Joe es tu desarrollador promedio de BF. Está a punto de revisar los cambios de su código en su repositorio cuando recibe una llamada de su jefe. "¡Joe! ¡La máquina del nuevo cliente está rota! El jodido intérprete establece todas las celdas en valores aleatorios antes de la ejecución del programa. No hay tiempo para arreglarlo, tu código tendrá que lidiar con eso". Joe no piensa mucho en eso, y está a punto de escribir un programa para poner a cero el primer millón de celdas, cuando su jefe lo interrumpe nuevamente - "... y no piense en usar la fuerza bruta, el código tiene que ser lo más pequeño posible ". ¡Ahora tienes que ayudar al pobre Joe!

Especificaciones

• Obtendrá un código válido de brainfuck como entrada
• Su programa luego modificará el código para que funcione en un intérprete aleatorio brainfuck
• Esto significa que antes de la ejecución del programa, las celdas se pueden establecer en cualquier valor.
• El nuevo programa debe tener exactamente el mismo comportamiento sin importar las condiciones iniciales.
• El intérprete tendrá un valor máximo de celda de 255 con envoltura y una cinta de longitud infinita.

Puntuación

Su puntaje es 10 veces el tamaño del compilador en bytes más la suma de los tamaños de los casos de prueba . Obviamente, el puntaje más bajo gana. Para mitigar la optimización de casos de prueba, me reservo el derecho de cambiar los casos de prueba si sospecho algo, y probablemente lo haré antes de elegir un ganador.

Casos de prueba

( Obtuve esto de la página de esolangs y esta página web: http://www.hevanet.com/cristofd/brainfuck/ ). También gracias a @Sparr por el último caso de prueba.

• Hola Mundo: ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
• Entrada inversa: >,[>,]<[.<]
• Poderes de dos (flujo infinito): >++++++++++>>+<+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<]>.>[->[ <++>-[<++>-[<++>-[<++>-[<-------->>[-]++<-[<++>-]]]]]]<[>+<-]+>>]<<]
• Cuadrados menores de 10000: ++++[>+++++<-]>[<+++++>-]+<+[>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+>>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]<<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-]
• Corriente de Fibonacci: >++++++++++>+>+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<<]>.>>[[-]<[>+<-]>>[<<+>+>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>+>+<<<-[>+<-]]]]]]]]]]]+>>>]<<<]
• Secuencia ASCII hasta la entrada: ,[.[>+<-]>-](esta requiere números de celda variables según la entrada)

sed, compilador de 46 bytes

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

No me di cuenta de que también se suponía que el resultado era golf hasta después de escribir el programa, así que iré al compilador corto. También fue demasiado trabajo para probar, así que notifique si no funciona correctamente :)

C ++

Tamaño del compilador: 630 bytes (-10 bytes gracias a Zacharý)
Tamaño del resultado de la compilación Hello World: 139
Cuadrado bajo 10000: 319

Compilador:

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

El intérprete aleatorio brainfuck:

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

Algunas notas :

• El compilador ejecutará el programa para determinar las celdas de memoria que se utilizan. Si su programa es un bucle infinito, el compilador realizará un bucle infinito.

rs , 33 bytes, Puntuación: 2659

Principalmente solo un puerto simple de la sedrespuesta.

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