Votre tâche consiste à écrire un programme complet qui continuera à décompter à partir de 10 à chaque exécution.

• La première fois que vous exécutez le programme, il devrait être imprimé 10.
• La prochaine fois, il devrait sortir 9.
• La prochaine fois, il devrait sortir 8, et ainsi de suite.
• Au lieu d’imprimer 0, le programme devrait planter. Vous ne devez plus gérer le programme en cours d'exécution par la suite.
• Toute installation utilisée pour le stockage peut être considérée comme vide avant la première exécution du programme.

Voici un exemple d'implémentation dans 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))

C'est du code-golf , donc la réponse la plus courte (mesurée en octets) est gagnante.

6502 langage machine + Apple] [+ ROM, 12 (11? 10? 9?) Octets

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

Devrait commencer à $8000. Se bloque sur le moniteur système lorsque le nombre atteint 0.

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

Devrait commencer à $B1. Cela enregistre un octet, car je peux utiliser la version (deux octets) de zéro page DEC, mais écrase la routine critique Applesoft CHRGET; vous devez le charger et l'appeler à partir du moniteur, puis utilisez CTRL+ BReturnpour réinitialiser BASIC une fois que vous avez terminé. Pas sûr si cela invalide ou pas.

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

Devrait commencer à $8000. Cela n'initialise pas $9E, économisant deux octets. Cependant, cela signifie que vous ne devez pas l'appeler avec une adresse négative (ou, si vous l'appelez depuis le moniteur, vous devez appeler le moniteur avec une adresse positive). Si vous le faites, de Applesoft CALLla routine va stocker FFdans $9E, l' amenant à ajouter 65280 au numéro lors de l' impression. Encore une fois, je ne sais pas si cela invalide la solution ou non.

C6 B6 F0 01 A2 0B 4C 26 ED

Devrait commencer à $B1. Ceci est une combinaison des deux programmes ci-dessus, économisant un total de trois octets; vous devrez appeler le moniteur avec une adresse positive, le charger et l'exécuter à partir de là, et utiliser Ctrl+ BReturnpour réinitialiser BASIC une fois que vous aurez terminé.

Notez que ces programmes ne modifient que le programme en mémoire; recharger le programme à partir du disque réinitialisera le compte à rebours. Cela fonctionne parce que les Apple] [(et] [+, // e et // c) n’ont aucun système de protection de la mémoire; le programme (et ses auto-modifications) restera en mémoire même après sa fermeture. Vous pourrez donc continuer à l'exécuter de mémoire jusqu'à ce que vous remplaciez cette mémoire par quelque chose d'autre.

Échantillon échantillon

]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
*

Explication

     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

Explication de la version 10 octets

     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

Des variantes

Imprime ERRet émet un bip lorsque le nombre atteint 0

Normal - 15 octets

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

Écrasement CHRGET- 14 octets

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

N'initialise pas $9E- 13 octets

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

Écrase CHRGETet n'initialise pas $9E- 12 octets

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

Gèle lorsque le nombre atteint 0

Normal - 12 octets

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

Écrasement CHRGET- 11 octets

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

N'initialise pas $9E- 10 octets

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

Écrase CHRGETet n'initialise pas $9E- 9 octets

C6 B6 F0 FE A2 0B 4C 26 ED

Perl sous Linux, 17 octets

J'ai pensé qu'il pourrait être intéressant de créer un programme qui ne maintienne aucun état et ne modifie pas son propre code source; autrement dit, il vérifie à quelle fréquence il est exécuté en interrogeant le système d'exploitation. La question dit "On peut supposer que toutes les installations utilisées pour le stockage sont vides avant la première exécution du programme" et nous voudrions donc partir d'un système d'exploitation complètement vide. En tant que tel, je ferais mieux de vous expliquer comment vous y prenez, sinon il est difficile de tester le programme.

Il existe en fait deux façons de configurer le programme. Quoi qu’il en soit, le système d’exploitation minimal utilisé n’exécutera rien d’autre qu’un shell (pour nous permettre d’exécuter Perl à son tour), et le shell le plus simple possible (pour qu’il ne fasse rien d’extrême qui rend le système Vide). /bin/dashest un bon choix ici, car il était conçu comme un shell minimal pour la récupération du système. Ensuite, nous devons démarrer Linux de telle sorte que rien ne soit exécuté dash. Nous pouvons le faire soit en redémarrant l'ordinateur avec init=/bin/dashla ligne de commande Linux pour qu'il démarre rien d' autre que dash, ou (bien plus pratique) la création d' un conteneur Linux en utilisant unshare -Urfp /bin/dashdans un terminal ( unsharene pas réellement créer un système d' exploitation en blanc, mais il Simulerun; notamment, l’intérieur du conteneur pense que c’est sa racine, dashpense qu’il est init, etc., comme cela arriverait avec un système d’exploitation vierge). Avertissement: Je n'ai pas encore testé cela sur du métal nu, mais uniquement à l'intérieur unshare, mais cela devrait fonctionner dans les deux sens en théorie.

Enfin, une fois que nous avons cette configuration, nous devons simplement examiner le PID; comme nous sommes sur un système vierge, le système init (ici, le shell) aura le PID 1, de sorte que les exécutions de Perl auront des PID de 2 à 12 inclus. Donc, notre programme ressemble à ceci:

say 12-$$||die

Voici un exemple de parcours:

$ 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 octets

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

Essayez-le en ligne!

Javascript, 42 octets

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

Testez-le avec ce violon - assurez-vous de vider votre mémoire de stockage locale pour réinitialiser le compte à rebours.

Merci à steenbergh, Lmis et obarakon pour de nombreux octets!

C #, 197 160 159 125 octets

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

Économisé 34 octets grâce au lait

Et une version formatée (avec ReadKeyajouté pour que vous puissiez voir la sortie):

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

Il est plus long que je ne le pensais, il y a donc de la place pour le golf.

Dyalog APL , 33 28 22/20? octets

Je ne suis pas sûr que ce soit valide, car il s'agit d'une fonction (qui doit être appelée avec un argument factice). Cependant, tous les programmes APL (purement fonctionnels ou non) ont le même statut et certaines versions de APL n’ont pas de programmes traditionnels, mais seulement des fonctions. En compensation, j'ai ajouté deux octets pour le nommer, bien que cela ne soit pas nécessaire pour obtenir l'effet désiré.

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

Notez que cela repose sur un caprice non officiel, qui ∘←affecte globalement.

6:: en cas d'erreur de valeur

⊢cretour c

∘←10 qui est globalement fixé à 10

⋄ maintenant

÷÷c retourne le double inversé (erreurs sur zéro) c

∘← qui est globalement mis à

c-1un de moins que c

TryAPL en ligne!

Version de 28 octets certainement valable:

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

Fonctionne en définissant c sur 11 en cas d’absence, puis en soustrayant 1 de c , en inversant deux fois (ce qui donne une erreur div par zéro si c -1 est égal à 0), en affectant à c et en affichant la nouvelle valeur.

Ancienne version à 33 octets:

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

Fonctionne en se redéfinissant à chaque exécution, mais avec une nouvelle ligne inférieure. Affiche le nombre de lignes restantes deux fois inversé (moins deux), générant ainsi une erreur div par zéro lorsqu'il ne reste que deux lignes (l'en-tête et le code réel).

Perl, 37 36 octets

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

Se bloque lorsque la valeur initiale atteint -1 (ce qui aurait imprimé 0), car il écrit sur l' =~opérateur.

Enregistré un octet en utilisant sysopenplutôt que open. Cela me permet d’imprimer en STDOUTpremier, en utilisant la valeur de retour comme mode de fichier ( 1, aka O_WRONLY), avant que cette valeur ne $~soit réaffectée.

Exemple d'utilisation

$ 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 octets

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

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

Nécessite un caractère de nouvelle ligne après =finish.

diepeut être remplacé par 1/0.

Explication:

Il obtient une liste de lignes après que =finish( $=finish.lines) le soustrait 10, et si le résultat n’est pas obtenu, 0il l’imprime, sinon il dies.

La dernière chose qu'il fait est de s'ouvrir en mode ajout et d'ajouter une autre ligne à la fin.

Python 2, 65 octets

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

Inspiré par la réponse de L3viathan .

Peut être réduit à 60 octets si vous pouvez choisir de nommer le fichier avec un seul caractère x, puis de le remplacer __file__par 'x'. Dans ce cas, remplacez 75par 70.

Jolf, 20 octets

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

Essayez-le ici! Erreurs quand 0est imprimé. Modifie le code. Explication à venir.

Applesoft BASIC, 21 octets (en jetons)

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

Remplacez <CTRL-F>et <CTRL-H>avec leurs versions littérales. Notez que cela ne modifie que le programme en mémoire; le recharger à partir du disque réinitialisera le compte à rebours.

Échantillon échantillon

]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

Explication

PRINT 9 + 1fait ce que vous attendez. CALL 2066appelle la routine de langage machine 6502 à l'emplacement de mémoire 2066, qui est après END :. ENDinterrompt le programme pour que la routine en langage machine (qui, pour l'interpréteur Applesoft, ne soit pas ordonnée) ne soit pas exécutée.

La routine en langage machine décrémente simplement 9dans PRINT 9 + 1. Démontage:

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

Lorsque le compteur atteint 0, il est "décrémenté" à /; tenter d'exécuter le programme provoquera alors une erreur de syntaxe.

*> <> , 20 18 octets

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

Cela fonctionne réellement sur Linux (et tout ce qui supporte des fichiers nommés, \nje suppose). Il crée un fichier nommé \nlors de la première exécution et des sorties 10. Il produit en sortie un nombre en moins à chaque exécution ultérieure, sauf en 0cas de blocage .

Explication

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 octets

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

ne plante pas vraiment mais quitte (sans décompter) quand il frappe 0. Est-ce suffisant?

Courez avec -r.

C #, 156 octets

J'ai joué au golf @ TheLethalCoder pendant un moment et j'ai pu économiser 3 octets en réordonnant les instructions et en éliminant int.parse (). Il y a encore place à amélioration, j'en suis sûr.

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);
    }
}

Méta-question: Il peut être difficile de prendre le travail de TheLethalCoder comme point de départ de ma réponse. Serait-il préférable (une fois que j'ai le représentant) d'ajouter ceci comme commentaire sur leur réponse? Je n'essaie pas de rivaliser avec eux, je veux juste montrer mon golf, pour une édification mutuelle.

Powershell V2.0, 49 octets

(Le tout premier code de golf, impossible de trouver les règles sur la façon de calculer les octets. J'ai utilisé une calculatrice Chaîne en octets en ligne)

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

Fonctionnement:

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 octets

Ma première tentative de 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+"");}}}

non-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 + "");
        }
    }
}

SQLite, 142 137

Cela pourrait probablement être fait beaucoup plus intelligemment. 141 136 caractères pour le code:

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

Plus 1 pour le nom xde fichier dans sqlite3 x '…'.

JavaScript, 74 octets

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)

Ruby, 94 87 84 61 59 octets

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

S'il vous plaît laissez des suggestions ci-dessous.

Merci @ ConorO'Brien pour les idées (certaines arrachées sans vergogne à sa réponse).

Ruby, 52 + 1 = 53 octets

Suppose que le fichier est nommé a(+1 octet).

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

Fonctionnement

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 octets

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

If not(Ans
11
Ans-1
AnsAns/Ans

Ans doit être égal à 0 (valeur par défaut) avant la première exécution.

Étant donné que AnsAns/Ansc'est la dernière ligne du programme, celui-ci sera sorti et stocké dans Ans à moins que Ans ne soit à 0, auquel cas une erreur de division par 0 se produit.

JavaScript, 41

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

GNU Smalltalk, 70, 68 octets

Code de 66 octets +2 octets pour l'indicateur "-S"

EDITS

• Suppression des parenthèses inutiles, -2 octets

Golfé

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

Tester

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

Important

Vous devez exécuter gst en tant que root pour pouvoir modifier l'image par défaut ou spécifier votre propre image avec -I .

PHP, 45 octets

Honnêtement, je ne sais pas si celui-ci compte.

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

Je posterais un lien vers un exemple, mais tous les testeurs en ligne que je connais ne permettent session_start()pas son utilisation.

Cela continuera à décompter chaque fois que vous actualiserez la page jusqu'à 0, lorsque la diecommande sera exécutée.

QBIC , 70 octets

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|

Ouvre le fichier a.b(ou le crée s’il n’a pas été trouvé lors de la première utilisation), lit l’enregistrement 1 dans e. Si cet enregistrement n’est pas trouvé, supposons 10, sinon sous 1. At e==0, déclenche une erreur. Écris eà a.b.

L’accès aux fichiers n’est pas intégré à QBIC, cela dépend fortement du QBasic sous-jacent.

Lot, 72 octets

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

Doit être appelé en utilisant le nom de fichier complet, extension comprise. La dernière ligne ne doit pas avoir de fin de ligne. Fonctionne en écrivant -1à la fin de la dernière ligne pour qu’elle soit évaluée à 1 de moins à chaque fois. goto gerreurs sur parce qu'il n'y a pas d'étiquette :g.

R, 52 octets

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

Utilise essentiellement la ls()liste des noms de tous les objets stockés globalement. Si nous supposons que l'environnement global est vide et "x"n'existe pas déjà, générez x=10, sinon, x!=0soustrayez 1sinon, appelez un argument manquant qui renvoie une erreur.

Lot Windows, 61 octets

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

JavaScript, 44 octets

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)