Il tuo compito è quello di scrivere un programma completo che continuerà il conto alla rovescia da 10 ogni volta che viene eseguito.

• La prima volta che esegui il programma, dovrebbe essere stampato 10.
• La prossima volta, dovrebbe essere emesso 9.
• La prossima volta, dovrebbe essere emesso 8e così via.
• Invece di stampare 0, il programma dovrebbe bloccarsi. Successivamente non è necessario gestire il programma in esecuzione più volte.
• Qualsiasi struttura utilizzata per l'archiviazione può essere considerata vuota prima della prima esecuzione del programma.

Ecco un'implementazione di esempio in Python 3:

try:f=open("a","r+");v=int(f.read())
except:f=open("a","w");v=10
1/v
print(v)
f.seek(0)
f.write(str(v-1))

Questo è code-golf , quindi vince la risposta più breve (misurata in byte).

6502 linguaggio macchina + Apple] [+ ROM, 12 (11? 10? 9?) Byte

CE 06 80 F0 01 A2 0B A9 00 4C 24 ED

Dovrebbe iniziare alle $8000. Si arresta in modo anomalo sul monitor di sistema quando il conteggio raggiunge 0.

C6 B6 F0 01 A2 0B A9 00 4C 24 ED

Dovrebbe iniziare alle $B1. Ciò consente di risparmiare un byte poiché posso utilizzare la versione (a due byte) della pagina zero di DEC, ma sovrascrive la routine critica di Applesoft CHRGET; dovrai caricarlo e chiamarlo dal monitor e, al termine, utilizzare CTRL+ BReturnper reinizializzare BASIC. Non sono sicuro se questo lo invalida o meno.

CE 06 80 F0 01 A2 0B 4C 26 ED

Dovrebbe iniziare alle $8000. Questo non si inizializza $9E, salvando due byte. Tuttavia, ciò significa che non è necessario chiamarlo con un indirizzo negativo (o, se lo si chiama dal monitor, è necessario chiamare il monitor con un indirizzo positivo). Se lo fai, di Applesoft CALLroutine memorizzare FFin $9E, inducendolo a aggiungi 65280 al numero quando stamparlo. Ancora una volta, non sono sicuro se questo invalida la soluzione o meno.

C6 B6 F0 01 A2 0B 4C 26 ED

Dovrebbe iniziare alle $B1. Questa è una combinazione dei due programmi precedenti, che salva un totale di tre byte; dovrai chiamare il monitor con un indirizzo positivo, caricarlo ed eseguirlo da lì, e usare Ctrl+ BReturnper reinizializzare BASIC al termine.

Si noti che questi programmi modificano solo il programma in memoria; il nuovo caricamento del programma dal disco ripristinerà il conto alla rovescia. Questo funziona perché Apple] [(e] [+, // e e // c) non ha alcun sistema di protezione della memoria; il programma (e le sue auto-modifiche) rimarranno in memoria anche dopo la sua uscita, quindi puoi continuare a eseguirlo dalla memoria fino a quando non sovrascrivi quella memoria con qualcos'altro.

Esecuzione del campione

]BLOAD COUNT THEN BRK
]CALL 32768
10
]CALL 32768
9
]CALL 32768
8
]CALL 32768
7
]CALL 32768
6
]CALL 32768
5
]CALL 32768
4
]CALL 32768
3
]CALL 32768
2
]CALL 32768
1
]CALL 32768

8008-    A=80 X=9D Y=00 P=36 S=EE
*

Spiegazione

     DEC NUM+1  ; Decrement the LDX instruction's operand
     BEQ NUM+1  ; If it is now zero, branch to it; 00 is the opcode for the BRK instruction, which causes the program to crash to the monitor
NUM  LDX #$0B   ; Load the X register with 0x0A; the operand has already been decremented once
     LDA #$00   ; Load the accumulator with 0
     JMP $ED24  ; Jump to $ED24, an Applesoft ROM routine which prints A (high byte),X (low byte) in decimal

Spiegazione della versione a 10 byte

     DEC NUM+1  ; Decrement the LDX instruction's operand
     BEQ NUM+1  ; If it is now zero, branch to it; 00 is the opcode for the BRK instruction, which causes the program to crash to the monitor
NUM  LDX #$0B   ; Load the X register with 0x0A; the operand has already been decremented once
     JMP $ED26  ; Jump to $ED26, which is two bytes into the Applesoft routine at $ED24. The two skipped bytes would store the accumulator in $9E

varianti

Stampa ERRe emette un segnale acustico quando il conteggio raggiunge 0

Normale - 15 byte

CE 06 80 F0 07 A2 0B A9 00 4C 24 ED 4C 2D FF

Sovrascrive CHRGET- 14 byte

C6 B6 F0 07 A2 0B A9 00 4C 24 ED 4C 2D FF

Non inizializza $9E- 13 byte

CE 06 80 F0 05 A2 0B 4C 26 ED 4C 2D FF

Sovrascrive CHRGETe non si inizializza $9E- 12 byte

C6 B6 F0 05 A2 0B 4C 26 ED 4C 2D FF

Si blocca quando il conteggio raggiunge 0

Normale - 12 byte

CE 06 80 F0 FE A2 0B A9 00 4C 24 ED

Sovrascrive CHRGET- 11 byte

C6 B6 F0 FE A2 0B A9 00 4C 24 ED

Non inizializza $9E- 10 byte

CE 06 80 F0 FE A2 0B 4C 26 ED

Sovrascrive CHRGETe non si inizializza $9E- 9 byte

C6 B6 F0 FE A2 0B 4C 26 ED

Perl su Linux, 17 byte

Ho pensato che potesse essere interessante creare un programma che non mantenga alcuno stato e non modifichi il proprio codice sorgente; in altre parole, controlla effettivamente quanto spesso è stato eseguito chiedendo al sistema operativo. La domanda dice "Qualsiasi struttura utilizzata per l'archiviazione può essere considerata vuota prima della prima esecuzione del programma", e quindi vorremmo iniziare da un sistema operativo completamente vuoto. Come tale, è meglio che ti spieghi come si fa a farlo, altrimenti testare il programma è difficile.

Esistono in realtà due modi per impostare l'esecuzione del programma. In entrambi i casi, il sistema operativo minimo allo scopo non eseguirà altro che una shell (per consentirci di eseguire Perl a sua volta), e la shell più semplice possibile in questo (in modo che non faccia nulla di fantasia che renda il sistema operativo non- vuoto). /bin/dashè una buona scelta qui, poiché era inteso come una shell minima per il ripristino del sistema. Quindi, abbiamo bisogno di avviare Linux in modo tale che non esegua altro che dash. Possiamo farlo riavviando il computer con init=/bin/dashdalla riga di comando di Linux in modo che non inizi nulla oltre dash, oppure (molto più convenientemente) creando un contenitore Linux usando unshare -Urfp /bin/dashin un terminale (in unsharerealtà non crea un sistema operativo vuoto, ma simulauno; in particolare, l'interno del contenitore pensa che sia root, dashpensa che sia init, ecc., proprio come accadrebbe su un vero sistema operativo vuoto). Disclaimer: non l'ho ancora testato su bare metal, solo all'interno unshare, ma in teoria dovrebbe funzionare in entrambi i modi.

Alla fine, una volta che abbiamo impostato questo, dobbiamo semplicemente guardare il PID; dato che siamo su un sistema vuoto, il sistema init (qui, la shell) avrà PID 1, quindi le esecuzioni di Perl avranno PID da 2 a 12 inclusi. Quindi il nostro programma è simile al seguente:

say 12-$$||die

Ecco un esempio:

$ unshare -Urfp /bin/dash
# perl -E 'say 12-$$||die'
10
# perl -E 'say 12-$$||die'
9
# perl -E 'say 12-$$||die'
8
# perl -E 'say 12-$$||die'
7
# perl -E 'say 12-$$||die'
6
# perl -E 'say 12-$$||die'
5
# perl -E 'say 12-$$||die'
4
# perl -E 'say 12-$$||die'
3
# perl -E 'say 12-$$||die'
2
# perl -E 'say 12-$$||die'
1
# perl -E 'say 12-$$||die'
Died at -e line 1.
#

Bash + sed, 41 40 38 byte

echo $[n=10/1]
sed -i s/$n/$[n-1]/g $0

Provalo online!

Javascript, 42 byte

y=localStorage;y.a=y.a||10;alert(y.a--||a)

Provalo con questo violino : assicurati di cancellare la memoria locale per ripristinare il conto alla rovescia.

Grazie a Steenbergh, Lmis e Obarakon per molti byte!

C #, 197 160 159 125 byte

namespace System.IO{class P{static void Main(){int n=11;for(;File.Exists(""+--n););File.Create(""+n);Console.Wr‌​ite(n*n/n);}}}

Risparmiato 34 byte grazie al latte

E una versione formattata (con ReadKeyaggiunta in modo da poter visualizzare l'output):

namespace System.IO
{
    class P
    {
        static void Main()
        {
            int n=11;
            for(;File.Exists(""+--n););
            File.Create(""+n);
            Console.Wr‌​ite(n*n/n);
        }
    }
}

È più lungo di quanto pensassi, quindi probabilmente c'è spazio per il golf.

Dyalog APL , 33 28 22/20? byte

Non sono sicuro che questo sia valido, poiché consiste in una funzione (che deve essere chiamata con un argomento fittizio). Tuttavia, tutti i programmi APL (puramente funzionali o meno) hanno lo stesso stato, e in effetti alcune versioni APL non hanno programmi tradizionali, solo funzioni. In compenso, ho aggiunto due byte per nominarlo, sebbene ciò non sia necessario per l'effetto desiderato.

f←{6::⊢c∘←10⋄÷÷c∘←c-1}

Si noti che questo si basa su una stranezza non ufficiale, che ∘←assegna a livello globale.

6:: su qualsiasi errore di valore

⊢critorno c

∘←10 che è globalmente impostato su 10

⋄ adesso

÷÷c restituisce il doppio invertito (errori su zero) c

∘← che è impostato a livello globale

c-1uno in meno di c

ProvaAPL online!

Versione sicuramente valida a 28 byte:

f
⍎'c←11'/⍨0=⎕NC'c'
⊢c←÷÷c-1

Funziona impostando c su 11 se mancante, quindi sottraendo 1 da c , invertendo due volte (il che dà errore div-by-zero se c -1 è 0), assegnando a c e producendo il nuovo valore.

Vecchia versione da 33 byte:

f
÷÷ ≢2 ↓ ↓ r⊣⎕FX¯1 r ← ⎕NR'f'

Funziona ridefinendo se stesso su ogni corsa, ma con una nuova riga finale in meno. Emette il numero due volte invertito di righe rimanenti (meno due), dando così un errore div-by-zero quando rimangono solo due righe (l'intestazione e il codice attuale).

Perl, 37 36 byte

9=~//;print$'-sysopen$~,$0,print$'+1

Si blocca quando il valore iniziale raggiunge -1 (che avrebbe stampato 0), mentre scrive sopra l' =~operatore.

Ho salvato un byte usando sysopenanziché open. Questo mi permette di stampare per STDOUTprimo, usando il valore restituito come modalità file ( 1, aka O_WRONLY), prima che $~venga riassegnato.

Esempio di utilizzo

$ perl crash-off.pl
10
$ perl crash-off.pl
9
$ perl crash-off.pl
8

...

$ perl crash-off.pl
2
$ perl crash-off.pl
1
$ perl crash-off.pl
syntax error at crash-off.pl line 1, near "1~"
Execution of crash-off.pl aborted due to compilation errors.

Perl 6 ,  60  58 byte

put 10-$=finish.lines||die;
$*PROGRAM.open(:a).put;
=finish
 

open($*PROGRAM,a=>put 10-$=finish.lines||die).put
=finish
 

Ha bisogno di un carattere newline dopo =finish.

diepuò essere sostituito con 1/0.

Spiegazione:

Ottiene un elenco di righe dopo =finish( $=finish.lines) sottrae tale da 10e, se il risultato non 0lo è, lo stampa, altrimenti lo dieè.

L'ultima cosa che fa è aprirsi in modalità append e aggiungere un'altra riga alla fine.

Python 2, 65 byte

f=open(__file__,"r+")
x=75-len(f.read())
x/x
print x
f.write('#')

Ispirato dalla risposta di L3viathan .

Può essere ridotto a 60 byte se puoi scegliere di nominare il file come un singolo carattere xe poi sostituirlo __file__con 'x'. In tal caso, sostituire 75con 70.

Jolf, 20 byte

γ-@▲lqΈ?␡γ?γaγ0₯I₯C1

Provalo qui! Errori quando 0viene stampato. Modifica il codice. Spiegazione a venire.

Applesoft BASIC, 21 byte (tokenized)

0  PRINT 9 + 1: CALL 2066: END : OR <CTRL-F><CTRL-H>`

Sostituisci <CTRL-F>e <CTRL-H>con le loro versioni letterali. Si noti che ciò modifica solo il programma in memoria; ricaricandolo dal disco si resetterà il conto alla rovescia.

Esecuzione del campione

]RUN
10

]RUN
9

]RUN
8

]RUN
7

]RUN
6

]RUN
5

]RUN
4

]RUN
3

]RUN
2

]RUN
1

]RUN

?SYNTAX ERROR IN 0

Spiegazione

PRINT 9 + 1fa quello che ti aspetteresti. CALL 2066chiama la routine di linguaggio macchina 6502 nella posizione di memoria 2066, che è dopo END :. ENDinterrompe il programma in modo che la routine del linguaggio macchina (che, per l'interprete di Applesoft, è spazzatura) non venga eseguita.

La routine del linguaggio macchina semplicemente decrementa l' 9in PRINT 9 + 1. Smontaggio:

0812-   CE 06 08    DEC $0806
0815-   60          RTS

Dopo che il contatore raggiunge 0, viene "decrementato" a /; il tentativo di eseguire il programma provocherà quindi un errore di sintassi.

*> <> , 20 18 byte

a1Fi:0(?b1-:?:1Fn;

Questo in realtà funziona su Linux (e qualunque cosa supporti i file di nome \nsuppongo). Crea un file denominato \nal primo avvio e output 10. Procede con l'output di un numero in meno su ogni corsa del subsquent, tranne 0dove si blocca invece.

Spiegazione

a1F                   open file named "\n"
   i:                 recieve input and duplicate it (-1 if empty)
     0(?b             if the file is empty, push 11 to the stack
         1-           subtract one
           :          duplicate the number
            ?:        if the number isn't 0, duplicate it again
              1F      save the number to the file
                n     output the number (crash if non-existant)
                 ;    exit

PHP 57 byte

echo$n=($f=file(f))?$f[0]:10?:die;fputs(fopen(f,w),--$n);

non si schianta davvero ma esce (senza conto alla rovescia) quando colpisce 0. È sufficiente?

Corri con -r.

C #, 156 byte

Ho golfato per un po 'la risposta di @ TheLethalCoder e sono stato in grado di salvare 3 byte riordinando le istruzioni ed eliminando int.parse (). Sono ancora margini di miglioramento, ne sono sicuro.

using System.IO;class P{static void Main(){int n;try{n=File.ReadAllText("f")[0]-48;}catch{n=10;}System.Console.Write(n/n*n);File.WriteAllText("f",""+--n);}}

Ungolfed:

using System.IO;
class P
{
    static void Main()
    {
        int n;
        try
        {
            n = File.ReadAllText("f")[0] - 48;
        }
        catch {
            n = 10;
        }
        System.Console.Write(n / n * n);
        File.WriteAllText("f", "" + --n);
    }
}

Meta-domanda: potrebbe essere hack-y prendere il lavoro di TheLethalCoder come punto di partenza per la mia risposta. Sarebbe meglio (una volta che ho il rappresentante) aggiungere questo come commento alla loro risposta? Non sto cercando di competere con loro, voglio solo mostrare il mio golf, per una reciproca edificazione.

Powershell V2.0, 49 byte

(Prima di tutto codice golf, non sono riuscito a trovare le regole su come calcolare i byte. Ho usato un calcolatore String per byte online)

if(!$n){$n=10;$n}else{$n-=1;if($n-eq0){throw};$n}

In esecuzione:

PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
10

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
9

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
8

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
7

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
6

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
5

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
4

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
3

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
2

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
1

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
ScriptHalted
At line:1 char:49
+ if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw <<<< };$n;}
    + CategoryInfo          : OperationStopped: (:) [], RuntimeException
    + FullyQualifiedErrorId : ScriptHalted

Java, 343 byte

Il mio primo tentativo di golf

import java.io.PrintWriter;class M{public static void main(String[] a) throws Exception{if(!new java.io.File("x").exists()) try(PrintWriter p=new java.io.PrintWriter("x")){p.write("10");}int b=new java.util.Scanner(new java.io.File("x")).nextInt();try(PrintWriter p=new java.io.PrintWriter("x")){p.print(b/b*b-1+"");System.out.print(b+"");}}}

ungolfed

import java.io.PrintWriter;

class M {
    public static void main(String[] a) throws Exception {
        if (!new java.io.File("x").exists()) {
            try (PrintWriter p = new java.io.PrintWriter("x")) {
                p.write("10");
            }
        }
        int b = new java.util.Scanner(new java.io.File("x")).nextInt();
        try (PrintWriter p = new java.io.PrintWriter("x")) {
            p.print(b / b * b - 1 + "");
            System.out.print(b + "");
        }
    }
}

SQLite, 142 137

Questo potrebbe probabilmente essere fatto in modo molto più intelligente. 141 136 caratteri per il codice:

create table if not exists t(n not null);insert into t select 11;update t set n=case n when 1 then null else n-1 end;select min(n)from t

Più 1 per il nome file xin sqlite3 x '…'.

JavaScript, 74 byte

x=typeof x!=typeof 1?10:x!=1?x-=1:_

l=localStorage;l.a=typeof l.a!=typeof""?10:l.a!=1?l.a=--l.a:_;aler‌​t(l.a)

Rubino, 94 87 84 61 59 byte

j=File.open(?a,"a+");1/(i=j.readlines.size-14);p -i;j.puts

Si prega di lasciare suggerimenti di seguito.

Grazie @ ConorO'Brien per le idee (alcuni spudoratamente strappati alla sua risposta).

Rubino, 52 + 1 = 53 byte

Presuppone che il file sia denominato a(+1 byte).

q=File.read ?a
0/h=62-q.size
p h
File.write ?a,q+?1#

In esecuzione

C:\Users\Conor O'Brien\Documents\Programming
λ type a
q=File.read ?a
0/h=62-q.size
p h
File.write ?a,q+?1#
C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
10

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
9

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
8

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
7

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
6

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
5

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
4

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
3

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
2

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
1

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
a:2:in `/': divided by 0 (ZeroDivisionError)
        from a:2:in `<main>'

Python 2, 89 byte

x=10
x/x
print x
f=open(__file__,"r+")
s=f.read()
f.seek(0)
f.write(s.replace(`x`,`x-1`))

TI-BASIC (TI-84 Plus) (15 byte)

If not(Ans
11
Ans-1
AnsAns/Ans

Ans dovrebbe essere uguale a 0 (il valore predefinito) prima della prima esecuzione.

Poiché AnsAns/Ansè l'ultima riga del programma, verrà emessa e memorizzata in Ans a meno che Ans sia 0, nel qual caso si verifica un errore di divisione per 0.

JavaScript, 41

l=localStorage;l.l=-~l.l;alert(11-l.l||I)

GNU Smalltalk, 70, 68 byte

66 byte codice +2 byte per il flag "-S"

EDITS

• Rimosse parentesi non necessarie, -2 byte

golfed

X=Y ifTrue:[Smalltalk at:#X put:10]ifFalse:[X:=X-1].(X*X/X)printNl

Test

>seq 11|xargs -L1 sudo gst -S fail.st 2>/dev/null
10
9
8
7
6
5
4
3
2
1
Object: 0 error: The program attempted to divide a number by zero
ZeroDivide(Exception)>>signal (ExcHandling.st:254)
SmallInteger(Number)>>zeroDivide (SysExcept.st:1426)
SmallInteger>>/ (SmallInt.st:277)
UndefinedObject>>executeStatements (fail.st:1)

Importante

È necessario eseguire gst come root, per poter modificare l'immagine predefinita o specificare la propria immagine con -I .

PHP, 45 byte

Onestamente non sono sicuro se questo conta.

<?session_start();echo10-$_SESSION[0]++?:die;

Pubblicherei un link a un esempio, ma tutti i tester online che conosco non consentono session_start()di essere utilizzati.

Ciò continuerà il conto alla rovescia ogni volta che si aggiorna la pagina fino a 0, quando dieviene eseguito il comando.

QBIC , 70 byte

open"r",1,"a.b" $get#1,1,e|~e=0|e=z\e=e-1]?e~e=0|$error 1|]$put#1,1,e|

Apre il file a.b(o lo crea quando non viene trovato alla prima esecuzione), legge il record 1 in e. Se quel record non viene trovato, supponi 10, altrimenti sub 1. At e==0, genera un errore. Riscrivi ea a.b.

L'accesso ai file non è integrato in QBIC, ciò dipende fortemente dal QBasic sottostante.

Lotto, 72 byte

@call:l
@if %n%==0 goto g
@echo %n%
@cmd/cset/a-1>>%0
:l
@set/an=10

Deve essere invocato usando il nome file completo inclusa l'estensione. L'ultima riga non deve avere una nuova riga finale. Funziona scrivendo -1alla fine dell'ultima riga in modo che valuti 1 in meno ogni volta. goto gerrori perché non c'è etichetta :g.

R, 52 byte

`if`(!"x"%in%ls(),cat(x<-10),`if`(x>0,cat(x<-x-1),))

Utilizza essenzialmente ls()per elencare i nomi di tutti gli oggetti archiviati a livello globale. Se supponiamo che l'ambiente globale sia vuoto e "x"non esista già, genera x=10, altrimenti se x!=0sottrai 1altro chiama un argomento mancante che restituisce un errore.

Batch di Windows, 61 byte

@if %n%.==. set n=10
@if %n%==0 goto.
@set /a n-=1&@echo %n%

JavaScript, 44 byte

function* f(n=11){for(;--n;yield n);throw''}

p=f()
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)