Joe est votre développeur BF moyen. Il est sur le point de vérifier ses modifications de code dans leur référentiel lorsqu'il reçoit un appel de son patron. "Joe! La machine du nouveau client est cassée! L'interpréteur brainfuck définit toutes les cellules sur des valeurs aléatoires avant l'exécution du programme. Pas le temps de le réparer, votre code devra y faire face." Joe n'y pense pas beaucoup et est sur le point d'écrire un programme pour remettre à zéro le premier million de cellules, quand son patron l'interrompt à nouveau - "... et ne pense pas à utiliser la force brute, le code doit être aussi petit que possible. " Maintenant, vous devez aider le pauvre Joe!

Caractéristiques

• Vous obtiendrez un code de brainfuck valide en entrée
• Votre programme va alors modifier le code pour qu'il fonctionne sur un interpréteur randomfuck randomisé
• Cela signifie qu'avant l'exécution du programme, les cellules peuvent être définies sur n'importe quelle valeur.
• Le nouveau programme doit avoir exactement le même comportement quelles que soient les conditions initiales.
• L'interpréteur aura une valeur de cellule maximale de 255 avec habillage et une bande de longueur infinie.

Notation

Votre score est 10 fois la taille du compilateur en octets plus la somme des tailles de cas de test . Le score le plus bas l'emporte évidemment.Pour atténuer l'optimisation des cas de test, je me réserve le droit de changer les cas de test si je soupçonne quelque chose, et je le ferai probablement avant de choisir un gagnant.

Cas de test

(Je les ai obtenues sur la page esolangs et sur cette page Web: http://www.hevanet.com/cristofd/brainfuck/ ). Merci également à @Sparr pour le dernier cas de test.

• Bonjour le monde: ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
• Entrée inversée: >,[>,]<[.<]
• Pouvoirs de deux (flux infini): >++++++++++>>+<+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<]>.>[->[ <++>-[<++>-[<++>-[<++>-[<-------->>[-]++<-[<++>-]]]]]]<[>+<-]+>>]<<]
• Carrés de moins de 10000: ++++[>+++++<-]>[<+++++>-]+<+[>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+>>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]<<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-]
• Flux de Fibonacci: >++++++++++>+>+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<<]>.>>[[-]<[>+<-]>>[<<+>+>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>+>+<<<-[>+<-]]]]]]]]]]]+>>>]<<<]
• Séquence ASCII jusqu'à l'entrée: ,[.[>+<-]>-](celle-ci nécessite un nombre de cellules variable en fonction de l'entrée)

sed, compilateur de 46 octets

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

Je n'ai pas remarqué que la sortie était également censée être du golf avant d'avoir écrit le programme, donc je vais opter pour le court compilateur. De plus, c'était beaucoup trop de travail à tester, alors s'il vous plaît, informez-le s'il ne fonctionne pas correctement :)

C ++

Taille du compilateur: 630 octets (-10 octets grâce à Zacharý) Taille
du résultat de la compilation Hello World: 139
Carré sous 10000: 319

Compilateur:

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

L'interprète randomfuck randomisé:

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

Quelques notes :

• Le compilateur exécutera le programme pour déterminer les cellules de mémoire utilisées. Si votre programme est une boucle infinie, le compilateur bouclera infiniment.

rs , 33 octets, score: 2659

Surtout juste un simple portage de la sedréponse.

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