introduzione

Può sembrare strano, ma non abbiamo UNA sfida per contare da 1a n, compreso.

Questa non è la stessa cosa Quella è una sfida (chiusa) non ben spiegata.
Questa non è la stessa cosa Quello riguarda il conto alla rovescia a tempo indeterminato.

Sfida

Scrivere un programma o una funzione che consente di stampare ogni intero da 1al ncompreso.

Regole

• Puoi ottenere in nqualsiasi modo.
• Puoi presumere che nsarà sempre un numero intero positivo.
• Puoi entrare nin qualsiasi base, ma dovresti sempre produrre in decimale.
• L'output deve essere separato da qualsiasi carattere (o modello) non presente 0123456789. Sono consentiti caratteri iniziali o finali non decimali (ad esempio quando si utilizzano matrici come [1, 2, 3, 4, 5, 6]).
• Le scappatoie standard vengono negate.
• Vogliamo trovare l'approccio più breve in ogni lingua, non la lingua più breve, quindi non accetterò alcuna risposta.
• Devi aggiornare le tue risposte dopo questa modifica, le risposte pubblicate prima dell'ultima modifica devono essere conformi alla regola di modifica relativa alle scappatoie standard (non volevo negarle, ma non volevo far ruggire la comunità, quindi Li ho negati).
• Puoi usare qualsiasi versione (o lingua) post-datazione. Non puoi usare nessuna lingua o versione linguistica creata proprio per questa sfida.

bonus

20%

• Il tuo programma deve essere in grado di contare almeno fino a 18446744073709551615( 2^64-1). Ad esempio, se un nuovo tipo di dati è l'unico modo per supportare numeri interi grandi, è necessario costruirlo. Se la tua lingua non ha modo di supportare numeri interi enormi fino a 2 ^ 64-1, è invece necessario supportare il limite superiore di quella particolare lingua.

EDIT : ho modificato il limite da 2^64a 2^64-1per consentire più risposte.

EDIT : ho reso la regola 2 ^ 64-1 un bonus, poiché non c'è stato molto interesse per questa sfida. Se la tua risposta supporta 2 ^ 64-1, ora puoi modificarla per includere il bonus. Inoltre, puoi pubblicare una risposta non supportandola, se è più breve.

MarioLANG , 29 byte

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

Provalo online!

So che il mio codice è tristemente super-triste o arrabbiato:

> :(

Felice MarioLANG, 46 byte

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

Provalo online!

Un approccio più felice:

 :)

MarioLANG non emotivo, 41 byte

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

Provalo online!

Pyth, 1 byte

S

_{Il corpo deve contenere almeno 30 caratteri; hai inserito 14.}

Cjam, 5 byte

{,:)}

Provalo online!

Questo è un blocco senza nome che si aspetta nnello stack e lascia un elenco con l'intervallo [1...n]su di esso.
Funziona semplicemente costruendo l'intervallo con ,e quindi incrementando ogni elemento dell'intervallo con :)per rendere l'intervallo basato su uno.

Mathematica, 5 byte

Range

Abbastanza semplice.

Esagonia, 19

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

O nel formato esagonale espanso:

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

Un enorme grazie a Martin per aver sostanzialmente elaborato questo programma, l'ho appena giocato per adattarmi a un esagono di lunghezza laterale 3.

Provalo online!

Non ho i fantastici programmi Hexagony di Timwi, quindi questa spiegazione non sarà molto colorata. Invece, puoi leggere un'enorme quantità di testo. Non è carino?

In ogni caso, l'IP inizia nell'angolo in alto a sinistra, sulla $, spostandosi verso est se immagini che questo programma sia stato posizionato con il nord rivolto verso l'alto su una mappa. Questo $ci fa saltare la prossima istruzione, che sarebbe @, che finirebbe il programma. Invece, eseguiamo ?che imposta l'attuale fronte di memoria come numero di input. Ora raggiungiamo la fine della fila, che ci porta alla fila centrale dell'esagono, muovendoci ancora verso est.

La maggior parte del resto del programma è un loop. Iniziamo con la .no-op. Quindi incontriamo un fork nell'esagono ... uh ... l' <istruzione fa sì che l'IP ruoti di 60 gradi a destra se il bordo di memoria corrente è positivo, altrimenti ruotiamo di 60 gradi a sinistra. Dato che ci stiamo spostando verso est, o finiamo con la nostra rotta verso sud o nord est. Poiché l'input è maggiore di zero (e quindi positivo), iniziamo sempre andando verso sud-est.

Successivamente abbiamo colpito un >che ci reindirizza verso est; questi operatori si biforcano solo se si colpisce la parte della forcella. Quindi premiamo 'quale cambia il margine di memoria che stiamo guardando. Quindi premiamo )che incrementa il valore del bordo di memoria corrente. Poiché tutti i bordi della memoria iniziano da 0, la prima volta che lo facciamo otteniamo un valore di 1. Successivamente saliamo dalla seconda alla riga superiore ed eseguiamo !quale stampa il nostro numero. Quindi ci spostiamo su un altro bordo con {e memorizziamo il valore ASCII di M moltiplicato per 10 più 8 (778). Quindi torniamo alla penultima riga dell'esagono e colpiamo il /. Questo ci porta a spostarci a nord-ovest. Superiamo la .fila in mezzo e ne usciamo;in basso a destra. Questo stampa l'attuale bordo di memoria mod 256 come ASCII. Questa sembra essere una newline. Colpiamo, il 'che ci riporta al primo spigolo che ha il valore in cui leggiamo. Il colpo /che ci spinge a spostarci di nuovo verso est. Quindi (colpiamo quale diminuisce il valore. =ci fa affrontare nuovamente la giusta direzione per il futuro salto della memoria.

Ora, poiché il valore è positivo (a meno che non sia zero) torniamo alla fine dell'esagono. Qui colpiamo, .quindi saltiamo sopra, ;quindi non succede nulla e torniamo all'inizio del loop. Quando il valore è zero torniamo all'inizio del programma, dove le stesse cose succedono di nuovo ma ?non riesce a trovare un altro numero e prendiamo l'altro percorso di ramificazione. Quel percorso è relativamente semplice: colpiamo {che cambia il bordo della memoria, ma non ci interessa più, quindi colpiamo @che termina il programma.

MATL, 1 byte

:

Esempio di output:

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

Provalo online qui

GNU Coreutils, 6 byte

seq $1

Dividi la risposta a pure bash, vedi sotto ...

R, 13 byte

cat(1:scan())

Il corpo deve contenere almeno 30 caratteri.

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

1 byte salvato grazie 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``)}}

Precisione arbitraria in soccorso!

Poiché javascript può contare solo fino a 2 ^ 53-1 (grazie a @ MartinBüttner per averlo sottolineato), ho dovuto creare una precisione arbitraria per farlo. Memorizza i dati in un array e ogni "segno di spunta" aggiunge 1 all'ultimo elemento, quindi passa attraverso l'array e, se qualcosa supera 9, imposta tale elemento su 0 e aggiunge 1 a quello sulla mano sinistra.

Provalo qui! Nota: premi F12 per vedere effettivamente il risultato, poiché non volevo farti aspettare le caselle di testo.

A proposito: ero l'unico, che non lo sapevo, gli operatori ternari sono così utili in Codegolf?

if(statement)executeSomething();

è più lungo di

statement?executeSomething():0;

di 1 byte.

Javascript, 28 byte (non valido - non può contare fino a 2 ⁶⁴ )

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

Java 8, 43/69/94 byte

^{_{Cancellato 44 è ancora un normale 44 - aspetta, non l'ho cancellato l'ho appena sostituito :(}}

Se posso restituire un LongStream: ( 43 bytes)

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

Questo è un lambda per a Function<Long,LongStream>. Tecnicamente, dovrei usare rangeClosedinvece di range, poiché sto tagliando uno dal mio massimo input in questo modo, ma rangeClosedè più lungo di range.

Se devo stampare nella funzione: ( 69 bytes)

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

Questo è un lambda per a Consumer<Long>. Tecnicamente sto abusando peek, poiché si tratta di un'operazione intermedia , il che significa che questa lambda sta tecnicamente restituendo un LongStreamsimile primo esempio; Dovrei usare forEachinvece. Ancora una volta, il golf non è un bel codice.

Purtroppo, dal momento che longgamma 's è un firmato intero a 64 bit, non raggiunge il richiesto 2^64-1, ma semplicemente 2^63-1.

Tuttavia , Java SE 8 fornisce funzionalità per trattare longi messaggi come se fossero senza segno, chiamando esplicitamente metodi specifici sulla Longclasse. Sfortunatamente, poiché Java è ancora Java, questo è piuttosto prolisso, sebbene più breve della versione di BigInteger che sostituisce. ( 94 bytes)

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

Questo è un Consumer<Long>, come il precedente.

^{_{E troppo a lungo per evitare lo scorrimento.}}

05AB1E , 1 byte

Codice:

L

Provalo online! .

Un approccio più interessante:

FN>,

Spiegazione:

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

Provalo online! .

MATLAB, 7 byte

Una funzione anonima senza nome:

@(n)1:n

Correre come:

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

Provalo qui!

Se è richiesto un programma completo, 17 byte:

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

Provalo qui!

Haskell, 10 byte

f n=[1..n]

Esempio di utilizzo: f 4-> [1,2,3,4].

MarioLANG , 19 byte

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

Provalo online!

I programmi verticali sono generalmente più golfabili per semplici loop in MarioLANG. Non sono sicuro di cosa faccia l'interprete quando si incontra [all'interno di un ascensore, ma sembra terminare il programma quando la cella corrente è 0. Questo è probabilmente un trucco utile in generale.

Spiegazione

MarioLANG è un linguaggio simile a Brainfuck (con un infinito nastro di memoria di numeri interi di precisione arbitraria) in cui il puntatore dell'istruzione ricorda Mario che cammina e salta in giro.

Mario inizia nell'angolo in alto a sinistra e cade verso il basso. ;legge un numero intero da STDIN e lo inserisce nella cella di memoria corrente. Ora nota che =è una cella di terra su cui camminare Mario, "che #forma un ascensore ( #essendo l'inizio) e !fa fermare Mario sull'ascensore in modo che non se ne vada subito. Il >e <impostare la sua direzione di movimento. Possiamo vedere che questo fornisce un semplice ciclo, contenente il seguente codice:

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

Ora normalmente [farebbe in modo condizionale Mario saltare il prossimo a seconda che la cella corrente sia zero o meno. Cioè, fintanto che il contatore è diverso da zero, questo non fa nulla. Tuttavia, sembra che quando Mario incontra un [istante in sella a un ascensore e la cella attuale è 0, il programma termina immediatamente immediatamente con un errore, il che significa che non abbiamo nemmeno bisogno di trovare un modo per reindirizzarlo correttamente.

Joe - 2 o 6

Mentre è possibile utilizzare la variante inclusiva della funzione intervallo.

1R

..è noioso! Prendiamo invece la somma cumulativa ( \/+) di una tabella di quelli di forma n ( 1~T).

\/+1~T

Pyth - 3 2 byte

1 byte salvato grazie a @DenkerAffe.

Senza usare il builtin.

hM

Provalo online .

Pyke, 1 byte

S

Provalo qui!

O 2 byte senza builtin

mh

Provalo qui!

#h

Provalo qui!

Lh

Provalo qui!

dc, 15

?[d1-d1<m]dsmxf

Ingresso letto dallo stdin. Questo fa il conto alla rovescia da n, spingendo una copia di ogni numero nella pila. Lo stack viene quindi emesso come uno con il fcomando, quindi i numeri vengono stampati nell'ordine crescente corretto.

Poiché tutti i numeri vengono inseriti nello stack, è molto probabile che questo rimanga a corto di memoria prima di arrivare ovunque vicino a 2 ^ 64. Se questo è un problema, possiamo invece farlo:

dc, 18

?sn0[1+pdln>m]dsmx

ArnoldC, 415 byte

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

L'unica cosa interessante è usare nx (dove n è l'obiettivo e x la variabile incrementata) per testare la fine del ciclo while invece di avere una variabile dedicata, quindi finisco per avere nx e n- (nx) = x in ogni ciclo

Nota : posso contare solo fino a 2 ^ 31-1. Beh, suppongo che i Terminator non siano un vero pericolo dopo tutto.

Piet, 64 codici

Con dimensione del codice 20:

Immagini di traccia Npiet

Primo ciclo:

Traccia rimanente per n=2:

Gli appunti

• Nessuna risposta Piet ancora? Consentitemi di risolverlo con il mio primo programma Piet in assoluto! Questo potrebbe probabilmente essere più breve con tiri migliori e meno manipolazione del puntatore però ...

• Il limite superiore supportato dipende dall'implementazione dell'interprete. In teoria sarebbe possibile supportare numeri arbitrariamente grandi con il giusto interprete.

• Il delimitatore è ETX(Ascii 3), tuttavia questo non può essere visualizzato correttamente in questa risposta, quindi li lascerò fuori. Funziona nella console:

Produzione

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Traccia Npiet per 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 byte

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

Accetta input ncome stringa, dovrebbe supportare fino a 9007199254740991999999999

Ha spiegato:

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

Ingresso letto dallo stdin. bcgestisce numeri di precisione arbitrari per impostazione predefinita, quindi il massimo 2 ^ 64 non è un problema.

In realtà, 1 byte

R

L'educazione noiosa è noiosa. Richiede una versione a 64 bit di Python 3 per arrivare fino in fondo 2**64.

Provalo online! (a causa delle restrizioni sulla lunghezza della memoria e dell'output, l'interprete online non può andare molto in alto).

Ecco una versione a 5 byte che non richiede Python 3 a 64 bit ed è un po 'più piacevole nell'uso della memoria:

W;DWX

Provalo online! (vedi sopra le avvertenze)

Fuzzy-Octo-Guacamole, 7 byte

^!_[+X]

Spiegazione:

^ 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 byte (non concorrenti)

literally, print range(input())

QBASIC, 43 byte

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

Cubix , 17 byte

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

Provalo qui

Cubix è un linguaggio 2D creato da @ETHProductions in cui i comandi sono racchiusi in un cubo. Questo programma si avvolge su un cubo con una lunghezza del bordo di 2 come segue.

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

• I ottiene l'input intero
• 0 spingere 0 nello stack
• - sottrarre gli oggetti principali dello stack
• !se la verità salta il comando successivo @termina
• ; pop il risultato di sottrazione dallo stack
• ) incrementare la parte superiore dello stack
• wsposta l'ip a destra e continua. Questo fa sì che passi alla riga successiva
• O emette la parte superiore dello stack come numero
• N spingere l'alimentazione di linea (10) nello stack
• o emette un avanzamento riga
• wsposta l'ip a destra e continua. Questo fa sì che passi alla faccia successiva
• !perché TOS in verità, salta la @fine
• ; pop il linefeed dallo stack
• Usvoltare a sinistra sulla -sottrazione e riprendere da lì

Python 2, 37 33 32 33 byte

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

Presumibilmente funziona fino 2**64e oltre.

Abbattuto quattro byte grazie @dieter , e un altro grazie a @orlp . Ma a quanto pare, come ha scoperto @ Sp3000, range()potrebbero avere problemi con valori più alti, quindi la funzione è stata cambiata inxrange() . Nota: anche xrange()potrebbe avere problemi, almeno in 2.7.10 .

Zsh, 12 byte

echo {1..$1}

Questo funziona perché le variabili vengono espanse prima delle parentesi graffe.

V, 11 byte

é1@añYpñdd

Dato che contiene cattivi UTF-8 e non stampabili, ecco un hexdump reversibile:

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

V è una lingua incompiuta che ho scritto, ma funziona a partire da commit 19 . Questa risposta è stata un po 'più dettagliata di quanto mi piacerebbe, ma principalmente perché V non ha conoscenza di numeri interi, ma solo di stringhe. Quindi è una risposta decente! Questo sarà lavorare fino a 2 ^ 64, ma ci vorranno probabilmente un molto tempo.

Per rendere la mia spiegazione più facile da leggere / scrivere, lavorerò con questo "modulo leggibile dall'uomo", che è in realtà il modo in cui lo scriverebbe in VIM.

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

Spiegazione:

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

Se sono consentite scappatoie, ecco una versione più corta che stampa da 1 a n, ma stampa anche uno 0 (8 byte):

é0@añYp

E in forma leggibile:

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

Questo è più breve perché <A-q>alla fine è implicito, quindi non ne abbiamo bisogno se non dobbiamo eliminare l'ultima riga.