Wenn Sie ein Array mit positiven Ganzzahlen Aals Eingabe angeben, generieren Sie ein Programm, das bei mehrmaliger Wiederholung kden kth-Wert (1-Index) des Arrays ausgibt .

Wenn das Array beispielsweise ist [1,11], sollte die Ausgabe ein Programm sein, das ausgibt 1und bei zweimaliger Wiederholung ausgegeben wird 11. Code wie print(end="1");in Python 3 funktioniert: print(end="1");druckt 1 und print(end="1");print(end="1");druckt 11

Die kleinste Summe von Codelängen zur Lösung aller Testfälle gewinnt. Ihr Metacode sollte 500 Testfälle in 60s lösen, und jeder Ihrer Lösungscodes sollte in 10s zurückkehren. Metacode und Lösungscode müssen nicht in derselben Sprache sein, aber alle Lösungen, die Ihr Metaprogramm generiert, sollten in derselben Sprache sein.

Pretest Daten und Generator zu sehen sind hier . 7 Tage später wird die Summe der Einreichungszeit (z. B. 12:34 Mittelwert 1234) als zufälliger Startwert verwendet und ein weiterer Testfall als endgültiger Testfall generiert.

Der endgültige Startwert ist 7335 in GMT + 8, daher sind die endgültigen Testdaten hier

Python 3 generiert Stax

Dies verwendet eine Vielzahl von Strategien. Die meisten Strategien gelten nur unter bestimmten Bedingungen, es gibt jedoch eine Fallback-Strategie, die immer verwendet werden kann. Am Ende wird das kleinste Kandidatenprogramm ausgewählt.

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)

Probieren Sie es online aus!

Update: Validierung Es ist zeitaufwändig, jede Vielzahl von Programmen separat auszuführen. Es ist möglich, sie alle gleichzeitig auszuführen. Dazu muss ein kleiner Code verwendet werden. Es ist für ein paar Dinge verantwortlich.

1. Führen Sie gegebenenfalls eine implizite Ausgabe durch. Normalerweise wird am Ende eines Stax-Programms die Oberseite des Stapels gedruckt, wenn keine andere Ausgabe erfolgt ist. Wenn Sie mehrere Programme in derselben Quelldatei ausführen, muss dies explizit erfolgen.

2. Löschen Sie beide Stapel.

3. Register zurücksetzen. Für diese Programme wird nur das x-Register verwendet.

Diese Kesselplatte sollte nach jedem einzelnen auszuführenden Programm angewendet werden.

|d{P}{zP}?0XLd

Beispielsweise [5,2,7,3]erzeugt die Eingabe das Stax-Programm 3527E|X@. Alle vier Multiplizitäten können gleichzeitig getestet werden.

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

Probieren Sie es online aus!

Auf diese Weise ist es möglich, alle Multiplizitäten des gesamten Programms im selben Lauf zu testen, sofern nichts kaputt geht. Es wäre wahrscheinlich das größte Stax-Programm, das jemals ausgeführt wurde, wenn alle 500 erledigt wären.

Perl 5 -p erzeugt Perl 5 -p , Overhead 19 17 13

-1 danke an @Dom Hastings

Die Punktzahl für eine Eingabe ist length of the input + 13. Kann natürlich verbessert werden, indem selbstdekomprimierende Programme für größere Eingänge generiert werden, aber ich werde mich nicht darum kümmern.

Geben Sie das Eingabearray in STDIN in einer Zeile durch Kommas getrennt an.

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

Probieren Sie es online aus!

Führen Sie die verketteten Ausgabezeiten nohne Eingabe aus (z. B. Umleitung von / dev / null).

Beispiel für die Ausführung zur Eingabe 2,6,4,7und das daraus resultierende viermal wiederholte Programm:

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

Probieren Sie es online aus!

Wenn Ihnen das resultierende Programm, das versucht, aus STDIN zu lesen, nicht gefällt, verwenden Sie diese Version mit Overhead 17:

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

Probieren Sie es online aus!

Beispiel für die Ausführung zur Eingabe 2,6,4,7und das daraus resultierende viermal wiederholte Programm:

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)[$-++],'

Probieren Sie es online aus!

Diese Version stürzt nach dem Drucken der erforderlichen Ausgabe ab

05AB1E , generiert 05AB1E

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

Probieren Sie es online aus!

Das generierte Programm für die Eingabe [5,17,7,13,2]ist "5 17 7 13 2"#.g<è.

Testsuite für [5,17,7,13,2]

Die Länge des generierten Programms beträgt len(input) + 5

APL (Dyalog Unicode)

Anonymes Präfix Lambda. Gibt einen Programmkörper zurück.

 {
     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
 }

Probieren Sie es online aus!

Methoden

Dies untersucht verschiedene Methoden und gibt die erste verwendbare zurück, wobei schließlich auf eine universell anwendbare Methode zurückgegriffen wird.

Einzelelement

Wenn die Liste nur ein Element enthält, wird sie unverändert zurückgegeben.

2, 22 usw.

Eine einzelne Ziffer kann einfach wiederholt werden, um die 11-mal größere Zahl zu generieren.

Alles das selbe

Wir geben nur die ⊢Nummer ganz rechts ( ) zurück.

Linear

f (n) = k × n Sequenzen fügen einfach ein Plus vor dem ersten Term ein.

Faktoriell gefolgt von allen Einsen

Wenn die erste Zahl n =! M und die nachfolgenden Zahlen 1 sind, !mist dies eine Lösung, da !mn und m!m1 ist und !11 ist.

b ab ab ab

Da alle zweistelligen Zahlen größer sind als alle einstelligen Zahlen, ist ein laufendes Maximum, bei dem die Vorderseite der ersten Zahl auf die Rückseite der zweiten Zahl geklebt wird, eine Lösung.

Der dreizeilige Code

Überprüfen Sie, ob eine Formel des Typs +a×bgültig ist.

String-Fallback

Lange Sequenzen ohne Zahlen unter 5 (da 4 ein Zeilenumbruch ist) können als Zeichen des SBCS codiert werden.

Fallback für versetzte Zeichenfolgen

Wenn es Zahlen unter 5 gibt, verschieben wir uns um 9, um diese zu vermeiden.

Zurückfallen

Einfache Verkettung der Zeichenfolge "{⍺←⊃⋄1⌽⍺⊢⍵}"und der ⍕Eingabe stringified ( ). ZB [3,1,4]gibt den Programmkörper zurück {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4.

Der Teil in geschweiften Klammern ist eine ambivalente Funktion, dh er kann entweder eine Präfixfunktion oder eine Infixfunktion sein. Daher wird die Instanz ganz links im Präfixmodus und alle anderen im Infixmodus ausgeführt. Der Unterschied zwischen den Modi besteht darin, ob ⍺das linke Argument einen Wert hat. Ist dies nicht der Fall, wird ihm die Funktion ⊃(zuerst) zugewiesen .

Erläuterung der Fallback-Methode

{… } Anonymes Lambda:

 ⍺←⊃ Wenn kein linkes Argument ( ⍺) vorhanden ist, weisen Sie die Funktion ⊃(zuerst) zu⍺

 ⋄ dann:

An dieser Stelle bedeutet der folgende Code zwei verschiedene Dinge, je nachdem, ob ⍺es sich um eine Liste von Nummern (Infix-Aufruf) oder um die Funktion "first" (Präfix-Aufruf) handelt.

 Wenn ⍺ist eine Liste von Zahlen:

  ⍺⊢⍵ Verwerfen Sie das linke Argument zugunsten des rechten Arguments

  1⌽ Drehe diesen einen Schritt nach links

 Wenn ⍺ist die Funktion "zuerst":

  ⊢⍵ das richtige Argument liefern

  ⍺ Wählen Sie das erste Element davon

  1⌽ drehe es einen Schritt (ein No-Op auf einem Skalar)

Beispiellauf der Fallback-Methode

Durch Ausführen 3 1 4des Codes wird {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4die "erste" Funktion zugewiesen ⍺und somit das erste Element zurückgegeben. 3.

Durch Ausführen kann {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4das Lambda ganz rechts die Linke 3 1 4als linkes Argument "erfassen" , ⍺hat also einen Wert, der verworfen 3 1 4wird, der dann einen Schritt nach links gedreht wird und 1 4 3als Ergebnis ergibt . Dies wird dann als einziges Argument für das Lambda ganz links verwendet, wo es ⍺zur "ersten" Funktion wird, wodurch das Ergebnis das erste Element ist. 1.

Durch Ausführen {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4"erfasst" das Lambda ganz rechts die Mitte 3 1 4als linkes Argument, das dann zugunsten des rechten Arguments verworfen wird 3 1 4, das bei Drehung um einen Schritt nach links ist 1 4 3. Dies wird dann als rechtes Argument des mittleren Lambda zusammen mit dem 3 1 4Argument ganz links als linkes verwendet. Das linke Argument wird für das rechte verworfen, das einen Schritt nach links gedreht ergibt 4 3 1. Dies wird dann das einzige Argument des Lambdas ganz links, wird also ⍺zur "ersten Funktion" und gibt das erste Element zurück; 4.

Wertung

Wenn es Zeit wird, anhand der tatsächlichen Daten zu testen, verwenden Sie dieses Testkabel (verknüpft mit Vortestdaten). Die Testfälle werden in das Eingabefeld eingegeben, und die Ausgabe ist die Gesamtbytezahl aller 500 Programme zusammen. (Es wird auch ein Fehler ausgegeben, aber das liegt nur daran, dass anschließend versucht wird, die Eingabe unverändert zu bewerten.)

Holzkohle

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

´⎚´§´⪪

Geben Sie die Literalzeichenfolge aus ⎚§⪪.

⪫ＩＡ 

Wandeln Sie das Eingabearray in eine Zeichenfolge um, verbinden Sie es mit Leerzeichen und drucken Sie.

”y¦ Ｌυ⊞υω

Geben Sie die Literalzeichenfolge aus ¦ Ｌυ⊞υω.

Ausgabe von zum Beispiel 5,17,7,13,2ist ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Probieren Sie es online aus! Erläuterung:

⎚

Löschen Sie die Leinwand, sodass nur die letzte Ausgabe sichtbar ist.

§⪪5 17 7 13 2¦ Ｌυ

Nehmen Sie die Länge der vordefinierten Liste u. Verwenden Sie diese Option, um in die Liste der Ganzzahlen zu indizieren, die auf Leerzeichen aufgeteilt wurden, und um das ausgewählte Element auszugeben.

⊞υω

Schieben Sie eine Dummy-Variable in die vordefinierte Liste u, damit die nächste Kopie das nächste Element der Liste ausgibt.

Gesamtausgabelänge = (Länge aller Ganzzahlen in allen Listen) + (Anzahl der Ganzzahlen in allen Listen) + (Anzahl der Listen * 9) Zeichen (SBCS).

Haskell , erzeugt Haskell

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

Probieren Sie es online aus! Für den ersten Testfall [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]wird das folgende Programm erstellt:

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

Versuchen Sie es einmal , verdoppelt und verdreifacht . Dies verwendet den gleichen Ansatz wie meine Haskell-Antwort: Ich verdopple die Quelle, Sie verdoppeln die Ausgabe .

Die Länge jedes generierten Programms entspricht der Länge der Eingabeliste als Zeichenfolge plus 25, daher beträgt die Punktzahl für die derzeit verfügbaren Testfälle 12266 + 500 * 25 = 24766. Dies zeigt, dass das Verhältnis von Code zu Daten im Grunde genommen gleich ist, und ich bezweifle, dass es möglich ist, einen ausreichend kleinen Dekomprimierungscode zu schreiben, der die Punktzahl verringert. Es könnte möglich sein, wenn die Listen viel größer sind.

Python 2 generiert Python 2

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

Probieren Sie es online aus!

Für die Eingabe

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

Das generierte Programm ist

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]#

Das sind 98 Bytes.

Angepasst an diese Lösung in "Ich verdopple die Quelle, du verdoppelst die Ausgabe!".

Verdammt, zwei kürzere Antworten tauchten auf, bevor ich mit dem Schreiben dieser Antwort fertig war.

Java 8 generiert 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())+"]#");}}

Probieren Sie es online aus.

Dh [3,4,5,6,7]generiert dieses Python 2-Programm:

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

Probieren Sie es einmal online aus . Probieren Sie es zweimal online aus . Probieren Sie es dreimal online aus .

Das generierte Python-Programm basiert auf der Antwort von @ Mr.Xcoder zum dritten Mal auf die Charm- Herausforderung .

Erläuterung:

Java 8-Code:

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 "]#"

Python 2-Code:

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, gibt Programme in Perl 5 aus

Bash-Programm kann wie aufgerufen werden script.sh 1,2,3.

Perl-Programm sollte mit dem -EFlag aufgerufen werden .

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

Der generierte perlCode für eine Eingabe von 4,7,8lautet:

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

Ziemlich rohe Gewalt. Entfernt ein Element des Arrays ( perles ist egal, dass das Array zuerst nicht vorhanden ist) und legt es fest, wenn es nicht bereits festgelegt ist. Am Ende wird dann das erste Element des Arrays wiedergegeben. (Der ENDBlock wird zuletzt ausgeführt). Das exec 'true'beendet das Programm, so dass die weiteren ENDBausteine ​​nicht ausgeführt werden.

Beispiel:

#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, generiert C ++

Dies wird keine Rekorde übertreffen, ich war hauptsächlich daran interessiert zu überlegen, ob ich herausfinden könnte, wie es geht :) Verwenden Sie die Tatsache, dass globale Variablen vor main ausgeführt werden und so eine globale Variable inkrementieren können, und verwenden Sie dann a #ifdef, um sicherzustellen, dass main nur einmal definiert ist.

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

Runenverzauberungen , erzeugt Runenverzauberungen

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

Probieren Sie es online aus!

Nimmt die Eingabe als durch Leerzeichen getrennte Liste von Werten auf.

Ausgabe einmal ausgeführt
Ausgabe zweimal ausgeführt
Ausgabe viermal ausgeführt

Verwendet den kontinuierlichen numerischen Lesemodus-Befehl, ´der am 12. Januar festgeschrieben wurde, und ich habe diese Frage am 14. Januar gefunden. Mit diesem Befehl können beliebige Längenwerte codiert werden, da dies ohne diese Funktion sehr schwierig 1392wäre (z. B. müsste dargestellt werden als 1X3+X9+X2+, was mindestens eine zusätzliche Schleife erforderlich macht). genau das Problem, das ich lösen wollte, als ich den ´Befehl erstellte.

Im ursprünglichen Code, der |in den Saiten "{Zs$;|1|l;|y"und "UwR'10<|I+}"wird ersetzt durch \n(die im Netz sitzen und es nicht ändern, wie sie normalerweise) mit write Befehlen: 74akw, 94/Rakw, c4akw, und 85akw. Die ursprünglichen Zeichen können buchstäblich alles sein. |wurde als symbolischer Platzhalter ausgewählt, der visuell darstellte, was ich wollte. Mehrere Bytes werden gespeichert (falls nicht bewertet), indem kein reflektierender Einstiegspunkt hinzugefügt werden muss, da wR'10<ein Ran eine Stelle geschrieben wird, an der bereits einer vorhanden ist (Position 0,1), und dann nach einer Schleife den Stapel mit Junk gefüllt wird, bevor das Mana ausgeht Sequenz U"'i34.

Der resultierende Ausgabecode verwendet den wBefehl rite, um das erste Zeichen in der zweiten Zeile in eine RNachtumleitung zu ändern (sodass nur eine IP eine Druckanweisung ausführt), wobei die Stapellänge, die sich aus immer größeren Programmen ergibt, geschickt verwendet wird, um den Index zu bestimmen lesen. Jede andere IP ändert denselben Speicherort in denselben Befehl und wird beendet. Alles andere bleibt ungenutzt.

_{Das Bild ist veraltet, aber für die Erklärung des Flusses ausreichend.}

Bei jeder Ausführung von 1Iybleibt die Fähigkeit der IP erhalten, einen immer größeren Stapel (verursacht durch den lBefehl) zu verarbeiten, dessen Größe es dem Programm ermöglicht, zu bestimmen, wie viele Kopien des Basisquellcodes vorhanden sind. Das Finale 1wird verwendet, um die vorherige lauf die erforderliche Zahl zu erhöhen, wenn der Stapel (der als nächstes erstellt wird) gedreht wird, um zum richtigen Wert zu gelangen. Der ZBefehl negiert diesen Wert, sodass sich der Stapel in die richtige Richtung dreht.

Das ursprüngliche Eingabearray wird dann im kontinuierlichen Lesemodus codiert und mit einer 0 versehen, um zu vermeiden, dass derselbe Wert schrittweise geändert wird, um die ursprünglichen Eingaben zu lesen. Der Leerzeichen-NOP ist erforderlich, um den kontinuierlichen Lesemodus zu verlassen und der nachfolgenden 0 zu ermöglichen, den Stapel erneut zu füllen.

Score sollte ungefähr gleich 3+v.toString().lengthfür jeden Array - Eintrag v, +23für jedes Array. Ungefähr (2.55*total length of input)oder 33837für die Beispieleingabe, wenn ich die Dinge richtig gemacht habe.

In meinem erwarteten endgültigen Programm wurden geringfügige Änderungen aufgrund von Nebenwirkungen vorgenommen, die im selben Build in Bezug auf den sBefehl eingeführt wurden. Dies führte jedoch gleichzeitig zu einer besseren Punktzahl.