Introducción

Puede sonar extraño, pero no lo hemos conseguido uno de los desafíos para el recuento de 1a n, ambos inclusive.

Esto no es lo mismo. Ese es un desafío (cerrado) no bien explicado.
Esto no es lo mismo. Esa se trata de contar indefinidamente.

Reto

Escribir un programa o función que imprime cada número entero de 1que nambos inclusive.

Reglas

• Puedes conseguir de ncualquier manera.
• Puede suponer que nsiempre será un número entero positivo.
• Puede ingresar nen cualquier base, pero siempre debe mostrar en decimal.
• La salida debe estar separada por cualquier carácter (o patrón) que no esté en 0123456789. Se permiten caracteres iniciales o finales no decimales (por ejemplo, cuando se utilizan matrices como [1, 2, 3, 4, 5, 6]).
• Las lagunas estándar son denegadas.
• Queremos encontrar el enfoque más corto en cada idioma, no el idioma más corto, por lo que no aceptaré ninguna respuesta.
• Debe actualizar sus respuestas después de esta edición, las respuestas publicadas antes de la última edición deben cumplir con la regla de cambio sobre las lagunas estándar (no quería negarlas, pero no quería hacer rugir a la comunidad, así que Los negué).
• Puede usar cualquier versión de idioma posterior a la fecha (o idioma). No puede usar ningún idioma o versión de idioma hecha solo para este desafío.

Bonos

20%

• Su programa debe poder contar al menos hasta 18446744073709551615( 2^64-1). Por ejemplo, si un nuevo tipo de datos es la única forma de admitir enteros grandes, debe construirlo. Si su idioma no tiene ninguna forma de admitir enteros enormes de hasta 2 ^ 64-1, en su lugar debe admitirse el límite superior de ese idioma en particular.

EDITAR : he cambiado el límite de 2^64a 2^64-1para permitir más respuestas.

EDITAR : convertí la regla 2 ^ 64-1 en un extra, ya que no ha habido mucho interés en este desafío. Si su respuesta admite 2 ^ 64-1, ahora puede editarla para incluir la bonificación. Además, puede publicar una respuesta que no sea compatible, si es más corta.

MarioLANG , 29 bytes

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

Pruébalo en línea!

Sé que mi código es tristemente súper triste o enojado:

> :(

Happy MarioLANG, 46 bytes

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

Pruébalo en línea!

Un enfoque más feliz:

 :)

MarioLANG no emocional, 41 bytes

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

Pruébalo en línea!

Pyth, 1 byte

S

_{El cuerpo debe tener al menos 30 caracteres; entraste en 14.}

Cjam, 5 bytes

{,:)}

Pruébalo en línea!

Este es un bloque sin nombre que espera nen la pila y deja una lista con el rango [1...n].
Funciona simplemente construyendo el rango con ,y luego incrementando cada elemento de rango :)para hacer que el rango se base en uno.

Mathematica, 5 bytes

Range

Suficientemente simple.

Hexagonía, 19

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

O en el formato de hexágono expandido:

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

Muchas gracias a Martin para básicamente viene con este programa, sólo se jugó golf para caber en un hexágono longitud del lado 3.

Pruébalo en línea!

No tengo los fantásticos programas relacionados con la Hexagonía de Timwi, por lo que esta explicación no será muy colorida. En cambio, puedes leer una gran cantidad de texto. ¿No es lindo?

En cualquier caso, la IP comienza en la esquina superior izquierda, en el $, moviéndose hacia el este si imagina que este programa se colocó con el norte hacia arriba en un mapa. Esto $nos hace omitir la siguiente instrucción, que sería @, que finalizaría el programa. En su lugar, ejecutamos lo ?que establece que el borde de la memoria actual sea el número de entrada. Ahora llegamos al final de la fila, que nos lleva a la fila central del hexágono, aún moviéndonos hacia el este.

La mayor parte del resto del programa es un bucle. Comenzamos con lo .que es un no-op. Luego nos encontramos con una bifurcación en el ... uh ... hexágono ... la <instrucción hace que la IP gire 60 grados a la derecha si el borde de memoria actual es positivo, de lo contrario giramos 60 grados a la izquierda. Como nos estamos moviendo hacia el este, terminamos con nuestro rumbo sur o noreste. Como la entrada es mayor que cero (y, por lo tanto, positiva), siempre comenzamos yendo hacia el sudeste.

Luego golpeamos un >que nos redirige hacia el este; estos operadores solo se bifurcan si golpeas la parte de la bifurcación. Luego golpeamos en la parte inferior derecha. Esto imprime el mod 256 de borde de memoria actual como ASCII. Esto pasa a ser una nueva línea. Golpeamos, lo que nos lleva de vuelta al primer borde que tiene el valor que leemos.' qué cambia qué borde de memoria estamos viendo. Luego tocamos )que incrementa el valor del borde de memoria actual. Como todos los bordes de la memoria comienzan en 0, la primera vez que hacemos esto obtenemos un valor de 1. Luego saltamos a la segunda línea superior y ejecutamos, lo !que imprime nuestro número. Luego nos movemos a otra arista con {y almacenamos el valor ASCII de M multiplicado por 10 más 8 (778). Luego saltamos de regreso a la penúltima línea del hexágono y golpeamos el /. Esto nos lleva a mudarnos al noroeste. Pasamos .por la fila del medio y salimos por la;'/ a movernos hacia el Este nuevamente. Luego tocamos (que disminuye el valor. =hace que volvamos a mirar en la dirección correcta para el salto de borde de memoria futuro.

Ahora, dado que el valor es positivo (a menos que sea cero) volvemos a la parte inferior del hexágono. Aquí golpeamos, .luego saltamos sobre el, ;así que no pasa nada, y volvemos al inicio del ciclo. Cuando el valor es cero, volvemos al comienzo del programa, donde vuelve a ocurrir lo mismo pero ?no encuentra otro número, y tomamos la otra ruta de ramificación. Ese camino es relativamente simple: tocamos lo {que cambia el borde de la memoria, pero ya no nos importa, luego tocamos lo @que finaliza el programa.

MATL, 1 byte

:

Salida de ejemplo:

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

Pruébalo en línea aquí

GNU Coreutils, 6 bytes

seq $1

respuesta dividida a bash puro, ver más abajo ...

R, 13 bytes

cat(1:scan())

El cuerpo debe tener al menos 30 caracteres.

Javascript 182 177 160 154 139 138 132 bytes (válido)

1 byte guardado gracias a @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``)}}

¡Precisión arbitraria al rescate!

Debido a que javascript solo puede contar hasta 2 ^ 53-1 (gracias a @ MartinBüttner por señalarlo), necesitaba crear una precisión arbitraria para hacer esto. Almacena datos en una matriz, y cada "marca" agrega 1 al último elemento, luego pasa por la matriz, y si algo excede 9, establece ese elemento en 0 y agrega 1 al que está en la mano izquierda.

Pruébalo aquí! Nota: presione F12, para ver realmente el resultado, ya que no quería hacerle esperar a los cuadros de texto.

BTW .: Yo era el único, que no sabía, los operadores ternarios son tan útiles en codegolf.

if(statement)executeSomething();

es más largo que

statement?executeSomething():0;

por 1 byte.

Javascript, 28 bytes (inválido - no puede contar hasta 2 ⁶⁴ )

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

Java 8, 43/69/94 bytes

^{_{Tachado 44 sigue siendo un 44 normal - espera, no lo taché, solo lo reemplacé :(}}

Si puedo devolver un LongStream: ( 43 bytes)

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

Esta es una lambda para a Function<Long,LongStream>. Técnicamente, debería usar en rangeClosedlugar de range, ya que estoy cortando uno de mi entrada máxima de esta manera, pero rangeClosedes más largo que range.

Si tengo que imprimir en la función: ( 69 bytes)

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

Esta es una lambda para a Consumer<Long>. Técnicamente estoy abusando peek, ya que es una operación intermedia , lo que significa que esta lambda está volviendo técnicamente LongStreamcomo el primer ejemplo; Debería estar usando en su forEachlugar. Nuevamente, el golf no es un buen código.

Por desgracia, ya que long's gama es una firmado entero de 64 bits, que no llega a la solicitada 2^64-1, sino que simplemente2^63-1 .

Sin embargo , Java SE 8 proporciona funcionalidad para tratar longlos mensajes de correo electrónico como si no estuvieran firmados, al llamar Longexplícitamente a métodos específicos de la clase. Desafortunadamente, como Java sigue siendo Java, esto es bastante largo, aunque más corto que la versión BigInteger que reemplaza. ( 94 bytes)

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

Este es un Consumer<Long>, como el anterior.

^{_{Y demasiado tiempo para evitar el desplazamiento.}}

05AB1E , 1 byte

Código:

L

Pruébalo en línea! .

Un enfoque más interesante:

FN>,

Explicación:

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

Pruébalo en línea! .

MATLAB, 7 bytes

Una función anónima sin nombre:

@(n)1:n

Correr como:

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

¡Pruébalo aquí!

Si se requiere un programa completo, 17 bytes:

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

¡Pruébalo aquí!

Haskell, 10 bytes

f n=[1..n]

Ejemplo de uso: f 4-> [1,2,3,4].

MarioLANG , 19 bytes

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

Pruébalo en línea!

Los programas verticales suelen ser más golfables para bucles simples en MarioLANG. No estoy seguro de lo que hace el intérprete cuando se encuentra [dentro de un elevador, pero parece terminar el programa cuando la celda actual es 0. Ese es probablemente un truco útil en general.

Explicación

MarioLANG es un lenguaje similar a Brainfuck (con una cinta de memoria infinita de enteros de precisión arbitraria) donde el puntero de instrucción se parece a Mario caminando y saltando.

Mario comienza en la esquina superior izquierda y cae hacia abajo. ;lee un número entero de STDIN y lo coloca en la celda de memoria actual. Ahora tenga en cuenta que =es una celda de tierra para que Mario camine, "y #forme un elevador ( #siendo el comienzo) y !hace que Mario se detenga en el elevador para que no se vaya de inmediato. El >y <establece su dirección de movimiento. Podemos ver que esto da un bucle simple, que contiene el siguiente código:

)   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.

Ahora normalmente [, condicionalmente, Mario saltaría el siguiente dependiendo de si la celda actual es cero o no. Es decir, mientras el contador no sea cero, esto no hace nada. Sin embargo, parece que cuando Mario se encuentra un [momento en un elevador y la celda actual es 0, el programa simplemente termina inmediatamente con un error, lo que significa que ni siquiera necesitamos encontrar una manera de redirigirlo correctamente.

Joe - 2 o 6

Si bien puede utilizar la variante inclusiva de la función de rango ...

1R

..¡eso es aburrido! En su lugar, tomemos la suma acumulativa ( \/+) de una tabla de unidades de forma n ( 1~T).

\/+1~T

Pyth - 3 2 bytes

1 bytes guardados gracias a @DenkerAffe.

Sin usar el incorporado.

hM

Pruébalo en línea .

Pyke, 1 byte

S

Pruébalo aquí!

O 2 bytes sin el incorporado

mh

Pruébalo aquí!

#h

Pruébalo aquí!

Lh

Pruébalo aquí!

dc, 15

?[d1-d1<m]dsmxf

Entrada leída desde stdin. Esto cuenta desde n, empujando una copia de cada número a la pila. La pila se genera como una con el fcomando, por lo que los números se imprimen en el orden ascendente correcto.

Debido a que todos los números se envían a la pila, es muy probable que se quede sin memoria antes de acercarse a 2 ^ 64. Si esto es un problema, entonces podemos hacer esto en su lugar:

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

Lo único interesante es usar nx (donde n es el objetivo yx la variable incrementada) para probar el final del ciclo while en lugar de tener una variable dedicada, así que termino teniendo nx y n- (nx) = x en cada ciclo

Nota : Solo puedo contar hasta 2 ^ 31-1. Bueno, supongo que los Terminators no son un verdadero peligro después de todo.

Piet, 64 codeles

Con codelsize 20:

Npiet traza imágenes

Primer bucle:

Rastro restante para n=2:

Notas

• ¿Aún no responde Piet? ¡Déjame arreglar eso con mi primer programa Piet! Sin embargo, esto podría ser más corto con mejores rollos y menos manipulación del puntero ...

• El límite superior admitido depende de la implementación del intérprete. Teóricamente sería posible admitir números arbitrariamente grandes con el intérprete correcto.

• El delímetro es ETX(Ascii 3), sin embargo, esto no se puede mostrar correctamente en esta respuesta, así que los dejaré fuera. Funciona en la consola:

Salida

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Npiet traza para 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)}

Toma la entrada ncomo una cadena, debe admitir hasta 9007199254740991999999999

Explicado:

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

Entrada leída desde stdin. bcmaneja números de precisión arbitrarios por defecto, por lo que 2 ^ 64 max no es un problema.

En realidad, 1 byte

R

Aburrido aburrido es aburrido. Requiere una versión de 64 bits de Python 3 para llegar hasta el final 2**64.

Pruébalo en línea! (debido a las restricciones de memoria y longitud de salida, el intérprete en línea no puede ir muy alto).

Aquí hay una versión de 5 bytes que no requiere Python 3 de 64 bits y es un poco mejor en el uso de memoria:

W;DWX

Pruébalo en línea! (ver advertencias anteriores)

Fuzzy-Octo-Guacamole, 7 bytes

^!_[+X]

Explicación:

^ 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

Oración, 31 bytes (no competitivos)

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!

Pruébalo aquí

Cubix es un lenguaje 2D creado por @ETHProductions donde los comandos se envuelven en un cubo. Este programa se ajusta a un cubo con una longitud de borde de 2 de la siguiente manera.

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

• I obtiene la entrada entera
• 0 empuje 0 a la pila
• - restar los elementos principales de la pila
• ! si la verdad salta el siguiente comando @ termina
• ; pop el resultado de la resta de la pila
• ) incrementar la parte superior de la pila
• wmover ip a la derecha y continuar. Esto hace que caiga a la siguiente línea
• O generar la parte superior de la pila como un número
• N empujar salto de línea (10) a la pila
• o dar salida a un salto de línea
• wmover ip a la derecha y continuar. Esto hace que caiga a la siguiente cara
• ! porque TOS de verdad, salta el @ final
• ; Pop el salto de línea de la pila
• Ugirar a la izquierda en la -resta y reanudar desde allí

Python 2, 37 33 32 33 bytes

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

Presumiblemente funciona hasta 2**64y más allá.

Derribó cuatro bytes gracias a @dieter , y otro gracias a @orlp . Pero aparentemente, como descubrió @ Sp3000, range()podría tener problemas con valores más altos, por lo que la función se cambió axrange() . Nota: incluso xrange()podría tener problemas, al menos en 2.7.10 .

Zsh, 12 bytes

echo {1..$1}

Esto funciona porque las variables se expanden antes de las llaves.

V, 11 bytes

é1@añYpñdd

Como esto contiene UTF-8 desagradable e imprimibles, aquí hay un hexdump reversible:

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

V es un lenguaje inacabado que escribí, pero funciona desde commit 19 . Esta respuesta fue un poco más detallada de lo que me gustaría, pero eso se debe principalmente a que V no tiene conocimiento de enteros, solo cadenas. ¡Entonces es una respuesta decente! Esto va a trabajar hasta 2 ^ 64, pero es probable que tome una muy largo tiempo.

Para hacer que mi explicación sea más fácil de leer / escribir, trabajaré con esta "forma legible por humanos", que en realidad es cómo escribiría esto en vim.

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

Explicación:

'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.

Si se permiten lagunas, aquí hay una versión más corta que imprime 1 an, pero también imprime un 0 (8 bytes):

é0@añYp

Y en forma legible:

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

Esto es más corto porque <A-q>al final está implícito, por lo que no lo necesitamos si no tenemos que eliminar la última línea.