Compilador Brainfuck randomizado

10

Joe é o seu desenvolvedor BF médio. Ele está prestes a verificar suas alterações de código no repositório quando receber uma ligação de seu chefe. "Joe! A máquina do novo cliente está quebrada! O intérprete de brainfuck define todas as células para valores aleatórios antes da execução do programa. Sem tempo para consertá-lo, seu código terá que lidar com isso." Joe não pensa muito sobre isso e está prestes a escrever um programa para zerar o primeiro milhão de células, quando seu chefe o interrompe novamente - "... e não pensa em usar força bruta, o código precisa ser o menor possível. " Agora você tem que ajudar o pobre Joe!

Especificações

  • Você receberá algum código válido do brainfuck como entrada
  • Seu programa modificará o código para que ele funcione em um intérprete aleatório de cérebro
  • Isso significa que antes da execução do programa, as células podem ser configuradas para qualquer valor.
  • O novo programa deve ter exatamente o mesmo comportamento, independentemente das condições iniciais.
  • O intérprete terá um valor máximo de célula de 255 com quebra automática e uma fita de comprimento infinito.

Pontuação

Sua pontuação é 10 vezes o tamanho do compilador em bytes mais a soma dos tamanhos dos casos de teste . A pontuação mais baixa obviamente vence. Para atenuar a otimização de casos de teste, reservo-me o direito de alterar os casos de teste, se suspeitar de alguma coisa, e provavelmente o fará antes de escolher um vencedor.

Casos de teste

( Comprei na página esolangs e nesta página: http://www.hevanet.com/cristofd/brainfuck/ ). Também obrigado a @Sparr pelo último caso de teste.

  • Olá Mundo: ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
  • Entrada reversa: >,[>,]<[.<]
  • Poderes de Dois (Fluxo Infinito): >++++++++++>>+<+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<]>.>[->[ <++>-[<++>-[<++>-[<++>-[<-------->>[-]++<-[<++>-]]]]]]<[>+<-]+>>]<<]
  • Quadrados abaixo de 10000: ++++[>+++++<-]>[<+++++>-]+<+[>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+>>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]<<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-]
  • Fluxo de Fibonacci: >++++++++++>+>+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<<]>.>>[[-]<[>+<-]>>[<<+>+>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>+>+<<<-[>+<-]]]]]]]]]]]+>>>]<<<]
  • Sequência ASCII até a entrada: ,[.[>+<-]>-](Esta requer vários números de células com base na entrada)
Maltysen
fonte
Comentários não são para discussão prolongada; esta conversa foi movida para o bate-papo .
Martin Ender

Respostas:

8

sed, compilador de 46 bytes

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

Eu não percebi que a saída também deveria ser de golfe até depois de escrever o programa, então irei para o compilador curto. Também foi muito trabalhoso testar, portanto, notifique se ele não funcionar corretamente :)

feersum
fonte
11
Estou confuso. Sua terceira linha substitui a string vazia? O que a string vazia corresponde no sed? "sed: primeiro RE pode não estar vazio"
Sparr
@ Sparr Tudo bem, tente com cursor em vez disso.
usar o seguinte código
3
ok, vamos ver se eu sigo ... zere a célula 0, defina a célula 1 como uma. substitua todos <por << e> por> X>. agora, sempre que o programa original acessa a célula no novo programa acessa a célula 2n, as células pares. X zera a célula ímpar que está sendo ignorada e, se não for zero, zera a célula seguinte (uma célula par) e define a próxima célula ímpar para 1. Eu tenho esse direito?
Sparr
2
Você sabe, se você estiver procurando por um compilador curto, isso representará apenas 35 bytes no Retina . ;)
Martin Enders
11
@ MartinBüttner plug descarado! : P
Otimizador
2

C ++

Tamanho do compilador: 630 bytes (-10 bytes graças a Zacharý)
Hello World tamanho do resultado da compilação: 139
Square under 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;}

O intérprete randomizado de 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;
    }
}

Algumas notas :

  • O compilador executará o programa para determinar as células de memória que são usadas. Se o seu programa for um loop infinito, o compilador fará um loop infinito.
HatsuPointerKun
fonte
Você pode reduzir sua pontuação alterando o nome de piipara P, alterando a definição de Rpara m[p<0?p%30000+30000:p]e modificando todas as chamadas / referências a eles de acordo. Além disso, ele modificou os casos de teste. Eu não verifiquei isso, mas pode salvar alguns bytes para definir algo para ser 30000, uma vez que você o usa com tanta frequência.
Zachary
11
Mudaria Rpara o m[p<0?p%S+S:p]trabalho?
Zachary
Remover os parênteses na definição de Rdeve salvar alguns bytes.
Zachary
1

rs , 33 bytes, Pontuação: 2659

Principalmente apenas uma porta simples da sedresposta.

</<<
>/>[->[-]>[-]+<<]>
[-]>[-]+<
kirbyfan64sos
fonte
11
Você publicou este idioma antes de ontem? Os idiomas que pós-datam a criação de uma pergunta não são válidos para o envio de respostas.
Sparr
@Sparr Bem, eu tive, mas depois eu destruí minha git commit história e tive que re-criar o repo ...
kirbyfan64sos