Joe ist ein durchschnittlicher BF-Entwickler. Er ist dabei, seine Codeänderungen in ihrem Repository einzuchecken, wenn er einen Anruf von seinem Chef erhält. "Joe! Der Computer des neuen Clients ist kaputt! Der Brainfuck-Interpreter setzt alle Zellen vor der Programmausführung auf zufällige Werte. Keine Zeit, dies zu beheben, Ihr Code muss sich darum kümmern." Joe denkt nicht viel darüber nach und ist dabei, ein Programm zu schreiben, um die ersten Millionen Zellen auf Null zu setzen, wenn sein Chef ihn erneut unterbricht - "... und denken Sie nicht daran, rohe Gewalt anzuwenden, der Code muss sei so klein wie möglich. " Jetzt musst du dem armen Joe helfen!

Spezifikationen

• Sie erhalten einen gültigen Brainfuck-Code als Eingabe
• Ihr Programm ändert dann den Code so, dass er auf einem zufälligen Brainfuck-Interpreter funktioniert
• Dies bedeutet, dass die Zellen vor der Programmausführung auf einen beliebigen Wert gesetzt werden können.
• Das neue Programm sollte unabhängig von den Anfangsbedingungen genau das gleiche Verhalten aufweisen.
• Der Interpreter hat einen maximalen Zellenwert von 255 mit Umbruch und ein Band mit unendlicher Länge.

Wertung

Ihre Punktzahl beträgt das 10-fache der Compilergröße in Bytes plus der Summe der Testfallgrößen . Die niedrigste Punktzahl gewinnt offensichtlich. Um der Optimierung von Testfällen entgegenzuwirken, behalte ich mir das Recht vor, die Testfälle zu ändern, wenn ich etwas vermute, und werde dies wahrscheinlich tun, bevor ich einen Gewinner auswähle.

Testfälle

(Ich habe diese von der Esolangs-Seite und dieser Webseite erhalten: http://www.hevanet.com/cristofd/brainfuck/ ). Vielen Dank auch an @Sparr für den letzten Testfall.

• Hallo Welt: ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
• Reverse Input: >,[>,]<[.<]
• Potenzen von zwei (unendlicher Strom): >++++++++++>>+<+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<]>.>[->[ <++>-[<++>-[<++>-[<++>-[<-------->>[-]++<-[<++>-]]]]]]<[>+<-]+>>]<<]
• Quadrate unter 10000: ++++[>+++++<-]>[<+++++>-]+<+[>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+>>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]<<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-]
• Fibonacci Stream: >++++++++++>+>+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<<]>.>>[[-]<[>+<-]>>[<<+>+>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>+>+<<<-[>+<-]]]]]]]]]]]+>>>]<<<]
• ASCII-Sequenz bis zur Eingabe: ,[.[>+<-]>-](Diese erfordert unterschiedliche Zellennummern basierend auf der Eingabe)

sed, 46 Byte Compiler

s/</<</g
s/>/>[->[-]>[-]+<<]>/g
s/^/[-]>[-]+</

Ich habe erst nach dem Schreiben des Programms bemerkt, dass die Ausgabe auch Golf sein sollte, also werde ich mich für den kurzen Compiler entscheiden. Es war auch viel zu viel Arbeit zum Testen, also benachrichtigen Sie bitte, wenn es nicht richtig funktioniert :)

C ++

Compilergröße: 630 Bytes (-10 Bytes dank Zacharý)
Hello World Kompilierungsergebnisgröße: 139
Quadrat unter 10000: 319

Compiler:

#include<string>
#include<map>
#include<stack>
#define B break
#define C case
#define S 30000
#define R m[(p<0)?(p%S)+S:p]
using s=std::string;using P=std::pair<int,int>;s a(s c){char m[S];memset(m,0,S);int p=0,i=0;P r{0,0};std::map<int,int>j;std::stack<int>t;for(int d=0;d<c.size();++d){if(c[d]==91)t.push(d);if(c[d]==93){j[d]=t.top();j[t.top()]=d;t.pop();}}while(i<c.size()){switch(c[i]){C'>':++p;B;C'<':--p;B;C'+':++R;B;C'-':--R;B;C'[':if(!R)i=j[i];B;C']':i=j[i]-1;B;default:B;}++i;r.first=p<r.first?p:r.first;r.second=p>r.second?p:r.second;}s n;for(int i=r.first;i<r.second;++i){n+="[-]>";}n+="[-]"+s(r.second,60)+c;return n;}

Der randomisierte Brainfuck-Interpreter:

void interpret(const std::string& code) {
    char memory[30000];
    for (int i = 0; i < 30000; ++i)
        memory[i] = std::rand()%256;
    int memPtr = 0, insPtr = 0;
    std::map<int, int> jump_map;

    {
        std::stack<int> jstack;
        for (int i = 0; i < code.size(); ++i) {
            if (code[i] == '[')
                jstack.push(i);
            if (code[i] == ']') {
                jump_map[i] = jstack.top();
                jump_map[jstack.top()] = i;
                jstack.pop();
            }
        }
    }
    while (insPtr < code.size()) {
        switch (code[insPtr]) {
        case '>': ++memPtr; break;
        case '<': --memPtr; break;
        case '+': ++memory[memPtr]; break;
        case '-': --memory[memPtr]; break;
        case '.': std::cout << memory[memPtr]; break;
        case ',': std::cin >> memory[memPtr]; break;
        case ']': if (memory[memPtr] != 0) insPtr = jump_map[insPtr]; break;
        case '[': if (memory[memPtr] == 0) insPtr = jump_map[insPtr]; break;
        default:break;
        }
        ++insPtr;
    }
}

Einige Notizen :

• Der Compiler führt das Programm aus, um die verwendeten Speicherzellen zu bestimmen. Wenn Ihr Programm eine Endlosschleife ist, wird der Compiler eine Endlosschleife ausführen.

rs , 33 Bytes, Punktzahl: 2659

Meist nur ein einfacher Port der sedAntwort.

</<<
>/>[->[-]>[-]+<<]>
[-]>[-]+<