Joe jest twoim przeciętnym programistą BF. Ma zamiar sprawdzić zmiany swojego kodu w repozytorium, gdy otrzyma telefon od swojego szefa. „Joe! Maszyna nowego klienta jest zepsuta! Interpretator ustawia wszystkie komórki na losowe wartości przed wykonaniem programu. Nie ma czasu na naprawę, twój kod będzie musiał sobie z tym poradzić.” Joe nie myśli o tym zbyt wiele i ma zamiar napisać program, który wyzeruje pierwszy milion komórek, gdy jego szef ponownie mu przerywa - „... i nie myśl o użyciu brutalnej siły, kod musi być tak mały, jak to możliwe. ” Teraz musisz pomóc biednemu Joe!

Dane techniczne

• Otrzymasz jakiś poprawny kod pieprzenia mózgu jako dane wejściowe
• Twój program następnie zmodyfikuje kod, aby działał na losowym interpretatorze pieprzenia mózgu
• Oznacza to, że przed wykonaniem programu komórki można ustawić na dowolną wartość.
• Nowy program powinien mieć dokładnie takie samo zachowanie bez względu na warunki początkowe.
• Interpretator będzie miał maksymalną wartość 255 z owinięciem i taśmę o nieskończonej długości.

Punktacja

Twój wynik to 10-krotność wielkości kompilatora w bajtach plus suma rozmiarów przypadków testowych . Najniższy wynik oczywiście wygrywa. Aby złagodzić optymalizację przypadków testowych, zastrzegam sobie prawo do zmiany przypadków testowych, jeśli coś podejrzewam, i prawdopodobnie zrobi to przed wyborem zwycięzcy.

Przypadki testowe

(Mam je ze strony esolangs i tej strony: http://www.hevanet.com/cristofd/brainfuck/ ). Również dzięki @Sparr za ostatni przypadek testowy.

• Witaj świecie: ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
• Odwrotne wejście: >,[>,]<[.<]
• Powers of Two (Infinite Stream): >++++++++++>>+<+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<]>.>[->[ <++>-[<++>-[<++>-[<++>-[<-------->>[-]++<-[<++>-]]]]]]<[>+<-]+>>]<<]
• Kwadraty poniżej 10000: ++++[>+++++<-]>[<+++++>-]+<+[>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+>>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]<<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-]
• Strumień Fibonacciego: >++++++++++>+>+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<<]>.>>[[-]<[>+<-]>>[<<+>+>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>+>+<<<-[>+<-]]]]]]]]]]]+>>>]<<<]
• Sekwencja ASCII do danych wejściowych: ,[.[>+<-]>-](Ta wymaga różnych liczb komórek w zależności od danych wejściowych)

sed, 46-bajtowy kompilator

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

Dopiero po napisaniu programu nie zauważyłem, że wyjście miało być golfem, więc wybiorę krótki kompilator. Również testowanie było zbyt pracochłonne, więc proszę powiadomić, jeśli nie działa poprawnie :)

C ++

Rozmiar kompilatora: 630 bajtów (-10 bajtów dzięki Zacharýowi)
Rozmiar wyniku kompilacji Hello World: 139
Kwadrat poniżej 10000: 319

Kompilator:

#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;}

Randomizowany tłumacz pieprzony mózg:

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

Niektóre uwagi:

• Kompilator uruchomi program w celu ustalenia używanych komórek pamięci. Jeśli twój program jest nieskończoną pętlą, kompilator zapętla się w nieskończoność.

rs , 33 bajty, wynik: 2659

Przeważnie tylko prosty port sedodpowiedzi.

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