Die Erstellung eines vielseitigen Ganzzahldruckers ist praktisch, aber das Schreiben eines einzelnen Codes, der viele verschiedene Zahlen druckt, ist umständlich. Wäre es nicht einfacher, ein Skript zu erstellen, das eine Zahl ausgibt, Ihnen aber auch ein neues Skript zum Abrufen der nächsten Zahl bietet?

Herausforderung:

Schreiben Sie einen Code, der eine einzelne Ganzzahl Nund einen ausführbaren Code ausgibt . Der nächste Code sollte ausgegeben werden N+1und ein Code, der ausgegeben werden kann N+2. Folgen Sie diesem Weg bis Sie erreichen N = 15. (Die zuletzt gedruckte Nummer sollte 15 sein).

Regeln:

• Keine Eingabe (vorausgesetzt, die Eingabe ist leer).
• Volles Programm oder Funktion oder andere bequeme Formate sind erlaubt.
• Der erste Code sollte ausgegeben werden 1.
• Sie können keine führenden Nullen ausgeben. Dh Sie können nicht drucken 01zu 1.
• Die Ausgabe muss im Format sein N, Code_for_N+1. Beachten Sie, dass die Ausgabe durch ein Komma und ein einzelnes Leerzeichen getrennt ist. Der Code für N+1hat keine umgebenden Anführungszeichen. N , Code_for_N+1wird nicht akzeptiert (Leerzeichen vor dem Komma). Nachgestellte Zeilenumbrüche sind in Ordnung.
• Die ersten Zeichen der Ausgabe müssen die Nummer sein. (Keine führenden Leerzeichen oder ans = N).
• Die gedruckte Nummer sollte nicht Teil des nächsten Codes sein (der Code kann diese Nummer enthalten, aber Sie können die ausgegebene Nummer nicht als Teil des Codes verwenden)
  • Beispiel: Der Ausgang N=2kann sein: 2, printer 2. In diesem Fall printer 2ist der Code für N=3. Sie können nicht die gesamte Ausgabe verwenden: 2, printer 2als Code für N=3.
• Die Skripte können in verschiedenen Sprachen vorliegen
• Die Datentypen sind irrelevant (die Nummer kann eine Zeichenfolge sein), sie dürfen jedoch nicht von irgendetwas umgeben sein (Anführungszeichen, Klammern usw.).
• Wenn ein Code für ausgegeben N=15wird, muss er entweder gedruckt werden STOP!(siehe Bonus) oder er darf überhaupt nichts drucken (nicht einmal ein Leerzeichen oder eine neue Zeile).
  • Der Code für N=15kann nicht abstürzen (aber die Ausgabe an STDERR ist in Ordnung).
  • Sie werden disqualifiziert, wenn der Ausgabecode für N=15Drucke 16oder etwas anderes (mit Ausnahme des Bonusfalls).
• Eingebaute Quine-Operatoren sind nicht erlaubt.
• Der Zugriff auf die Quelldatei über das Dateisystem ist nicht zulässig.

Bonus:

-10 Byte, wenn der Code, der 15 ausgibt, auch einen Code erzeugt, der " STOP!" ausgibt

Beispiele mit Python-Syntax: (Diese funktionieren natürlich nur für die ausgewählten Ganzzahlen, nicht für 1 bis 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

Es gelten die üblichen Golfregeln! Kleinster Code (für N = 1) in Bytes gewinnen!

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

pPt`S15", STOP!

Dies wird 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, STOP!in Pyth gedruckt, indem range(1,15+1)die Anfangs- und Endklammern entfernt und ausgedruckt werden und unmittelbar danach ", STOP!".

Die nächsten vierzehn Programme befinden sich in ///, wodurch alle Programme, die /oder nicht enthalten, direkt ausgegeben werden \. Also das zweite Programm

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

gibt 2und das dritte Programm 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15. Das vorletzte Programm wird 15, STOP!gedruckt 15, STOP!, das letzte Programm ist also gerade STOP!.

JavaScript, 131238-10 = 131228 Byte

Die naive Herangehensweise fiel schlimmer aus als erwartet. Im Nachhinein hätte ich es erwarten sollen. Aber ich dachte, ich würde es trotzdem teilen. Vollständiger Code hier.

Idee: Iterativ entkommen und hinzufügen N-1, ...

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

CJam, 26 25 24 Bytes

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

Probieren Sie es online aus.

Bei den nachfolgenden Programmen wird einfach die erste Nummer erhöht. Dadurch wird das Programm 16 Mal ausgeführt.

Oder mit Bonus für die gleiche Punktzahl:

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

Probieren Sie es online aus.

Bei den nachfolgenden Programmen wird einfach die erste Nummer erhöht. Dadurch wird das Programm 16 Mal ausgeführt.

Alternative Lösung für den Bonus:

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

JavaScript (ES6), 62 61 Bytes - 10 Bonus = 51 Punkte

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

Erläuterung

Eine Lösung, die ihren eigenen Quellcode nicht liest und auch nicht lächerlich lang ist.

Das erste Programm erstellt alle 15 anderen Programme und verschachtelt sie mithilfe einer rekursiven Funktion ineinander. Um das Backslash-Problem zu umgehen, verschachtele ich die Funktionen selbst (die dann während der Ausgabe in Zeichenfolgen umgewandelt werden) und nicht in Zeichenfolgen.

_=>
  "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

Prüfung

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, 226 212 - 10 = 202 Bytes

Danke an @StewieGriffin für ein paar Bytes =)

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

Der erste Teil ist eine Zeichenfolge, die die zweite Zeile (unten) darstellt, den tatsächlichen Code (nur um 9 verschoben). In Matlab sind Zeichenfolgen Matrizen, die mit Zeichen gefüllt sind. Sie können die Verschiebungen also problemlos ausführen, indem Sie einfach einen Skalar hinzufügen / abziehen. Das Programm druckt also nur die gleiche Zeichenfolge * und die gleiche Zeichenfolge, aber verschoben, was zum Code führt.

* Nicht ganz: Das erste Byte ist der Zähler, der bei jeder Iteration erhöht werden muss.

Der Quintrick mit der Schnur wurde hier schamlos gestohlen .

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

Hier die letzten Zeilen der Sequenz, die von der Konsole kopiert wurden:

>> '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 ^* Bytes

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

Es ist eine Funktion, die ihren eigenen Körper (nur a) extrahiert und ihn ersetzt. Wenn der Funktionskörper eine integrierte Funktion von JavaScript ist, obwohl er nicht ausdrücklich ein Quine-Operator ist (wenn er ungültig ist, wird die Antwort entfernt).

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

Für den Fall , funktioniert es nicht richtig dort eingebettet (denn für mich ist es nicht), können Sie sehen , ein Beispiel gibt .

^{* - sieht so aus, als würde das Snippet das Ergebnis ohne erzeugen a=, was weitere Aufrufe unmöglich macht}

Python 2.7.10, 196 92 - 10 = 82 Bytes

Whee !!! Das hat Spaß gemacht. Jetzt viel kürzer. : 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!"

Erläuterung:

Ich habe damit angefangen:

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

Das ist nur eine einfache Quine. Dies ist, dass mit einem Zähler hinzugefügt:

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

nist eine Zählervariable, die am Anfang ausgegeben wird. Wenn es dann das n=Teil druckt , ersetzt es n+1das %d. Ab hier zählt es also unendlich hoch.

Und hier ist die endgültige Version. Es wird eine if-Klausel hinzugefügt, die bei 15 stoppt und "STOP!" auch.

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!"

Alter 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

Niemals gewinnen, aber Spaß machen. : P Jetzt viel kürzer, obwohl ich immer noch keine Chance habe. : P

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

$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

_{(Wenn Ihr einziges Tool PowerShell ist, sieht jedes Problem wie ein Nagel aus. Warten Sie ...)}

Im Wesentlichen beginnen wir mit der Einstellung $dauf eine große ole-lange Kette von einer fast - gleich quine des ursprünglichen Codes. Es gibt 1und dann $dmit dem Format des Bedieners -frichtig des Auffüllens {0}, {1}, {2}Stand-in, die Inkrementieren {2}Nummer in dem ,1*{2}von einem jeden Zeitabschnitt.

Durch den ,x*yVorgang in PowerShell wird ein neues Array von yElementen erstellt, von denen jedes gleich ist x. Zum Beispiel ,2*3ist äquivalent zu @(2,2,2).

Dies bedeutet, dass die erste Ausgabe gleich der Anzahl des Arrays oder usw. ist 1, $c=(,1*2).length;$d=(etc...), wenn der zweite Code ausgeführt $cwird . Beachten Sie, dass diese nicht als Variable im ursprünglichen Code verwendet wird, sondern nur in nachfolgenden Ausführungen .@(1,1)2$c

Stoppt, wenn es 15 ausgibt, indem es einfach berechnet, ob es $cgleich ist, 15und dann in ein Array indiziert. Das 0. Element ist $c, $dwie oben beschrieben, das andere ist gerade 15. Wenn $calso 15 ist, wird es ausgegeben 15und sonst nichts. Qualifiziert sich nicht für den Bonus, da "15, {0}STOP!{0}"5 Zeichen zu lang sind, damit sich die -10 lohnt.

Benötigt ein PowerShell-Terminal mit einer Breite> ~ 150. Oder Sie müssen den zusätzlichen Zeilenumbruch (den das Terminal beim Umbruch der Ausgabe hilfreich einfügt) manuell entfernen, wenn Sie den Code kopieren und einfügen. Oder Sie erfassen die Ausgabe in einer Variablen und führen diese Variable erneut aus. Etc.

_{Edit 1 - Einige Bytes durch Entfernen des "STOP!" Wortlaut.
Edit 2 - Durr, nicht verwenden .length jedes Mal, rufen Sie einfach einmal
bearbeiten 3 - Ist ein quine nicht sein müssen, so dass die erste Auflage viel kürzer sein kann
bearbeiten 4 - Änderungen verwenden Strings Arrays zu berechnen $c, die zwei Bytes gespeichert. Ich bin mir ziemlich sicher, dass dies für diesen Ansatz fast optimal ist.
Edit 5 - Speichert ein weiteres Byte, indem die Gleichheit direkt gezählt wird, anstatt sie zu modifizieren}

JavaScript, 79 - 10 = 69 Bytes

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

Ohne Function.prototype.toStringauf irgendeine Weise zu benutzen .

Befunge, 57 - 10 = 47 Bytes

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

Dieser ist fantastisch. Probieren Sie es hier aus .

Batch, 73 + 5 - 10 = 68 Bytes

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

Benötigt CMD /V:ONalso habe ich 5 Bytes dazuaddiert .

Python 2.7, 107 Zeichen

Indem ich Rekursion benutze und kein Quine schreibe, dachte ich, ich könnte viel sparen, was zwar stimmt, aber nicht gut genug ist. Obwohl ich kein Gewinner bin, finde ich, dass es Spaß macht, diesen Ansatz zu teilen.

Ich begann damit, eine Zeichenfolge für N = 4 zu erstellen \und die "Zeichen und zu umgehen.

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

Dann habe ich eine Lambda-Funktion erstellt, die diese Zeichenfolge basierend auf einem Startindex und einem Stoppindex unter Verwendung von Rekursion erstellt. Das ist es:

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

Benutze es so:

print l(1,15)

Ausgabe: [32902 Zeichen, zu lang zum Verarbeiten]

Mein Kolmogorov-Komplexitätsansatz scheint also nicht so erfolgreich zu sein ;-)

SMBF , 28 Bytes

\x10steht für ein Literalbyte (Dezimalwert 16). Die Ganzzahl wird als Ganzzahl (Byte) ausgegeben. Die erste Zeichenausgabe ist also \x01. Das Programm gibt dann "," aus. Beim Drucken einer eigenen Quelle wird +am Anfang eine zusätzliche Quelle gedruckt .

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

Erläuterung:

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

Beachten Sie, dass Sie dies nicht in einem Standardinterpreter ausführen können, da ein Hex-Literal in der Eingabe erforderlich ist. Sie benötigen außerdem einen speziellen Anschluss, damit die Hex-Ausgabe ordnungsgemäß funktioniert.

Bash, 78 74 73 - 10 = 63 Bytes (Beispiel, kann nicht gewinnen)

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

Ich kam zu spät, sah aber, dass Bash nicht ausprobiert worden war, also probieren Sie es aus. Erste Golf-Herausforderung und quineartiges Rätsel. Sie machen Spaß!

Erläuterung:

Dies funktioniert, weil aSchritte von 1 bis 15 und ist dann unsetzusammen mit p. Das Skript (gespeichert in p) druckt beide aus, wenn sie setund "STOP!" Andernfalls. Der Anfangsbuchstabe unset aist set0, da er in einer arithmetischen Erweiterung erscheint.

𝔼𝕊𝕄𝕚𝕟, 30 Zeichen / 47 Byte (nicht wettbewerbsfähig)

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

Try it here (Firefox only).

Endlich eine gute alte Quine für 𝔼𝕊𝕄𝕚𝕟 gefunden.

Erläuterung

Hier ist die wahre Quine, die ich verwendet habe: ⟮ⒸⅩ222+ᶈ0

Sie sehen es in meiner Antwort? Hoffentlich können Sie von dort aus expandieren.

Keg + PHP, 19-10 = 10 Bytes

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

Zählt von 1 bis 15 und stoppt dann. TIO

Fass, 13 Bytes

ï_(. \,,,).