Tworzenie wszechstronnej drukarki liczb całkowitych jest fajne, ale pisanie jednego kodu, który drukuje wiele różnych liczb, jest uciążliwe. Czy nie byłoby łatwiej stworzyć skrypt, który wypisuje liczbę, ale daje także nowy skrypt, aby uzyskać następny numer?

Wyzwanie:

Napisz kod, który wyświetli jedną liczbę całkowitą Ni kod wykonywalny. Następny kod powinien zostać wypisany, N+1a kod, który może wypisać N+2. Kontynuuj tę ścieżkę, aż dotrzesz N = 15. (Ostatni wydrukowany numer powinien wynosić 15).

Zasady:

• Brak danych wejściowych (zakładając, że dane wejściowe są puste).
• Dozwolony jest pełny program lub funkcja lub inne wygodne formaty.
• Pierwszy kod powinien zostać wyprowadzony 1.
• Nie można wyprowadzać zer wiodących. Czyli nie można drukować 01na 1.
• Dane wyjściowe muszą mieć format N, Code_for_N+1. Zauważ, że dane wyjściowe są oddzielone przecinkiem i pojedynczą spacją. Kod dla N+1nie ma otaczających cudzysłowów. N , Code_for_N+1nie jest akceptowane (spacja przed przecinkiem). Końcowe znaki nowej linii są w porządku.
• Pierwszymi znakami danych wyjściowych musi być liczba. (Bez spacji wiodących lub ans = N).
• Wydrukowany numer nie powinien być częścią następnego kodu (kod może zawierać ten numer, ale nie można traktować numeru wyjściowego jako części kodu)
  • Przykład: wyjście N=2może być: 2, printer 2. W tym przypadku printer 2jest kod N=3. Nie możesz użyć całego wyniku: 2, printer 2jako kodu dla N=3.
• Skrypty mogą być w różnych językach
• Typy danych są nieistotne (liczba może być ciągiem), ale nie może być otoczona niczym (cudzysłowy, nawiasy itp.).
• Jeśli jest wyprowadzany kod N=15, musi on albo wydrukować STOP!(patrz bonus), albo w ogóle nic nie wydrukować (nawet spacji lub nowego wiersza).
  • Kod parametru N=15nie może ulec awarii (ale wysyłanie do STDERR jest prawidłowe).
  • Jesteś zdyskwalifikowany, jeśli kod wyjściowy dla N=15wydruków 16lub cokolwiek innego (z wyjątkiem przypadku bonusowego).
• Wbudowane operatory quine są niedozwolone.
• Dostęp do pliku źródłowego za pośrednictwem systemu plików jest niedozwolony.

Premia:

-10 bajtów, jeśli kod, który drukuje 15, tworzy również kod, który drukuje „ STOP!”

Przykłady wykorzystujące składnię Pythona: (oczywiście będą one działać tylko dla wybranych liczb całkowitych, a nie od 1 do 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

Obowiązują standardowe zasady gry w golfa! Wygrywa najmniejszy kod (dla N = 1) w bajtach!

Pyth + ///, 15 bajtów - 10 = 5

pPt`S15", STOP!

Spowoduje to wydrukowanie 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, STOP!w języku Pyth, pobranie range(1,15+1)i usunięcie nawiasów początkowych i końcowych oraz wydrukowanie go, a następnie „, STOP!”.

Następne czternaście programów znajduje się w ///, który bezpośrednio wyświetla wszystkie programy, które nie zawierają /lub \. Więc drugi program

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

daje 2i trzeci program 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15. Przedostatni program 15, STOP!drukuje 15, STOP!, więc ostatni program jest po prostu STOP!.

JavaScript, 131238 - 10 = 131228 bajtów

Naiwne podejście okazało się gorsze niż oczekiwano. Z perspektywy czasu powinienem się tego spodziewać. Ale myślałem, że i tak to podzielę. Pełny kod tutaj.

Pomysł: Iteracyjnie ucieczka i dodanie N-1, ...

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

CJam, 26 25 24 bajtów

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

Wypróbuj online.

Kolejne programy mają po prostu zwiększoną pierwszą liczbę. Spowoduje to uruchomienie programu 16 razy.

Lub z premią za ten sam wynik:

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

Wypróbuj online.

Kolejne programy mają po prostu zwiększoną pierwszą liczbę. Spowoduje to uruchomienie programu 16 razy.

Alternatywne rozwiązanie dla premii:

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

JavaScript (ES6), 62 61 bajtów - 10 bonusów = 51 punktów

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

Wyjaśnienie

Rozwiązanie, które nie odczytuje własnego kodu źródłowego, a także nie jest absurdalnie długie.

Pierwszy program konstruuje wszystkie 15 innych programów i zagnieżdża je w sobie za pomocą funkcji rekurencyjnej. Rozwiązuję problem z odwrotnym ukośnikiem, zagnieżdżając same funkcje (które są następnie rzutowane na łańcuchy podczas wyjścia) zamiast łańcuchów.

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

Test

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 bajty

Dzięki @StewieGriffin za kilka bajtów =)

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

Pierwsza część to ciąg znaków reprezentujący drugą linię (poniżej), rzeczywisty kod (tylko przesunięty o 9). W Matlabie ciągi są macierzami wypełnionymi znakami, dzięki czemu można łatwo wykonywać zmiany, po prostu dodając / odejmując skalar. Tak więc program po prostu drukuje ponownie ten sam ciąg *, plus ten sam ciąg, ale został przesunięty, co skutkuje kodem.

* Niezupełnie: pierwszy bajt to licznik, który należy zwiększyć w każdej iteracji.

Quine trick ze sznurkiem został stąd bezwstydnie skradziony .

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

Oto kilka ostatnich wierszy sekwencji skopiowanych z konsoli:

>> '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 ^* bajtów

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

Jest to funkcja, która wydobywa własne ciało (tylko a) i dokonuje w nim zamian. Uzyskanie treści funkcji wbudowanej funkcji JavaScript, choć nie jest jawnym operatorem quine (jeśli jest niepoprawna, usunie odpowiedź).

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

W przypadku, gdy nie działa tam poprawnie osadzone (ponieważ dla mnie nie działa), możesz zobaczyć tam przykład .

^{* - wygląda na to, że fragment kodu daje wynik bez a=, uniemożliwiając dalsze połączenia}

Python 2.7.10, 196 = 82 bajtów

Whee !!! To było fajne. Teraz znacznie krótszy. : 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!"

Wyjaśnienie:

Zacząłem od tego:

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

To tylko prosta quine. Po dodaniu licznika:

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

njest zmienną przeciwną, która jest drukowana na początku. Wtedy, gdy jego wydrukowanie n=części, zastępuje on n+1dla %d. Odtąd będzie się to liczyło w nieskończoność.

A oto ostateczna wersja. Dodaje klauzulę if, aby zatrzymać o 15, i wypisuje „STOP!” także.

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

Stary kod:

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

Nigdy nie wygrywam, ale fajnie. : P O wiele krótszy, choć wciąż nie mam szans. : P

PowerShell, (215-10) = 205 197 167 106 104 103 bajtów

$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

_{(Jeśli Twoim jedynym narzędziem jest PowerShell, każdy problem wygląda jak gwóźdź. Poczekaj ...)}

Zasadniczo zaczynamy od ustawienia $drównego długiemu ciągowi olefiny prawie dziesięciu oryginalnego kodu. Wyprowadza 1a następnie $dz operatorem formacie -fpoprawnie wypełnić {0}, {1}, {2}stand-ins, zwiększając {2}liczbę w,1*{2} przekroju jeden za każdym razem.

,x*yOperacja w PowerShell tworzy nową tablicę yelementów, z których każdy jest równy x. Na przykład,,2*3 jest równoważne z @(2,2,2).

Oznacza to, że pierwsze wyjście będzie 1, $c=(,1*2).length;$d=(etc...), więc gdy drugi kod jest wykonywany, $cbędzie równa rachubę tablicy @(1,1)lub 2itp Zauważmy, że$c nie są wykorzystywane jako zmienna w oryginalnym kodzie, tylko w kolejnych seriach.

Zatrzymuje się, gdy drukuje 15, po prostu obliczając, czy $cjest równy, 15a następnie indeksując do tablicy, 0-ty element jest taki $c, $djak opisano powyżej, drugi jest po prostu 15. Tak więc, kiedy $cma 15 lat, będzie generować 15i nic więcej. Nie kwalifikuje się do premii, ponieważ"15, {0}STOP!{0}" jest o 5 znaków za długi, aby wartość -10 była opłacalna.

Wymaga terminala PowerShell o szerokości> ~ 150. Lub do ręcznego usunięcia dodatkowego łamania linii (że terminal jest pomocny wkładki na wyjściu opasania) podczas kopiowania wklejenie kodu. Lub w celu przechwycenia danych wyjściowych w zmiennej, a następnie ponownego uruchomienia tej zmiennej. Itp.

_{Edycja 1 - Zapisano niektóre bajty, usuwając „STOP!” sformułowanie.
Edytuj 2 - Durr, nie używaj .length za każdym razem, po prostu wywołaj go raz
Edytuj 3 - Nie musi to być quine, więc początkowy przebieg może być znacznie krótszy
Edytuj 4 - Zmieniono z używania ciągów na tablice do obliczenia $c, co pozwoliło zaoszczędzić dwa bajty. Jestem prawie pewien, że jest to prawie optymalne dla tego podejścia.
Edycja 5 - Zapisano kolejny bajt, bezpośrednio licząc równość, a nie modując}

JavaScript, 79–10 = 69 bajtów

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

Bez użycia Function.prototype.toStringw jakikolwiek sposób.

Befunge, 57-10 = 47 bajtów

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

Ten jest niesamowity. Wypróbuj tutaj .

Partia, 73 + 5–10 = 68 bajtów

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

Wymaga, CMD /V:ONwięc dodałem do tego 5 bajtów.

Python 2.7, 107 znaków

Używając rekurencji, a nie writing a quine, I thought I could save a lot, which is true, but not good enough. Although not a winner, I think the approach is fun to share.

Zacząłem od utworzenia ciągu dla N = 4, unikając znaków \i ".

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

Następnie utworzyłem funkcję lambda, która tworzy ten ciąg, na podstawie indeksu początkowego i indeksu zatrzymującego, za pomocą rekurencji. To jest to:

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

Użyj tego w ten sposób:

print l(1,15)

Dane wyjściowe: [32902 znaków, za długi do obsługi]

Wygląda więc na to, że moje podejście do złożoności Kołmogorowa nie jest tak skuteczne ;-)

SMBF, 28 bytes

\x10 represents a literal byte (decimal value 16). The integer is output as an integer (byte). So the first character output is \x01. The program then prints ", ". When printing its own source, it prints an extra + at the beginning.

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

Explanation:

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

Note that you cannot run this in a standard interpreter because it requires a hex literal in the input. You also need a special terminal for hex output to work properly.

Bash, 78 74 73 - 10 = 63 bytes (Example, can't win)

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

Coming in late, but saw bash hadn't been tried so gave it a go. First gulf challenge and quine-like puzzle. They're fun!

Explanation:

This works because a steps from 1 to 15 and is then unset along with p. The script (stored in p) prints them both out if they're set and "STOP!" otherwise. The initially unset a is set to 0 because it appears in an arithmetic expansion.

𝔼𝕊𝕄𝕚𝕟, 30 chars / 47 bytes (non-competitive)

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

Try it here (Firefox only).

Finally found a good ol' true quine for 𝔼𝕊𝕄𝕚𝕟.

Explanation

Here's the true quine that I used: ⟮ⒸⅩ222+ᶈ0

You see it in my answer? Hopefully, y'all will be able to expand from there.

Keg+PHP, 19-10=10 bytes

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

Counts from 1 to 15 and then stops. TIO

Keg, 13 bytes

ï_(. \,,,).