Masz napisać program, który wyśle ​​kod źródłowy, który jest

1. Większy niż oryginalny program (pod względem znaków)
2. Po uruchomieniu wydrukuje inny program większy niż on sam (tj. Nowy program jest również prawidłową odpowiedzią na to wyzwanie)

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź.

GS2 (8636bd8e) , 0 bajtów

Spowoduje to wydrukowanie jednej nowej linii, która wypisze dwie nowe linie, która wypisze trzy nowe linie, i tak dalej.

Wypróbuj online!

H9 + : 1 znak

9

Zgadza się. Jedna postać. Wysyła tekst do 99 butelek piwa , co jest prawidłowym programem. Wszystkie zewnętrzne dane się nie liczą, ale jest tam mnóstwo 9s.

Rezultatem wyprodukowanego programu jest tekst do 99 butelek piwa 59 razy.

Ta funkcja podaje liczbę wyświetleń tekstu, jeśli uruchomisz nczasy programu (jeśli moje obliczenia są prawidłowe):

f(n) = 59n-1

GolfScript, 9 znaków

{.'.~'}.~

Ten kod generuje:

{.'.~'}{.'.~'}.~

które wyjścia:

{.'.~'}{.'.~'}{.'.~'}.~

które wyjścia:

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

i tak dalej.

Uważam, że jak dotąd jest to najkrótsza odpowiedź w „prawdziwym” języku programowania Turinga.

Wyjaśnienie:

Zasadniczo powyższy oryginalny kod jest „warstwą quine”: wyprowadza normalną quine, po której następuje sama.

W GolfScript każdy literał bloku kodu (np. {foo}), Jeśli pozostanie niezakłócony na stosie, jest quine. Tak więc, {.'.~'}sam z siebie wypisuje, tak jak każdy inny blok kodu.

Na .~końcu kodu pobiera ostatni blok kodu na stosie, kopiuje go i wykonuje kopię. Po uruchomieniu kod .'.~'wewnątrz bloku kodu duplikuje najwyższy element na stosie (tj. Jego kopię) i dołącza ciąg .~.

Na końcu programu interpreter GolfScript strituje i wypisuje wszystko na stosie, który w tym przypadku składa się z jeszcze jednego {.'.~'}bloku niż na wejściu oraz łańcucha .~.

Premia:

Dodanie ]przed pierwszym .(aby zebrać wszystkie bloki kodu na stosie do tablicy przed ich zduplikowaniem) powoduje, że rośnie on wykładniczo:

{].'.~'}.~

wyjścia:

{].'.~'}{].'.~'}.~

które wyjścia:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

które wyjścia:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

i tak dalej.

Znaki Java 7: 0

Zapisz jako plik Blank.java. Jeśli zapiszesz go jako inny plik, zastąp dowolne wystąpienie Blankodpowiednią nazwą pliku.

Następnie uruchom w wierszu poleceń, najpierw kompilując, a następnie uruchamiając. Jeśli kompilacja się nie powiedzie, zatrzymaj się.

Podaję to jako Java 7, ponieważ może to wyglądać inaczej dla różnych wersji Java.

Pierwsze kilka wyników (wysyłanych do stderr):

Error: Could not find or load main class Blank

Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
                                              ^
2 errors

Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                          ^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                                     ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
                                          ^
  (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
                                               ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
     ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
              ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                   ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                 ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
                                        ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                         ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                                              ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:6: error: = expected
                                              ^
                                              ^
Blank.java:6: error: ';' expected
                                              ^
                                               ^
Blank.java:7: error: reached end of file while parsing
2 errors
        ^
30 errors

HQ9 +, HQ9 ++ i podobne, 2 znaki

QQ

To jest wynik:

QQQQ

Rubin 27

Bardzo nieznacznie zmodyfikowana wersja tego ( przez ):

puts <<3*3,3
puts <<3*3,3
3

Liczba putswydrukowanych linii rośnie wykładniczo.

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3

$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
    3283

Rachunek Lambda - 29

Prosty termin lambda

(λu.(u u)(u u))(λu.(u u)(u u))

Skrócenie tego terminu o jedną redukcję beta daje

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

I tak dalej i tak dalej. Jest to prosty wariant klasycznego, (λu.u u)(λu.u u)który jest rachunkiem różniczkowym w rachunku lambda, podwójne zastosowanie tutaj oznacza, że ​​otrzymujemy podwójną moc wyjściową.

Skrypt SH, 9

cat $0 $0

Rośnie w tempie wykładniczym.

Uruchom jako sh whatever.shlub ustaw jako plik wykonywalny.

Wersja systemu Windows jest tutaj .

dc 11

Całkiem proste:

6579792
dfP

Pierwszy wiersz jest powtarzany raz na każde pokolenie:

$ dc growing_quine.dc
6579792
6579792
dfP

$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

Ostatni wiersz składa się z następujących instrukcji: dduplikuje ostatnią wartość umieszczoną na stosie (6579792) (abyśmy otrzymywali jeszcze jedną kopię za każdym razem, gdy go uruchamiamy), fdrukuje cały stos (który jest wiązką tej samej liczby) i Pdrukuje liczbę (6579792) jako strumień bajtów, który wyświetla się jako dfP.

redcode (rozwiązanie rekurencyjne)

Oto kod najłatwiejszego do zapisania wojownika w redcode , słynnego Imp:

MOV 0, 1

Po wykonaniu kod zapisuje kopię swojej pojedynczej instrukcji pod następnym adresem w pamięci; następnie wykonuje to itp.

Python 3 - 55

print(open(__file__).read())
f=lambda:print('f()')
f()

Można to skrócić, zastępując __ plik__ jednoznakową nazwą pliku i zapisując plik jako taki, ale czułem, że ta odpowiedź była bardziej zgodna z duchem pytania. Po jednej iteracji generuje:

print(open(__file__).read())
f=lambda:print('f()')
f()
f()

Smalltalk, 125 61 57

Wersja golfowa wygląda prawie nieczytelnie, więc najpierw wyjaśnię (i użyję prawdziwych identyfikatorów).

Jest to wariant metody samodzielnej modyfikacji „najdziwniejszego sposobu na wytworzenie przepełnienia stosu”.

Metoda wypisuje komunikat „witaj” i jego bieżące źródło (tylko dla celów demonstracyjnych). Następnie kod jest modyfikowany, aby wyświetlać dłuższy ciąg i instalowany. Wreszcie nowy kod jest nazywany rekurencyjnie.

Aby uchronić się przed natychmiastowym niekontrolowanym, pozwala użytkownikowi potwierdzić w każdym cyklu.

skompiluj w obiekcie:

eatMe_alice
   |msg mySource|

   mySource := thisContext method source.

   '**** Hello Alice' printCR.
   '  ---- my current code is:' printCR.
   mySource printCR.
   '  ---------------' printCR.

   (UserConfirmation confirm:'Again? ') ifTrue:[
       Object compile:
            (mySource
                copyReplaceString:'Hello ','Alice'
                withString:'Hello ','Alice !').
       self eatMe_alice
   ]

rozpocznij pokaz, wysyłając „eatMe_alice” do dowolnego obiektu; zero zrobi:

nil eatMe_alice

Przyjemnym wariantem jest nie wywoływanie nowego kodu rekurencyjnie, ale iteracyjnie, przez cofnięcie stosu wywołań i ponowne wejście do nowej metody. Ma to tę zaletę, że nie prowadzi do wyjątku rekurencji. Aby to zrobić, zastąp wywołanie rekurencyjne („self eatMe_alice”) przez:

thisContext resend

Gra w golfa:

Oczywiście nie wymagano drukowania i samodzielnego dzwonienia, więc najkrótsze (dla golfa) jest po prostu dodanie komentarza do mojego źródła i zwrócenie go. Jako efekt uboczny instaluje się go również do następnego połączenia ...

x|s|Object compile:(s:=thisContext method source,'""').^s

Skrypt SH, 12 8 7

Zapisz plik w

sed p *

we własnym, pustym katalogu i uruchamiaj go z tego katalogu, używając sh [file]lub ustawiając plik wykonywalny.

Stara alternatywa z 8 znakami , ale nie potrzebuje własnego katalogu. Zapisz plik w

sed p $0

i uruchom używając sh [file]lub ustawiając plik wykonywalny.

Stara alternatywa z 12 znakami :

sed -i- p $0

To faktycznie wyświetli dane wyjściowe do samego pliku programu, ale nie podano gdzie dane wyjściowe. Replikuje się w tempie wykładniczym.

JavaScript, 41 , 40 znaków

function f(){console.log(f+"f(f())")}f()

Przy pierwszym uruchomieniu program wypisuje się z innym ;f()na końcu. Kolejne przebiegi wyjściowe powodują dwukrotne wydrukowanie każdego źródła „wejściowego”.

alertbyłby krótszy niż, console.logale nie uważam wielu okien dialogowych z alertami za wyjściowe, podczas gdy rozsądne wydaje się wywoływanie wielu linii w konsoli jako wyjściowych.

J , 1 bajt

'

Wypróbuj online!

Otwarta oferta zawiera oczywiście błąd otwartej oferty:

|open quote
|   '
|   ^
|[-1] /home/runner/.code.tio

Zauważ, że z natury interpretera J błędy są drukowane do STDOUT , a nie do STDERR.

Gdy powyższe zostanie uruchomione jako kod, zostanie wydrukowane:

|open quote
|   |   '
|       ^
|[-2] /home/runner/.code.tio

Następnie

|open quote
|   |   |   '
|           ^
|[-2] /home/runner/.code.tio

i tak dalej. Za każdym razem, gdy kod jest uruchamiany, drugi wiersz jest uzupełniany w lewo czterema bajtami |   , spełniając wymagania tego wyzwania.

J , właściwy wariant quine, 25 bajtów

echo,~'echo,:~(,quote)'''

Wypróbuj online!

Wyjścia

echo,:~(,quote)'echo,:~(,quote)'

A potem wysyła się dwukrotnie, w osobnych wierszach:

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

następnie

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

i tak dalej.

Pierwsze wyjście jest prosty wariant standardowego J Quine'a . Dodany ,:~konkatenuje się w pionie, a wynikowa tablica 2D jest drukowana jako dwa rzędy tego samego łańcucha.

Windows .BAT, 25

@COPY %~nx0+%~nx0 CON>NUL

Rośnie w tempie wykładniczym.

Równoważna wersja SH tutaj .

siatkowy, 11 bajtów, niekonkurujący

"'34'coo1o;

Jest to standardowy szkielet quine, z tym że 1po każdej iteracji drukowane jest dodatkowe . Wypróbuj online!

Pierwsze kilka wyników:

"'34'coo1o;
"'34'coo1o;1
"'34'coo1o;11
"'34'coo1o;111

Microscript II, 6 bajtów

Język niekonkurencyjny, datuje wyzwanie.

"qp"qp

Pierwsza iteracja dodaje dodatek qpdo końca, a każda kolejna iteracja dodaje dodatkową kopię tego oryginalnego programu na początku.

Runiczne Zaklęcia , 6 bajtów

"'<S@>

Wypróbuj online!

Ten był dziwny. Wszystko, co musiałem zrobić, to usunąć ~oryginał z quine znalezionej przez Jo Kinga .

Każde dodatkowe uruchomienie dołącza kolejne <do końca, np .:

"'<S@><<<<<<<<<

Z których nic nie robi.

EcmaScript 6 (51 bajtów):

(_=x=>'(_='+_+Array(x++).join(','+_)+')('+x+')')(2)

Tworzy dłuższą wersję siebie, która może wytworzyć dłuższą wersję siebie, która może wyprodukować dłuższą wersję siebie itp. ...

PHP, 38

<?echo fgets(fopen(__FILE__,'r')).';';

Dodanie średnika przy każdym uruchomieniu.

ECMAScript 6 (38 znaków)

(f=_=>'(f='+f+')();(f='+f+')();')();

Które wyjścia:

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

Edytować

Możesz zrobić (28 znaków):

(f=_=>'(f='+f+')();'+f())();

Jednak będzie się powtarzać w nieskończoność i nigdy nie zwróci niczego ... ale można to rozwiązać robiąc coś takiego (42 znaki):

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

Co da wynik:

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);

Common Lisp, 16 znaków

(print `(or ,-))

To prawda, że ​​jest interaktywny, ale możliwość odniesienia się do bieżącej formy najwyższego poziomu jest prawdopodobnie najlepszym sposobem na zminimalizowanie niebanalnego programu, który spełnia specyfikację.

To, co byłoby naprawdę interesujące, to to, co wysadza się najszybciej. Może coś takiego

(print `(progn ,@(loop repeat (length -) collect -)))

Julia, 66 znaków

x="print(\"x=\$(repr(x))\\n\$x;\"^2)";print("x=$(repr(x))\n$x;"^2)

Wyjście (134 znaków):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Wynik wykonania wyniku (268 znaków):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

następny wynik (536 znaków):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Następny wynik (1072 znaków):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Mam nadzieję, że jest to zgodne z zasadami.

Daje większy wynik, a sam wynik jest poprawnym kodem źródłowym, który ponownie wytwarza większy wynik.

05AB1E, 15 bajtów, niekonkurujące

0"DÐ34çý"DÐ34çý

Wypróbuj online!

Odbitki 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
która drukuje 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
etc.

Evoloop, 9 × 9 prostokąt (81 komórek)

Evoloop automat komórkowy dołączone Golly obsługuje wzory, które replikują się w „Quine-like” sposób. W szczególności każdy z tych wzorów zawiera „program”; wzorzec odtwarza się najpierw poprzez uruchomienie programu (który tworzy „ciało” córki), a następnie przez skopiowanie programu do córki.

Powyższe dotyczy bardziej znanego automatu komórkowego „Pętle Langtona”, a także Evoloopa, ale Evoloop ma interesującą różnicę, polegającą na tym, że łatwo jest stworzyć wzór, który rośnie w każdym kolejnym pokoleniu.

( Moim zdaniem o wiele bardziej interesujący jest fakt, że Evoloop jest prostym automatem komórkowym, który zawiera wzorce, które się reprodukują i ewoluują w sposób podobny do życia! Myślę, że jedynymi znanymi automatami komórkowymi, które to robią, są Evoloop i jego potomkowie Wadą Evoloop jest jednak to, że istnieje jeden szczególny „najlepszy” genom; ewolucja zawsze ostatecznie zbiega się do tego jednego genomu.)

Obecnie istnieją dwa niedociągnięcia w tym oświadczeniu. Jednym z nich jest to, że nie jest jasne, jakie jest „wyjście” automatu komórkowego. Myślę jednak, że automat do reprodukcji jest „wystarczająco blisko”, by być quine; to z pewnością nie mniej interesujące! Inną wadą jest to, że wzorce te nie tworzą po prostu jednej kopii; każda kopia oryginalnego wzoru próbuje stworzyć nieskończenie wiele swoich kopii, które ostatecznie oddziaływują ze sobą w destrukcyjny sposób. Myślę, że spełniłem wymagania tego wyzwania w duchu, ale nie w piśmie.

Bez zbędnych ceregieli wzór jest następujący:

022222220
270170172
212222202
202000212
272000272
212000202
202222212
271041032
022222250

Oto ponownie wzór w formacie, który można skopiować i wkleić w Golly:

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

Okej, ale jak to wygląda? To wygląda tak:

Na powyższej animacji możesz zobaczyć, jak początkowy wzór tworzy większą córkę, która tworzy większą wnuczkę, następnie większą prawnuczkę, a na koniec jeszcze większą pra-prawnuczkę, która zaczyna budować jeszcze większą trzecią-pra- wnuczka. Gdybyś używał tego schematu przez długi czas, trwałby tak w nieskończoność (a może w końcu zostałyby wyprzedzone przez ewolucyjne organizmy, które są w stanie rozmnażać się znacznie szybciej; nie jestem pewien).

SERIA, 26

Umieść ten kod w dowolnym pliku .bat, a on będzie nadal działał (w nieskończonej pętli), a plik również się powiększy.

echo echo %0 ^>^> %0 >> %0

PYG (6)

P(Q,Q)

Drukuje własny kod źródłowy, oddzielony znakami nowej linii. Drugie pokolenie byłoby

P(Q,Q)
P(Q,Q)

i tak dalej.

OLEJ , 83 bajty

0
0
1
1
1
4
1
11
4
1
11
1
2
2
1
12
18
10
18
1
32
22
1
18
26
4
26
8
18
11
6
17
4
26

Najpierw drukuje dwie linie z zerami, a następnie porównuje każdą linię z linią 1, jeśli są one równe (co ma miejsce w przypadku wyczerpania pliku), wypisujemy to, co jest w komórce 26. Wynikowy wynik będzie wyglądał to samo, z wyjątkiem dodanego 33, który nic nie robi. Następnym razem zostanie dodana kolejna linia i tak dalej.

Pomoc, WarDoq! , 1 bajt.

H.

Wydruki Hello, World!.

Inne znaki niż H są poprawnym (i bezpiecznym) kodem źródłowym (który wypisuje inne warianty Hello World).