pengantar

Ini mungkin terdengar aneh, tapi kami tidak punya satu tantangan bagi menghitung dari 1ke n, inklusif.

Ini bukan hal yang sama. Itu adalah tantangan (tertutup) yang tidak dijelaskan dengan baik.
Ini bukan hal yang sama. Yang itu tentang menghitung tanpa batas.

Tantangan

Menulis sebuah program atau fungsi yang mencetak setiap bilangan bulat dari 1ke ninklusif.

Aturan

• Anda bisa mendapatkan ncara apa pun.
• Anda dapat mengasumsikan bahwa nakan selalu menjadi bilangan bulat positif.
• Anda bisa mendapatkan nbasis apa pun, tetapi Anda harus selalu output dalam desimal.
• Output harus dipisahkan oleh karakter apa pun (atau pola) yang tidak ada di 0123456789. Karakter memimpin atau trailing non-desimal diizinkan (misalnya saat menggunakan array seperti [1, 2, 3, 4, 5, 6]).
• Celah standar ditolak.
• Kami ingin menemukan pendekatan terpendek dalam setiap bahasa, bukan bahasa terpendek, jadi saya tidak akan menerima jawaban apa pun.
• Anda harus memperbarui jawaban Anda setelah pengeditan ini, jawaban yang diposting sebelum pengeditan terakhir harus mematuhi aturan perubahan tentang celah standar (saya tidak ingin menyangkal mereka, tetapi saya tidak ingin membuat masyarakat mengaum, jadi Saya menyangkal mereka).
• Anda dapat menggunakan versi bahasa (atau bahasa) pasca-kencan apa pun. Anda tidak dapat menggunakan bahasa apa pun atau versi bahasa yang dibuat hanya untuk tantangan ini.

Bonus

20%

• Program Anda harus dapat menghitung setidaknya hingga 18446744073709551615( 2^64-1). Misalnya, jika tipe data baru adalah satu-satunya cara untuk mendukung bilangan bulat besar, Anda harus membuatnya. Jika bahasa Anda tidak memiliki cara apa pun untuk mendukung bilangan bulat besar hingga 2 ^ 64-1, batas atas bahasa tersebut harus didukung.

EDIT : Saya telah mengubah batas dari 2^64ke 2^64-1untuk memungkinkan lebih banyak jawaban.

EDIT : Saya menjadikan aturan 2 ^ 64-1 sebagai bonus, karena belum banyak minat pada tantangan ini. Jika jawaban Anda mendukung 2 ^ 64-1, Anda sekarang dapat mengeditnya untuk memasukkan bonus. Anda juga dapat memposting jawaban yang tidak mendukungnya, jika lebih pendek.

MarioLANG , 29 byte

;
)    <
+===="
>:(-[!
=====#

Cobalah online!

Saya tahu kode saya sangat sedih atau marah:

> :(

Selamat MarioLANG, 46 byte

;
)       <
+======="
>  >((-[!
=:)^====#
 ===

Cobalah online!

Pendekatan yang lebih bahagia:

 :)

MarioLANG non-emosional, 41 byte

;
)     <
+====="
> >(-[!
= "===#
 :!
 =#

Cobalah online!

Pyth, 1 byte

S

_{Badan harus minimal 30 karakter; Anda memasukkan 14.}

Cjam, 5 byte

{,:)}

Cobalah online!

Ini adalah blok tanpa nama yang mengharapkan npada tumpukan dan meninggalkan daftar dengan kisaran [1...n]di atasnya.
Bekerja dengan hanya membangun rentang dengan ,dan kemudian menambah setiap elemen rentang dengan :)membuat rentang berbasis satu.

Mathematica, 5 byte

Range

Cukup sederhana.

Hexagony, 19

$@?!{M8.</(=/>').$;

Atau dalam format segi enam yang diperluas:

  $ @ ?
 ! { M 8
. < / ( =
 / > ' ) 
  . $ ;

Terima kasih banyak untuk Martin karena pada dasarnya membuat program ini, saya hanya memasukkannya agar sesuai dengan segi 3 panjang sisi.

Cobalah online!

Saya tidak memiliki program Hexagony yang fantastis dari Timwi, jadi penjelasan ini tidak akan sangat berwarna. Sebaliknya, Anda bisa membaca gumpalan besar teks. Bukankah itu bagus?

Bagaimanapun, IP dimulai di sudut kiri atas, di $, bergerak ke arah Timur jika Anda membayangkan program ini ditempatkan dengan North menghadap ke atas pada peta. The $menyebabkan kita melewatkan instruksi berikutnya, yang akan @, yang akan mengakhiri program. Sebagai gantinya, kami mengeksekusi ?yang menetapkan tepi memori saat ini menjadi nomor input. Sekarang kita mencapai ujung barisan, yang membawa kita ke barisan tengah segi enam, masih bergerak ke arah Timur.

Sebagian besar sisa program adalah loop. Kita mulai dengan .yang merupakan no-op. Selanjutnya kita menemukan garpu di ... eh ... segi enam ... <instruksi menyebabkan IP berputar 60 derajat ke kanan jika tepi memori saat ini positif, jika tidak kita putar 60 derajat ke kiri. Karena kami bergerak ke arah Timur, kami akhirnya menuju ke Selatan atau Timur Laut. Karena input lebih besar dari nol (dan karenanya positif) kami selalu memulai dengan pergi ke Tenggara.

Selanjutnya kita tekan >yang mengarahkan kita ke arah Timur; operator ini hanya memotong jika Anda menekan bagian garpu. Lalu kami menekan 'yang mengubah tepi memori apa yang kita lihat. Lalu kami menekan )yang menambah nilai tepi memori saat ini. Karena semua tepi memori mulai dari 0, pertama kali kita melakukan ini, kita mendapatkan nilai 1. Selanjutnya kita melompat ke baris kedua ke atas dan menjalankan !yang mencetak nomor kita. Kemudian kita pindah ke sisi lain dengan {dan menyimpan nilai ASCII dari M dikalikan dengan 10 ditambah 8 (778). Lalu kita melompat kembali ke baris kedua ke terakhir dari segi enam, dan tekan tombol /. Ini mengakibatkan kami pindah ke Barat Laut. Kami melewati .di baris tengah, dan keluar di;di kanan bawah. Ini mencetak tepi memori saat ini mod 256 sebagai ASCII. Ini kebetulan merupakan baris baru. Kita menekan 'yang membawa kita kembali ke tepi pertama yang memiliki nilai yang kita baca. Kita memukul /yang membuat kita bergerak ke arah timur lagi. Lalu kami menekan (yang menurunkan nilai. =menyebabkan kita menghadapi arah yang benar lagi untuk lompatan tepi memori di masa depan.

Sekarang, karena nilainya positif (kecuali nol) kita kembali ke bagian bawah segi enam. Di sini kita menekan .lalu kita melompati ;sehingga tidak ada yang terjadi, dan kita kembali ke awal perulangan. Ketika nilainya nol kita kembali ke awal program, di mana hal yang sama terjadi lagi tetapi ?gagal menemukan nomor lain, dan kita mengambil jalur percabangan lainnya. Jalur itu relatif sederhana: kami menekan {yang mengubah tepi memori, tetapi kami tidak peduli lagi, lalu kami menekan @yang mengakhiri program.

MATL, 1 byte

:

Contoh output:

15
1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

Cobalah online di sini

GNU Coreutils, 6 byte

seq $1

pisahkan jawaban untuk bash murni, lihat di bawah ...

R, 13 byte

cat(1:scan())

Badan harus minimal 30 karakter.

Javascript 182 177 160 154 139 138 132 byte (valid)

1 byte disimpan berkat @ShaunH

n=>{c=[e=0];for(;c.join``!=n;){a=c.length-1;c[a]++;for(;a+1;a--){c[a]+=e;e=0;if(c[a]>9)c[a]=0,e++;}e&&c.unshift(1);alert(c.join``)}}

Presisi arbiter untuk penyelamatan!

Karena javascript hanya dapat menghitung hingga 2 ^ 53-1 (Terima kasih kepada @ MartinBüttner karena menunjukkannya), saya perlu membuat presisi arbiter untuk melakukan ini. Ini menyimpan data dalam sebuah array, dan setiap "centang" itu menambahkan 1 ke elemen terakhir, kemudian pergi melalui array, dan jika sesuatu melebihi 9, itu menetapkan elemen itu ke 0, dan menambahkan 1 ke yang di sebelah kiri.

Coba di sini! Catatan: tekan F12, untuk benar-benar melihat hasilnya, karena saya tidak ingin membuat Anda menunggu kotak teks.

BTW .: Saya adalah satu-satunya, yang tidak tahu, operator ternary sangat berguna dalam codegolf?

if(statement)executeSomething();

lebih panjang dari

statement?executeSomething():0;

dengan 1 byte.

Javascript, 28 byte (tidak valid - tidak dapat dihitung hingga ⁶⁴ )

n=>{for(i=0;i++<n;)alert(i)}

Java 8, 43/69/94 byte

^{_{Dicoret 44 masih tetap 44 - tunggu, saya tidak mencoretnya, saya hanya menggantinya :(}}

Jika saya dapat mengembalikan LongStream: ( 43 bytes)

n->java.util.stream.LongStream.range(1,n+1)

Ini adalah lambda untuk a Function<Long,LongStream>. Secara teknis, saya harus menggunakan rangeClosedbukan range, karena saya memotong satu dari input maksimum saya dengan cara ini, tetapi rangeClosedlebih lama dari itu range.

Jika saya harus mencetak dalam fungsi: ( 69 bytes)

n->java.util.stream.LongStream.range(1,n+1).peek(System.out::println)

Ini adalah lambda untuk a Consumer<Long>. Secara teknis saya menyalahgunakan peek, karena ini adalah operasi perantara , yang berarti lambda ini secara teknis mengembalikan LongStreamseperti contoh pertama; Saya harus menggunakan forEachsebagai gantinya. Sekali lagi, golf bukan kode yang bagus.

Sayangnya, karena longrange adalah integer 64-bit yang ditandatangani , ia tidak mencapai yang diminta 2^64-1, tetapi hanya 2^63-1.

Namun , Java SE 8 menyediakan fungsionalitas untuk mengobati longs seakan mereka unsigned, dengan memanggil metode tertentu di Longkelas secara eksplisit. Sayangnya, karena Java masih Java, ini agak bertele-tele, meskipun lebih pendek dari versi BigInteger yang digantikannya. ( 94 bytes)

n->{for(long i=0;Long.compareUnsigned(i,n)<0;)System.out.println(Long.toUnsignedString(++i));}

Ini adalah Consumer<Long>, seperti sebelumnya.

^{_{Dan terlalu lama untuk menghindari gulir.}}

05AB1E, 1 byte

Kode:

L

Cobalah online!.

Pendekatan yang lebih menarik:

FN>,

Penjelasan:

F     # For N in range(0, input):
 N>   #   Push N + 1
   ,  #   Pop and print with a newline

Cobalah online! .

MATLAB, 7 bytes

Fungsi anonim tanpa nama:

@(n)1:n

Jalankan sebagai:

ans(10)
ans =
     1     2     3     4     5     6     7     8     9    10

Uji di sini!

If a full program is required, 17 bytes:

disp(1:input(''))
10
     1     2     3     4     5     6     7     8     9    10

Test it here!

Haskell, 10 bytes

f n=[1..n]

Usage example: f 4-> [1,2,3,4].

MarioLANG, 19 bytes

;
)<
+"
:[
(-
>!
=#

Try it online!

Vertical programs are usually more golfable for simple loops in MarioLANG. I'm not sure what the interpreter does when encountering [ inside an elevator, but it seems to terminate the program when the current cell is 0. That's probably a useful trick in general.

Explanation

MarioLANG is a Brainfuck-like language (with an infinite memory tape of arbitrary-precision integers) where the instruction pointer resembles Mario walking and jumping around.

Mario starts in the top left corner and falls downward. ; reads an integer from STDIN and places it in the current memory cell. Now note that = is a ground cell for Mario to walk on, the " and # form an elevator (with # being the start) and ! makes mario stop on the elevator so that he doesn't walk off right away. The > and < set his movement direction. We can see that this gives a simple loop, containing the following code:

)   Move memory pointer one cell right.
+   Increment (initially zero).
:   Print as integer, followed by a space.
(   Move memory pointer one cell left.
-   Decrement.
[   Conditional, see below.

Now normally [ would conditionally make Mario skip the next depending on whether the current cell is zero or not. That is, as long as the counter is non-zero this does nothing. However, it seems that when Mario encounters a [ while riding an elevator and the current cell is 0, the program simply terminates immediately with an error, which means we don't even need to find a way to redirect him correctly.

Joe - 2 or 6

While you can use the inclusive variant of the range function..

1R

..that's boring! Let's instead take the cumulative sum (\/+) of a table of ones of shape n (1~T).

\/+1~T

Pyth - 3 2 bytes

1 bytes saved thanks to @DenkerAffe.

Without using the builtin.

hM

Try it online.

Pyke, 1 byte

S

Try it here!

Or 2 bytes without the builtin

mh

Try it here!

#h

Try it here!

Lh

Try it here!

dc, 15

?[d1-d1<m]dsmxf

Input read from stdin. This counts down from n, pushing a copy of each numbers to the stack. The stack is then output as one with the f command, so the numbers get printed in the correct ascending order.

Because all the numbers are pushed to the stack, this is highly likely to run out of memory before getting anywhere near 2^64. If this is a problem, then we can do this instead:

dc, 18

?sn0[1+pdln>m]dsmx

ArnoldC, 415 bytes

IT'S SHOWTIME
HEY CHRISTMAS TREE n
YOU SET US UP 0
GET YOUR ASS TO MARS n
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
HEY CHRISTMAS TREE x
YOU SET US UP n
STICK AROUND x
GET TO THE CHOPPER x
HERE IS MY INVITATION n
GET DOWN x
GET UP 1
ENOUGH TALK
TALK TO THE HAND x
GET TO THE CHOPPER x
HERE IS MY INVITATION n
GET DOWN x
ENOUGH TALK
CHILL
YOU HAVE BEEN TERMINATED

The only thing of interest is to use n-x (where n is the goal and x the incremented variable) to test the end of the while loop instead of having a dedicated variable, so I end up having n-x and n-(n-x) = x in each loop run

Note: I can only count to 2^31-1. Well I guess the Terminators are not a real danger after all.

Piet, 64 Codels

With codelsize 20:

Npiet trace images

First loop:

Remaining trace for n=2:

Notes

• Belum ada jawaban Piet? Biarkan saya memperbaikinya dengan program Piet pertama saya! Ini mungkin bisa lebih pendek dengan gulungan yang lebih baik dan manipulasi pointer ...

• Batas yang didukung atas tergantung pada implementasi penerjemah. Secara teori dimungkinkan untuk mendukung jumlah besar yang sewenang-wenang dengan juru bahasa yang tepat.

• Delimeter adalah ETX(Ascii 3), namun ini tidak dapat ditampilkan dengan benar dalam jawaban ini jadi saya hanya akan mengabaikannya. Ini bekerja di konsol:

Keluaran

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Jejak npiet untuk n=2

trace: step 0  (0,0/r,l nR -> 1,0/r,l lB):
action: in(number)
? 2
trace: stack (1 values): 2

trace: step 1  (1,0/r,l lB -> 2,0/r,l nB):
action: push, value 1
trace: stack (2 values): 1 2

trace: step 2  (2,0/r,l nB -> 3,0/r,l nG):
action: duplicate
trace: stack (3 values): 1 1 2

trace: step 3  (3,0/r,l nG -> 4,0/r,l dY):
action: out(number)
1
trace: stack (2 values): 1 2

trace: step 4  (4,0/r,l dY -> 5,0/r,l lY):
action: push, value 1
trace: stack (3 values): 1 1 2

trace: step 5  (5,0/r,l lY -> 6,0/r,l lG):
action: add
trace: stack (2 values): 2 2

trace: step 6  (6,0/r,l lG -> 7,0/r,l lR):
action: duplicate
trace: stack (3 values): 2 2 2

trace: step 7  (7,0/r,l lR -> 10,0/r,l nR):
action: push, value 3
trace: stack (4 values): 3 2 2 2

trace: step 8  (10,0/r,l nR -> 12,0/r,l dR):
action: push, value 2
trace: stack (5 values): 2 3 2 2 2

trace: step 9  (12,0/r,l dR -> 13,0/r,l lB):
action: roll
trace: stack (3 values): 2 2 2

trace: step 10  (13,0/r,l lB -> 14,0/r,l lG):
action: duplicate
trace: stack (4 values): 2 2 2 2

trace: step 11  (14,0/r,l lG -> 15,2/d,r nG):
action: push, value 3
trace: stack (5 values): 3 2 2 2 2

trace: step 12  (15,2/d,r nG -> 15,3/d,r dG):
action: push, value 1
trace: stack (6 values): 1 3 2 2 2 2

trace: step 13  (15,3/d,r dG -> 14,3/l,l lR):
action: roll
trace: stack (4 values): 2 2 2 2

trace: step 14  (14,3/l,l lR -> 13,1/l,r lC):
action: greater
trace: stack (3 values): 0 2 2

trace: step 15  (13,1/l,r lC -> 11,1/l,r nC):
action: push, value 3
trace: stack (4 values): 3 0 2 2

trace: step 16  (11,1/l,r nC -> 10,1/l,r lB):
action: multiply
trace: stack (3 values): 0 2 2

trace: step 17  (10,1/l,r lB -> 9,1/l,r nY):
action: pointer
trace: stack (2 values): 2 2

trace: step 18  (9,1/l,r nY -> 7,1/l,r dY):
action: push, value 2
trace: stack (3 values): 2 2 2

trace: step 19  (7,1/l,r dY -> 6,1/l,r lY):
action: push, value 1
trace: stack (4 values): 1 2 2 2

trace: step 20  (6,1/l,r lY -> 5,1/l,r nM):
action: roll
trace: stack (2 values): 2 2

trace: step 21  (5,1/l,r nM -> 4,1/l,r dM):
action: push, value 3
trace: stack (3 values): 3 2 2

trace: step 22  (4,1/l,r dM -> 3,1/l,r lG):
action: pointer
trace: stack (2 values): 2 2

trace: step 23  (3,1/d,r lG -> 2,3/l,l nG):
action: push, value 3
trace: stack (3 values): 3 2 2

trace: step 24  (2,3/l,l nG -> 2,2/u,r lY):
action: out(char)

trace: stack (2 values): 2 2
trace: white cell(s) crossed - continuing with no command at 2,0...

trace: step 25  (2,2/u,r lY -> 2,0/u,r nB):

trace: step 26  (2,0/u,r nB -> 3,0/r,l nG):
action: duplicate
trace: stack (3 values): 2 2 2

trace: step 27  (3,0/r,l nG -> 4,0/r,l dY):
action: out(number)
2
trace: stack (2 values): 2 2

trace: step 28  (4,0/r,l dY -> 5,0/r,l lY):
action: push, value 1
trace: stack (3 values): 1 2 2

trace: step 29  (5,0/r,l lY -> 6,0/r,l lG):
action: add
trace: stack (2 values): 3 2

trace: step 30  (6,0/r,l lG -> 7,0/r,l lR):
action: duplicate
trace: stack (3 values): 3 3 2

trace: step 31  (7,0/r,l lR -> 10,0/r,l nR):
action: push, value 3
trace: stack (4 values): 3 3 3 2

trace: step 32  (10,0/r,l nR -> 12,0/r,l dR):
action: push, value 2
trace: stack (5 values): 2 3 3 3 2

trace: step 33  (12,0/r,l dR -> 13,0/r,l lB):
action: roll
trace: stack (3 values): 2 3 3

trace: step 34  (13,0/r,l lB -> 14,0/r,l lG):
action: duplicate
trace: stack (4 values): 2 2 3 3

trace: step 35  (14,0/r,l lG -> 15,2/d,r nG):
action: push, value 3
trace: stack (5 values): 3 2 2 3 3

trace: step 36  (15,2/d,r nG -> 15,3/d,r dG):
action: push, value 1
trace: stack (6 values): 1 3 2 2 3 3

trace: step 37  (15,3/d,r dG -> 14,3/l,l lR):
action: roll
trace: stack (4 values): 2 3 2 3

trace: step 38  (14,3/l,l lR -> 13,1/l,r lC):
action: greater
trace: stack (3 values): 1 2 3

trace: step 39  (13,1/l,r lC -> 11,1/l,r nC):
action: push, value 3
trace: stack (4 values): 3 1 2 3

trace: step 40  (11,1/l,r nC -> 10,1/l,r lB):
action: multiply
trace: stack (3 values): 3 2 3

trace: step 41  (10,1/l,r lB -> 9,1/l,r nY):
action: pointer
trace: stack (2 values): 2 3
trace: white cell(s) crossed - continuing with no command at 9,3...

trace: step 42  (9,1/d,r nY -> 9,3/d,l nR):

JavaScript (ES6), 77 76 63 59 58 Bytes

n=>{for(s=a=b=0;s!=n;console.log(s=[a]+b))a+=!(b=++b%1e9)}

Mengambil input nsebagai string, harus mendukung hingga 9007199254740991999999999

Dijelaskan:

n=>{ //create function, takes n as input
    for( //setup for loop
        s=a=b=0; //init s, a, and b to 0
        s!=n; //before each cycle check if s!=n
        console.log(s=[a]+b) //after each cycle concat a and b into to s and print
    )
        a+=!(b=++b%1e9) //During each cycle set b to (b+1)mod 1e9, if b == 0 and increment a
} //Wrap it all up

GNU bc, 23

n=read()
for(;i++<n;)i

Input read from stdin. bc handles arbitrary precision numbers by default, so the 2^64 max is no problem.

Actually, 1 byte

R

Boring builtin is boring. Requires a 64-bit version of Python 3 to get all the way up to 2**64.

Try it online! (due to memory and output length restrictions, the online interpreter can't go very high).

Here's a 5-byte version that doesn't require 64-bit Python 3 and is a little nicer on memory usage:

W;DWX

Try it online! (see above caveats)

Fuzzy-Octo-Guacamole, 7 bytes

^!_[+X]

Explanation:

^ get input to ToS
! set for loop to ToS
_ pop
[ start for loop
+ increment ToS (which aparently happens to be 0)
X print ToS
] end for loop

Oration, 31 bytes (non competing)

literally, print range(input())

QBASIC, 43 bytes

1 INPUT a
2 FOR b=1 TO a
3 PRINT b
4 NEXT b

Cubix, 17 bytes

..U;I0-!@;)wONow!

Try it here

Cubix is a 2D language created by @ETHProductions where the commands are wrapped onto a cube. This program wraps onto a cube with an edge length of 2 as follows.

    . .
    U ;
I 0 - ! @ ; ) w
O N o w ! . . .
    . .
    . .

• I gets the integer input
• 0 push 0 to the stack
• - subtract top items of stack
• ! if truthy jump the next command @ terminate
• ; pop the subtraction result from the stack
• ) increment top of stack
• w move ip to the right and carry on. This causes it to drop to the next line
• O output the top of stack as a number
• N push linefeed (10) to the stack
• o output a linefeed
• w move ip to the right and carry on. This causes it to drop to the next face
• ! because TOS truthy, jump the @ terminate
• ; pop the linefeed from the stack
• U uturn to the left onto the - subtraction and resume from there

Python 2, 37 33 32 33 bytes

for i in xrange(input()):print-~i

Presumably works up to 2**64 and beyond.

Shot down four bytes thanks to @dieter, and another thanks to @orlp. But apparently, as @Sp3000 found out, range() might have issues with higher values, so the function was changed to xrange(). Note: even xrange() might have issues, at least in 2.7.10.

Zsh, 12 bytes

echo {1..$1}

This works because variables are expanded before the braces.

V, 11 Bytes

é1@añYpñdd

Since this contains nasty UTF-8 and unprintables, here is a reversible hexdump:

00000000: e931 4061 f159 7001 f164 64              .1@a.Yp..dd

V is an unfinished language I wrote, but this is working as of commit 19. This answer was a little more verbose than I'd like, but that's mostly because V has no knowledge of integers, only strings. So it's a decent answer! This will work up to 2^64, but it will probably take a very long time.

To make my explanation easier to read/write, I will work with this "Human readable form", which is actually how you would type this in vim.

<A-i>1@a<A-q>Yp<C-a><A-q>dd

Explanation:

'Implicit: register "a" == arg 1, and any generated text is printed. 

<A-i>1                       'Insert a single character: "1"
      @a                     ' "a" times, 
        <A-q>       <A-q>    'Repeat the following:
             Yp<C-a>         'Duplicate the line, and increment it
                         dd  'Delete the last line, since we have one too many.

If loopholes are allowed, here's a shorter version that prints 1 to n, but also prints a 0 (8 bytes):

é0@añYp

And in readable form:

<A-i>1@a<A-q>Yp<C-a>

This is shorter because the <A-q> at the end is implicit, so we don't need it if we don't have to delete the last line.