Biorąc pod uwagę tablicę dodatnich liczb całkowitych Ajako danych wejściowych, wygeneruj program, który po powtórzeniu krazy wyświetli wartość kth (1-index) tablicy.

Na przykład, jeśli tablica jest [1,11], wyjście powinno być programem, który wypisuje 1, a po dwukrotnym powtórzeniu, wyjście 11. Kod jak print(end="1");w Pythonie 3 działa: print(end="1");wypisuje 1 i print(end="1");print(end="1");wypisuje 11

Wygrywa najmniejsza suma długości kodu do rozwiązania wszystkich przypadków testowych. Twój meta kod powinien rozwiązać 500 przypadków testowych w latach 60., a każdy kod rozwiązania powinien zwrócić za 10 sekund. Kod meta i kod rozwiązania nie muszą być w tym samym języku, ale wszystkie rozwiązania generowane przez Twój metaprogram powinny być w tym samym języku.

Dane z testu wstępnego i generator można zobaczyć tutaj . 7 dni później wykorzysta sumę czasu przesłania (np. 12:34 średnia 1234) jako losowe ziarno i wygeneruje kolejny przypadek testowy jako ostateczny przypadek testowy.

Końcowy materiał siewny to 7335 w GMT + 8, więc ostateczne dane testowe są tutaj

Python 3 , generuje Stax

Korzysta z różnych strategii. Większość strategii ma zastosowanie tylko pod pewnymi warunkami, ale istnieje jedna strategia zastępcza, która jest zawsze użyteczna. Na koniec wybierany jest najmniejszy program kandydujący.

from functools import reduce
from math import sqrt

symbols = " !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_abcdefghijklmnopqrstuvwxyz{|}"

def uncycle(arr):
    for size in range(1, len(arr)):
        if all(e == arr[i % size] for (i, e) in enumerate(arr)):
            return arr[:size]
    return arr

def constant(val):
    return "A" if val == 10 else str(val)

def shift(val):
    if not val: return ""
    return constant(abs(val)) + "+-"[val < 0]

def encode(a, offsetMode):
    result = "";
    if offsetMode:
        for i in range(len(a) - 1, 0, -1):
            a[i] -= a[i - 1]
    for i in range(len(a)):
        parts = []
        signBit = (a[i] < 0) * 2
        continuing = (offsetMode and i == len(a) - 1) * 1
        remain = abs(a[i])
        while remain > 22:
            parts.insert(0, remain % 46 * 2 + continuing);
            remain //= 46
            continuing = 1

        parts.insert(0, remain * 4 + signBit + continuing)
        result += "".join(symbols[p] for p in parts)
    
    return result

def cram(arr):
    flat = encode(arr, False)
    offset = encode(arr, True)
    return offset if len(offset) < len(flat) else flat;

def issquare(num):
    root = int(sqrt(num))
    return root * root == num

def isgeometric(arr):
    r = arr[0]
    return all(r ** (i + 1) == e for (i,e) in enumerate(arr))

def generateProgram(arr):
    candidates = []
    rotated = uncycle(arr)
    rotated = rotated[-1:] + rotated[:-1]

    deltas = [b - a for a,b in zip(arr, arr[1:])]

    # single constant strategy
    if len(arr) == 1:
        candidates.append(constant(arr[0]))

    # repeated constant
    elif len(set(arr)) == 1:
        num = arr[0]
        if num == 10: candidates.append("A")
        if num % 2 == 0: candidates.append(constant(num // 2) + "H")
        if issquare(num): candidates.append(str(int(sqrt(num))) + "J")
        candidates.append(constant(num - 1) +  "^")

    # repdigit
    if len(arr) == 2 and 10 < arr[1] == arr[0] * 11 < 100:
        candidates.append(str(arr[0]) + "p")

    # single digits
    if max(arr) < 10:
        candidates.append("".join(map(str, rotated)) + "E|X@")

    # max 10
    if max(arr) == 10 and rotated[0] != 1:
        candidates.append("".join(str(e - 1) for e in rotated) + "E|X@^")

    fns = [
        ("", lambda x: x),
        ("H", lambda x: 2 * x),
        ("^", lambda x: x + 1),
        ("J", lambda x: x * x),
        ("Hv", lambda x: 2 * x - 1),
        ("H^", lambda x: 2 * x + 1),
        ("^H", lambda x: 2 * x + 2),
        ("HJ", lambda x: 4 * x * x),
        ("JH", lambda x: 2 * x * x),
        (":T", lambda x: x * (x + 1) / 2),
        ("|F", lambda x: reduce(lambda a, b: a*b, range(1, x+1))),
        ("J^", lambda x: x * x + 1),
        ("^J", lambda x: x * x + 2 * x + 1),
    ]
    for (stax, fn) in fns:
        if all(fn(i + 1) == e for (i,e) in enumerate(arr)):
            candidates.append("|X" + stax)

    # fixed delta
    if len(set(deltas)) == 1:
        delta = deltas[0]
        start = arr[0] - delta
        if start == 0:
            candidates.append(shift(delta))
        if delta == 1:
            candidates.append("|X" + shift(start))
        elif delta == -1:
            candidates.append("|x" + shift(start))
        elif delta > 1:
            candidates.append("|X" + constant(delta) + "*" + shift(start))
        elif delta < -1:
            candidates.append("|x" + constant(-delta) + "*" + shift(start))

    # geometric series
    if isgeometric(arr):
        candidates.append(constant(arr[0]) + "*")

    # prefix
    if len(arr) == 2 and arr[1] // 10 == arr[0] < 10:
        candidates.append("." + str(arr[1]) + "|X(")

    # suffix
    if len(arr) == 2 and arr[0] % 10 == arr[1] < 10:
        candidates.append("." + "".join(map(str, arr)) + "|X)")

    # uncycled cram
    candidates.append('"' + cram(rotated) + '"!|X@')
    
    candidates.sort(key=len)
    return candidates[0]

while True:
    arr = eval(input())
    prog = generateProgram(arr)
    print(prog)

Wypróbuj online!

Aktualizacja: Walidacja Wykonanie każdej krotności każdego programu osobno będzie czasochłonne. Możliwe jest uruchomienie ich wszystkich jednocześnie. W tym celu należy użyć małego fragmentu kodu. Jest odpowiedzialny za kilka rzeczy.

1. Wykonaj niejawne dane wyjściowe, jeśli takie istnieją. Zwykle na końcu programu stax górna część stosu jest drukowana, jeśli nie było innych wyników. W przypadku uruchamiania wielu programów w tym samym pliku źródłowym należy to zrobić jawnie.

2. Wyczyść oba stosy.

3. Resetuj rejestry. W przypadku tych programów używany jest tylko rejestr x.

Tę płytkę należy zastosować po każdym indywidualnym programie do wykonania.

|d{P}{zP}?0XLd

Na przykład dane wejściowe [5,2,7,3]tworzą program stax 3527E|X@. Wszystkie cztery krotności mogą być testowane jednocześnie.

3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@3527E|X@3527E|X@
|d{P}{zP}?0XLd

Wypróbuj online!

W ten sposób możliwe jest przetestowanie wszystkich krotności całego programu w tym samym przebiegu, zakładając, że nic się nie psuje. Byłby to prawdopodobnie największy program stax, jaki kiedykolwiek został wykonany, gdyby wykonano wszystkie 500.

Perl 5 -p , generuje Perl 5 -p , obciążenie 19 17 13

-1 dzięki @Dom Hastings

Wynik dla jednego wejścia będzie length of the input + 13. Można to oczywiście poprawić, generując programy samodekompresujące dla większych danych wejściowych, ale nie będę się tym przejmować.

Podaj tablicę wejściową oddzieloną przecinkami w jednym wierszu na STDIN.

#!/usr/bin/perl -p
chomp;$_="}{\$_=($_)[\$%++]"

Wypróbuj online!

Uruchom dane wyjściowe skonkatowane nrazy bez danych wejściowych (np. Przekierowanie z / dev / null)

Przykładowy sposób uruchomienia go dla danych wejściowych, 2,6,4,7a wynikowy program powtórzono 4 razy:

perl -p '}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]' < /dev/null

Wypróbuj online!

Jeśli nie podoba ci się wynikowy program próbujący czytać ze STDIN, użyj tej wersji z narzutem 17:

#!/usr/bin/perl -p
chomp;$_="1/!say+($_)[\$-++],"

Wypróbuj online!

Przykładowy sposób uruchomienia go dla danych wejściowych, 2,6,4,7a wynikowy program powtórzono 4 razy:

perl -E '1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],'

Wypróbuj online!

Ta wersja ulega awarii po wydrukowaniu wymaganego wyjścia

05AB1E , generuje 05AB1E

¸»“"ÿ"#.g<“ƵƒçJ

Wypróbuj online!

Wygenerowany program do wprowadzania [5,17,7,13,2]to "5 17 7 13 2"#.g<è.

Zestaw testowy dla [5,17,7,13,2]

Długość wygenerowanego programu wynosi len(input) + 5

APL (Dyalog Unicode)

Anonimowy przedrostek lambda. Zwraca treść programu.

 {
     1=≢⍵:⍕⍵ ⍝ single element

     (2=≢⍵)∧(⍵[2]=11×⍵[1]):⍕⍵[1] ⍝ 2, 22 etc.

     1=≢∪⍵:'⊢',⍕⊃⍵ ⍝ all the same

     (⊢≡⊃×⍳∘≢)⍵:'+',⍕⊃⍵ ⍝ linear

     ((⌊=⊢)!⍣¯1⊢⊃⍵)∧(1∧.=1↓⍵):'!',⍕!⍣¯1⊃⍵ ⍝ factorial followed by all 1s

     (⍵[2]∧.=1↓⍵)∧(⍵[1]=10|2⊃⍵):(⍕⊃⍵),'⌈',(⊃⍕2⊃⍵) ⍝ b ab ab ab

     e←{∊⍉2 2⍴'+×',⍕¨⍵}¨⍸(⊃⍵)=∘.×⍨⍳10
     b←⍵∘≡¨e(({0::⍬ ⋄ ⍎⍵}¨,\)⍴∘⊂)¨⍨(≢⍵)
     ∨/b:⊃b/e

     Q←{'''',⍨⍵/⍨1+''''=⍵}
     (5∧.≤⍵)∧(≢⍕⍵)>6+(+/14=⍵)+≢⍵:'{⍺←⎕AV⍳⊃⋄1⌽⍺⊢⍵}''',Q ⎕AV[⍵] ⍝ string fallback

     (≢⍕⍵)>9+(+/5=⍵)+≢⍵:'{⍺←¯4+⎕AV⍳⊃⋄1⌽⍺⊢⍵}''',Q ⎕AV[4+⍵] ⍝ offset string fallback

     '{⍺←⊃⋄1⌽⍺⊢⍵}',⍕⍵ ⍝ fallback
 }

Wypróbuj online!

Metody

To bada różne metody i zwraca pierwszą użyteczną, ostatecznie wracając do powszechnie stosowanej metody.

Pojedynczy element

Jeśli lista zawiera tylko jeden element, jest zwracana w niezmienionej postaci.

2, 22 itd.

Pojedynczą cyfrę można po prostu powtórzyć, aby wygenerować liczbę 11 razy większą,

Wszystkie takie same

Zwracamy tylko najbardziej prawą ( ⊢) liczbę.

Liniowy

f (n) = k × n sekwencji wystarczy wstawić plus przed pierwszym terminem.

Czynnikowe, a następnie wszystkie 1

Gdy pierwsza liczba n =! Mi kolejne liczby to 1, to !mjest rozwiązanie, ponieważ !mjest n i m!mwynosi 1, a !1wynosi 1.

b ab ab ab

Ponieważ wszystkie liczby dwucyfrowe są większe niż wszystkie liczby jednocyfrowe, rozwiązaniem jest maksimum, w którym przód pierwszej liczby jest przyklejony z tyłu drugiej liczby.

Trzywierszowy kod

Sprawdź, czy jakaś formuła tego typu +a×bjest poprawna.

Powrót łańcucha

Długie sekwencje bez liczb poniżej 5 (ponieważ 4 to podział linii) mogą być kodowane jako znaki SBCS.

Zastąpienie ciągu zastępczego

Jeśli liczb jest poniżej 5, przeskakujemy o 9, aby ich uniknąć.

Fallback

Prosta konkatenacja ciągu znaków "{⍺←⊃⋄1⌽⍺⊢⍵}"i ⍕wejście stringified ( ). Np. [3,1,4]Zwraca treść programu{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4 .

Część nawiasów klamrowych jest funkcją ambiwalentną, co oznacza, że ​​może to być funkcja przedrostka lub funkcja przedrostka. W ten sposób jego najbardziej lewa instancja będzie działać w trybie przedrostka, a wszystkie pozostałe w trybie przedrostka. Różnica między trybami polega na tym, czy ⍺oznaczenie lewego argumentu ma wartość. Jeśli nie, to zostanie mu przypisana funkcja ⊃(pierwsza).

Wyjaśnienie metody rezerwowej

{… } Anonimowa lambda:

 ⍺←⊃ Jeśli nie ma lewego argumentu ( ⍺), przypisz funkcję ⊃(pierwszą) do⍺

 ⋄ następnie:

W tym momencie poniższy kod oznacza dwie różne rzeczy w zależności od tego, czy ⍺ jest to lista numerów (połączenie infix), czy funkcja „pierwsza” (połączenie prefiksu).

 Jeśli ⍺jest to lista liczb:

  ⍺⊢⍵ odrzuć lewy argument na rzecz prawego argumentu

  1⌽ obróć o jeden krok w lewo

 Jeśli ⍺jest funkcja „pierwsza”:

  ⊢⍵ podać właściwy argument

  ⍺ wybierz pierwszy element tego

  1⌽ obróć go o jeden krok (no-op na skalar)

Przykład uruchomienia metody rezerwowej

Wykonując 3 1 4kod, {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4przypisuje funkcję „first” do, ⍺a tym samym zwraca pierwszy element; 3.

Wykonanie {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4pozwala lambda najbardziej wysuniętej na prawo „uchwycić” 3 1 4lewy argument jako lewy argument, więc ⍺ma wartość, która jest odrzucana, na rzecz 3 1 4której jest następnie obracana o jeden krok w lewo i daje 1 4 3wynik. Jest to następnie wykorzystywane jako jedyny argument dla lewej skrajnej lambdy, gdzie ⍺staje się „pierwszą” funkcją, powodując, że wynik jest pierwszym elementem;1.

Wykonywanie {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4pozwala lewemu lambda „uchwycić” środek 3 1 4jako lewy argument, który jest następnie odrzucany na korzyść prawego argumentu 3 1 4, którym jest obrócenie o jeden krok w lewo 1 4 3. Jest to następnie wykorzystywane jako prawy argument środkowej lambdy wraz z lewym skrajnym 3 1 4jako lewy argument. Lewy argument jest odrzucany dla prawej, która obraca się o jeden krok w lewo daje 4 3 1. To staje się wówczas jedynym argumentem lambda położonej najbardziej na lewo, a więc ⍺staje się „pierwszą funkcją”, zwracającą pierwszy element; 4.

Punktacja

Kiedy przyjdzie czas na testowanie przy użyciu rzeczywistych danych, użyj tej wiązki testowej (połączonej z danymi z testu wstępnego). Przypadki testowe trafiają do pola Input, a Output będzie całkowitą liczbą bajtów wszystkich 500 programów razem. (Zgłasza również błąd, ale tylko dlatego, że później próbuje ocenić dane wejściowe w obecnej postaci).

Węgiel drzewny

´⎚´§´⪪⪫ＩＡ ”y¦ Ｌυ⊞υω

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

´⎚´§´⪪

Podaj ciąg literału ⎚§⪪.

⪫ＩＡ 

Rzuć tablicę wejściową na ciąg, połącz ze spacjami i wydrukuj.

”y¦ Ｌυ⊞υω

Podaj ciąg literału ¦ Ｌυ⊞υω.

Dane wyjściowe na przykład 5,17,7,13,2to ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Wypróbuj online! Wyjaśnienie:

⎚

Wyczyść płótno, aby widoczny był tylko ostatni wynik.

§⪪5 17 7 13 2¦ Ｌυ

Weź długość wstępnie zdefiniowanej listy u. Użyj tego, aby zindeksować listę liczb całkowitych, które zostały podzielone na spacje i wygenerować wybrany element.

⊞υω

Wciśnij zmienną fikcyjną do wstępnie zdefiniowanej listy u, aby następna kopia wygenerowała następny element listy.

Całkowita długość wyjściowa = (długość wszystkich liczb całkowitych na wszystkich listach) + (liczba liczb całkowitych na wszystkich listach) + (liczba list * 9) znaków (SBCS).

Haskell , generuje Haskell

main = interact $ ("main=print$("++) . (++"!!)$ -1\n +1--")

Wypróbuj online! Dla pierwszej skrzynki testowej [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]tworzy następujący program:

main=print$([5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]!!)$ -1
 +1--

Spróbuj raz , podwójnie i potrójnie . Wykorzystuje to to samo podejście, co moja odpowiedź Haskella: podwoiłem źródło, podwoiłeś wynik .

Długość każdego generowanego programu jest długością listy danych wejściowych w postaci ciągu plus 25, zatem wynik dla obecnie dostępnych przypadków testowych wynosi 12266 + 500 * 25 = 24766. To pokazuje, że stosunek kodu do danych jest w zasadzie równy i wątpię, czy można napisać wystarczająco mały kod dekompresyjny, który obniży wynik. Może to być możliwe, jeśli listy będą znacznie większe.

Python 2 , generuje Python 2

import sys
a=`input()[::-1]`.replace(' ','')
sys.stdout.write('print%s[-open(__file__,"a").tell()/%s]#'%(a,len(a)+37))

Wypróbuj online!

Dla danych wejściowych

[10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29]

wygenerowany program to

print[29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10][-open(__file__,"a").tell()/98]#

który ma 98 bajtów.

Zaadaptowano z tego rozwiązania w „Podwajam źródło, podwajasz moc wyjściową!”.

Cholera, pojawiły się dwie krótsze odpowiedzi, zanim skończyłem pisać tę odpowiedź.

Java 8, generuje Python 2

interface M{static void main(String[]a){int l=a[0].length();System.out.print("print"+a[0]+"[open(__file__,'a').tell()/"+(l+35+(l+"").length())+"]#");}}

Wypróbuj online.

Tj. [3,4,5,6,7]Generuje ten program w języku Python 2:

print[3,4,5,6,7][open(__file__,'a').tell()/48]#

Spróbuj raz online ; Wypróbuj online dwa razy ; Wypróbuj online trzy razy .

Wygenerowany program Python jest oparty na odpowiedzi @ Mr.Xcodera po raz trzeci wyzwanie rzucenia uroku .

Wyjaśnienie:

Kod Java 8:

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    int l=a[0].length();        //   The length of the first argument
                                //   (Note that this is the length of the input as String,
                                //   not the size of the array)
    System.out.print(           //   Print:
      "print"                   //    Literal "print"
      +a[0]                     //    Appended with the argument
      +"[open(__file__,'a').tell()/"
                                //    Appended with literal "[open(__file__,'a').tell()/"
      +                         //    Appended with an integer that is formed by:
       (l                       //     Getting the length we got earlier
       +35                      //     +34 for the rest of the Python 2 code + 1
       +(l+"").length())        //     + the length of the length (<10→1; 10-99→2; etc.)
       +"]#");}}                //    Appended with literal "]#"

Kod Python 2:

print                        # Print
 [3,4,5,6,7]                 #  From this array
 [                           #   The `k`'th item,
  open(__file__,'a').tell()  #   where `k` is the length of its own source code
  /                          #   divided by
  48                         #   the length of its own source code (once) + 1
 ]#                          # With a trailing comment, so we can repeat the program

Bash, wyświetla programy w Perlu 5

Program Bash można wywołać jak script.sh 1,2,3.

Program Perla powinien być wywoływany z -Eflagą.

echo "shift@a;@a=($1)unless@a;END{say\$a[0];exec'true'}"

Wygenerowany perlkod dla danych wejściowych 4,7,8to:

shift@a;@a=(4,7,8)unless@a;END{say$a[0];exec'true'}

Dość brutalna siła. Usuwa element tablicy ( perlnie obchodzi go, że tablica na początku nie istnieje), ustawia go, jeśli nie jest jeszcze ustawiony. Następnie echo pierwszego elementu tablicy na końcu. ( ENDBlok jest uruchamiany jako ostatni). exec 'true'Rezygnuje z programu, tak, że dalsze ENDbloki nie są wykonywane.

Przykład:

#Once
$ perl -E "$(bash script.sh 4,7,8)"
4

#Duplicated twice
$ perl -E "$(bash script.sh 4,7,8)$(bash script.sh 4,7,8)"
7

#Duplicated thrice
$ perl -E "$(bash script.sh 4,7,8)$(bash script.sh 4,7,8)$(bash script.sh 4,7,8)"
8

Python 2, generuje C ++

Nie pobije to żadnych rekordów, interesowało mnie głównie to, czy uda mi się wymyślić, jak to zrobić :) Użyj faktu, że zmienne globalne są uruchamiane przed głównym, a więc można zwiększyć zmienną globalną, a następnie użyć #ifdef, aby upewnić się, że main jest zdefiniowany tylko raz.

import sys
print("""#include <stdio.h>
#ifndef A
#define A
int v;
int d[]={""" + sys.argv[1] + """};
struct C{C(){v++;}};
int main(void){ printf("%d",d[v]); }
#else
C c1;
#endif
""")

Runiczne Zaklęcia , generują Runiczne

74akw94/85akw
R32B~~?US' Sqq1Ky1Ky
\i<{1[lil1-{S{)]{{1KyB
D'0$'´$$' $     Rl0) ?
R"{Zs$;|1|l;|y"@
"UwR'10<|I+}"$~ /' Su0
       Rakwc4akw/

Wypróbuj online!

Pobiera dane wejściowe jako rozdzieloną spacjami listę wartości.

Dane wyjściowe wykonane raz Dane
wyjściowe dwa razy Dane
wyjściowe cztery razy

Wykorzystuje polecenie ciągłego numerycznego trybu odczytu, ´które zostało popełnione 12 stycznia i znalazłem to pytanie 14 stycznia . To polecenie pozwala na zakodowanie dowolnych wartości długości, ponieważ bez tej funkcji byłoby to bardzo trudne (np. 1392Należałoby je przedstawić jako 1X3+X9+X2+wymagające co najmniej dodatkowej pętli); dokładnie problem, który chciałem rozwiązać, gdy tworzyłem ´polecenie.

W oryginalnym kodzie |w struny "{Zs$;|1|l;|y"i "UwR'10<|I+}"są zastąpione \n(co siedzieć w sieci i nie zmieniać go, jak to normalnie) z wobrządku poleceń: 74akw, 94/Rakw, c4akw, i 85akw. Oryginalne postacie mogą być dosłownie wszystkim. |został wybrany jako symboliczny symbol zastępczy, który wizualnie reprezentuje to, czego chciałem. Zapisano kilka bajtów (w przypadku odznaczenia) bez konieczności refleksyjnego dodawania punktu wejścia, ponieważ wR'10<zapisuje Rw miejscu, w którym już istnieje (pozycja0,1 ), a następnie wypełnia swój stos śmieciami, zanim zabraknie many, po zapętleniu sekwencja U"'i34.

Wynikowy kod wyjściowy działa przy użyciu wpolecenia rite, aby zmienić pierwszy znak w drugim wierszu na Rprzekierowanie ight (więc tylko jeden adres IP wykonuje instrukcję print), przy sprytnym użyciu długości stosu wynikającej z wyższych i wyższych programów w celu ustalenia, który indeks czytać. Każde inne IP zmienia tę samą lokalizację na tę samą instrukcję i kończy się. Wszystko inne pozostaje niewykorzystane.

_{Obraz jest nieaktualny, ale wystarcza do wyjaśnienia przepływu.}

Każde wykonanie 1Iyzachowuje zdolność IP do obsługi coraz większego stosu (spowodowanego przez lpolecenie), którego rozmiar pozwala programowi określić liczbę kopii podstawowego kodu źródłowego. Ostateczny 1służy do zwiększenia poprzedniegol liczby do wymaganej liczby podczas obracania stosu (utworzonego następnie) w celu uzyskania prawidłowej wartości. ZKomenda neguje tę wartość tak, że podczas obrotu stosu w prawidłowym kierunku.

Oryginalna tablica wejściowa jest następnie kodowana przy użyciu trybu ciągłego odczytu, wypełnionego cyfrą 0, aby uniknąć stopniowego modyfikowania tej samej wartości, aby odczytać oryginalne dane wejściowe. Spacja NOP jest wymagana, aby wyjść z trybu ciągłego odczytu i pozwolić kolejnym 0 ponownie zalać stos.

Wynik powinien wynosić w przybliżeniu 3+v.toString().length, dla każdego wpisu tablicy v, +23dla każdej tablicy. W przybliżeniu (2.55*total length of input)lub 33837dla próbki wejściowej, jeśli zrobiłem wszystko dobrze.

Drobne zmiany zostały wprowadzone do mojego oczekiwanego programu końcowego z powodu efektów ubocznych wprowadzonych w tej samej wersji dotyczącej spolecenia, ale zaowocowało to lepszym wynikiem w tym samym czasie.