Fabriquer une imprimante entière polyvalente est agréable et tout, mais écrire un seul code qui imprime beaucoup de nombres différents est lourd. Ne serait-il pas plus facile de créer un script qui génère un nombre, mais vous donne également un nouveau script pour obtenir le nombre suivant?

Défi:

Écrivez un code qui produit un seul entier Net un code exécutable. Le code suivant devrait sortir N+1et un code qui peut sortir N+2. Continuez ce chemin jusqu'à ce que vous atteigniez N = 15. (Le dernier numéro imprimé doit être 15).

Règles:

• Aucune entrée (supposez que l'entrée est vide).
• Un programme ou une fonction complète ou d'autres formats pratiques sont autorisés.
• Le premier code devrait sortir 1.
• Vous ne pouvez pas générer de zéros non significatifs. -À- dire que vous ne pouvez pas imprimer 01pour 1.
• La sortie doit être au format N, Code_for_N+1. Notez que la sortie est séparée par une virgule et un seul espace. Le code de N+1n'a pas de guillemets. N , Code_for_N+1n'est pas accepté (espace devant la virgule). Les retours à la ligne de fin sont OK.
• Le ou les premiers caractères de la sortie doivent être le nombre. (Pas d'espaces de tête, ou ans = N).
• Le numéro imprimé ne doit pas faire partie du code suivant (le code peut contenir ce numéro, mais vous ne pouvez pas prendre le numéro de sortie comme faisant partie du code)
  • Exemple: La sortie N=2peut être: 2, printer 2. Dans ce cas, printer 2est le code pour N=3. Vous ne pouvez pas utiliser la sortie entière: 2, printer 2comme code pour N=3.
• Les scripts peuvent être dans différentes langues
• Les types de données ne sont pas pertinents (le nombre peut être une chaîne), mais il ne peut être entouré de rien (guillemets, parenthèses, etc.).
• S'il y a un code sorti, N=15il doit soit imprimer STOP!(voir bonus), soit ne rien imprimer du tout (pas même un espace ou une nouvelle ligne).
  • Le code de N=15ne peut pas planter (mais la sortie vers STDERR est OK).
  • Vous êtes disqualifié si le code de sortie pour les N=15impressions 16ou toute autre chose (sauf le cas bonus).
• Les opérateurs de quine intégrés ne sont pas autorisés.
• L'accès au fichier source via le système de fichiers n'est pas autorisé.

Prime:

-10 octets si le code qui imprime 15 produit également un code qui imprime " STOP!"

Exemples utilisant la syntaxe Python: (évidemment, cela ne fonctionnera que pour les entiers sélectionnés, pas de 1 à 15.)

N = 1
print "1, print 2"
1, print 2

---
N = 15
print 15
15

---
N = 15   (Qualifies for the -10 bytes bonus)
print "15, print 'STOP!'"
15, print 'STOP!'

print 'STOP!'
STOP!

----

N = 15   (Qualifies for the -10 bytes bonus)
print "15, disp('STOP!')"
15, disp('STOP!')        (disp('STOP!') outputs STOP! in MATLAB)

----
N = 15   (This one is not OK. The submission is disqualified)
print "15, print 16"
15, print 16

Les règles de golf standard s'appliquent! Le plus petit code (pour N = 1) en octets gagne!

Pyth + ///, 15 octets - 10 = 5

pPt`S15", STOP!

Cela s'imprime 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, STOP!en Pyth, en prenant range(1,15+1)et en supprimant les crochets de début et de fin, et en l'imprimant immédiatement suivi de ", STOP!".

Les quatorze programmes suivants sont dans ///, qui génère directement tous les programmes qui ne contiennent pas /ou \. Donc, le deuxième programme

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

donne 2et le troisième programme 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15. L'avant-dernier programme 15, STOP!,, imprime 15, STOP!, donc le dernier programme est juste STOP!.

JavaScript, 131238 - 10 = 131228 octets

L'approche naïve s'est avérée pire que prévu. Avec du recul, j'aurais dû m'y attendre. Mais je pensais que je le partagerais de toute façon. Code complet ici.

Idée: échapper itérativement et ajouter le N-1, ...

alert("14,alert(\"15, alert(\\\"STOP!\\\")\")")

CJam, 26 25 24 octets

1{", "2$)@"_~"](_F<@*}_~

Essayez-le en ligne.

Les programmes suivants ont simplement le premier numéro incrémenté. Cela exécute le programme 16 fois.

Ou avec bonus pour le même score:

1{", "\2$)_G<\@`+"_~"+"STOP!"`?}_~

Essayez-le en ligne.

Les programmes suivants ont simplement le premier numéro incrémenté. Cela exécute le programme 16 fois.

Solution alternative pour le bonus:

1{", "\2$)Gmd@`+"_~"+"STOP!"`\?}_~

JavaScript (ES6), 62 61 octets - 10 bonus = 51 points

_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)

Explication

Une solution qui ne lit pas son propre code source et qui n'est pas non plus ridiculement longue.

Le premier programme construit les 15 autres programmes et les imbrique les uns dans les autres à l'aide d'une fonction récursive. Je contourne le problème de la barre oblique inverse en imbriquant les fonctions elles-mêmes (qui sont ensuite converties en chaînes lors de la sortie) plutôt qu'en chaînes.

_=>
  "1, "                // print the first number
  +(f=n=>`_=>"`+(      // f = recursive function for printing program N
    n<16?              // for programs 2 - 15:
      n+`, "+(${       // add N to the output of the nested function
        f(n+1)         // nest the code of program N + 1
      })`
    :`STOP!"`          // program 16 just outputs "STOP!" for the bonus
  ))(2)                // start from program 2

Tester

var nextProgram = '_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)',
    n = 1;
while(nextProgram) {
  result.textContent += "Program " + n++ + ": " + nextProgram + "\n";
  var output = eval("(" + nextProgram + ")()");
  result.textContent += "   Output: " + output + "\n\n";
  var index = output.indexOf(",");
  nextProgram = index > 0 ? output.substr(index + 2) : null;
}

<pre id="result"></pre>

Matlab, 226212 - 10 = 202 octets

Merci à @StewieGriffin pour quelques octets =)

'awFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)

La première partie est une chaîne qui représente la deuxième ligne (ci-dessous), le code réel (juste décalé de 9). Dans Matlab, les chaînes sont des matrices remplies de caractères, vous pouvez donc facilement effectuer les décalages en ajoutant / soustrayant simplement un scalaire. Ainsi, le programme imprime à nouveau la même chaîne *, plus la même chaîne mais décalée, ce qui donne le code.

* Pas tout à fait: le premier octet est le compteur qui doit être augmenté à chaque itération.

L'astuce quine avec la chaîne a été volée sans vergogne d' ici.

'awFjw|Dro)w1:26B?G:>DwF0\}xy*0Dnu|nDwFdw~v;|}{1w1:26B?2505)05<B5w1:24:5w1;Cnwm25<B5>B5w1;Cnwm26B500fDnwmDmr|y1w2';
n=ans;if n(1)-96>15;n='Stop!';else;n=[num2str(n(1)-96),', ',39,n(1)+1,n(2:end),39,59,n(2:end)-9,''];end;disp(n)

Voici les dernières lignes de la séquence copiées depuis la console:

>> 'mwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
13, 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
14, 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
15, 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
STOP!

JavaScript, 50 47 44 42 44 ^* octets

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1)

C'est une fonction qui extrait (juste a) son propre corps et y fait des remplacements. Obtenir le corps de la fonction une fonctionnalité intégrée de JavaScript, bien qu'il ne soit pas explicitement un opérateur de quine (s'il n'est pas valide, supprimera la réponse).

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1);
alert(a());

Dans le cas où cela ne fonctionne pas correctement intégré (car pour moi, cela ne fonctionne pas), vous pouvez voir un exemple ici .

^{* - on dirait que l'extrait produit le résultat sans a=, rendant les appels ultérieurs impossibles}

Python 2.7.10, 196 92-10 = 82 octets

Whee !!! C'était amusant. Beaucoup plus court maintenant. : P

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Explication:

J'ai commencé avec ceci:

a='a=%r;print a%%a';print a%a

Ce n'est qu'une simple quine. C'est cela avec un compteur ajouté:

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)';print n,a%(n+1,a)

nest une variable de compteur qui est imprimée au début. Ensuite, lorsque son imprime len= pièce, il remplace n+1le %d. Donc, à partir d'ici, il comptera infiniment.

Et voici la version finale. Il ajoute une clause if pour s'arrêter à 15 et affiche "STOP!" ainsi que.

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Ancien code:

a= ['if num==15:print"STOP!!!";exit()','print num','print"a=",a','print"num=",num+1', 'for s in a:print s']
num= 1
print num
if num==15:print"STOP!!!";exit()
print"a=",a
print"num=",num+1
for s in a:print s

Jamais gagner, mais amusant. : P Beaucoup plus court maintenant, même si je n'ai toujours aucune chance. : P

PowerShell, (215-10) = 205 197 167 106 104 103 octets

$d='$c=(,1*{2}).count;$d={0}{1}{0};(("$c, $d"-f[char]39,$d,($c+1)),$c)[$c-eq15]';"1, $d"-f[char]39,$d,2

_{(Si votre seul outil est PowerShell, chaque problème ressemble à un clou. Attendez ...)}

Essentiellement, nous commençons avec un réglage $dégal à une chaîne longue de gros ole d'une quasi- quine du code original. Il produit 1et ensuite $davec l'opérateur de format -fpour remplir correctement le {0}, {1}, {2}stand-ins, incrémenter le {2}numéro dans la ,1*{2}section par un à chaque fois.

L' ,x*yopération dans PowerShell crée un nouveau tableau d' yéléments, chacun étant égal à x. Par exemple, ,2*3est équivalent à@(2,2,2) .

Cela signifie que la première sortie sera 1, $c=(,1*2).length;$d=(etc...), donc lorsque le deuxième code sera exécuté, $csera égal au nombre du tableau @(1,1), ou 2, etc. Notez que$c n'est pas utilisé comme une variable dans le code d' origine, juste dans les courses suivantes.

Arrête quand il imprime 15 en calculant simplement si $cégal 15et en indexant ensuite dans un tableau, le 0ème élément est $c, $dcomme décrit ci-dessus, l'autre est juste 15. Ainsi, à $c15 ans, il sortira 15et rien d'autre. Ne donne pas droit au bonus, car "15, {0}STOP!{0}"5 caractères sont trop longs pour que le -10 en vaille la peine.

Nécessite un terminal PowerShell d'une largeur> ~ 150. Ou pour vous de supprimer manuellement le saut de ligne supplémentaire (que le terminal obligeamment insère sur sortie) lors du copier-coller du code. Ou pour que vous capturiez la sortie dans une variable, puis réexécutez cette variable. Etc.

_{Edit 1 - Enregistré quelques octets en supprimant le "STOP!" formulation.
Edit 2 - Durr, n'utilisez pas .length à chaque fois, appelez-le une seule fois
Edit 3 - N'a pas besoin d'être une quine, donc l'exécution initiale peut être beaucoup plus courte
Edit 4 - Changé d'utiliser des chaînes en tableaux à calculer $c, ce qui a permis d'économiser deux octets. Je suis presque sûr que c'est presque optimal pour cette approche.
Edit 5 - Sauvegardé un autre octet en comptant directement l'égalité plutôt que le modding}

JavaScript, 79-10 = 69 octets

s='STOP!';for(i=15;i;){s=i--+',alert("'+s.replace(/[\\"]/g,"\\$&")+'")'};alert(s)

Sans utiliser Function.prototype.toStringdu tout.

Befunge, 57-10 = 47 octets

1:'!`'#*j:.',,1+:9`''*'0++,1#;:0g:48*`j@,1+;"!POTS",,,,,@

Celui-ci est génial. Essayez-le ici .

Lot, 73 + 5 - 10 = 68 octets

@set a=STOP!
@for /l %%a in (15,-1,1)do @set a=%%a, @echo !a!
@echo %a%

Nécessite CMD /V:ONdonc j'ai ajouté 5 octets pour cela.

Python 2.7, 107 caractères

En utilisant la récursivité et en n'écrivant pas de quine, j'ai pensé que je pourrais économiser beaucoup, ce qui est vrai, mais pas assez bon. Bien que n'étant pas gagnant, je pense que l'approche est amusante à partager.

J'ai commencé par créer une chaîne pour N = 4, en échappant aux caractères \et ".

print "1, print \"2, print \\\"3, print \\\\\\\"4, print \\\\\\\\\\\\\\\"STOP!\\\\\\\\\\\\\\\"\\\\\\\"\\\"\""

J'ai ensuite créé une fonction lambda qui crée cette chaîne, basée sur un index de démarrage et un index d'arrêt, en utilisant la récursivité. Ça y est:

l=lambda n,m:str(n)+", print "+"\\"*(2**(n-1)-1)+"\""+l(n+1,m)+"\\"*(2**(n-1)-1)+"\"" if n<m else "STOP!"

Utilisez-le comme ceci:

print l(1,15)

Sortie: [32902 caractères, trop long à gérer]

Donc, il semble que mon approche de la complexité kolmogorov ne soit pas si réussie ;-)

SMBF , 28 octets

\x10représente un octet littéral (valeur décimale 16). L'entier est sorti sous forme d'entier (octet). Donc, la première sortie de caractère est \x01. Le programme imprime ensuite ",". Lors de l'impression de sa propre source, il imprime un supplément +au début.

+.<-<<.>.>[[<]>.[.>]<[-]], \x10

Explication:

+.                                  Increment number and print
  <-                                Pre-decrement loop counter
    <<.>.>                          Print comma and space from own source
          [             ]           Only execute if loop counter != 0
           [<]>.                    Move to left of source, then print `+`
                [.>]                Print entire source.
                    <[-]            Zero out the loop counter so this program halts.
                         , \x10     The comma, space, and loop counter used earlier.
                                    Input is empty, so `,` doesn't do anything.

Notez que vous ne pouvez pas l'exécuter dans un interpréteur standard car il nécessite un littéral hexadécimal en entrée. Vous avez également besoin d'un terminal spécial pour que la sortie hexadécimale fonctionne correctement.

Bash, 78 74 73 - 10 = 63 octets (exemple, impossible de gagner)

p='if(($((++a>15))));then unset a p;fi;echo ${a-STOP\!}${p+, $p}';eval $p

Arrivant tard, mais vu que bash n'avait pas été essayé, essayez-le. Premier défi du golfe et puzzle de type quine. Ils sont amusants!

Explication:

Cela fonctionne parce que les aétapes de 1 à 15 et est ensuite unsetavec p. Le script (stocké dans p) les imprime tous les deux s'ils sont setet "STOP!" autrement. La valeur initiale unset aest setà 0 car elle apparaît dans une expansion arithmétique.

𝔼𝕊𝕄𝕚𝕟, 30 caractères / 47 octets (non compétitif)

⟮a=1)+(a<ḏ?⬬+ⒸⅩ222+ᶈ0:⬯)ē(a,⧺a

Try it here (Firefox only).

J'ai enfin trouvé une bonne vraie quine pour 𝔼𝕊𝕄𝕚𝕟.

Explication

Voici le vrai quine que j'ai utilisé: ⟮ⒸⅩ222+ᶈ0

Vous le voyez dans ma réponse? Espérons que vous pourrez tous vous développer à partir de là.

Keg + PHP, 19-10 = 10 octets

ï_(. \,,,)\!POTS(,

Compte de 1 à 15 puis s'arrête. TIO

Keg, 13 octets

ï_(. \,,,).