Você deve escrever um programa BF (brainfuck de 100 bytes).
Um caractere removerá dele de todas as formas possíveis os 100 novos programas resultantes (99 bytes de comprimento). Por exemplo, para o programa ++.>.
os 5 subprogramas são +.>.
, +.>.
, ++>.
, ++..
e ++.>
.
Sua pontuação será o número de saídas exclusivas que os 100 programas geram. Maior pontuação é melhor.
Detalhes
- Seus programas serão encerrados após a saída do primeiro caractere.
- Programas inválidos ou não termináveis e programas que geram saídas vazias não são contabilizados para a pontuação.
- As células BF são de 8 bits. (255 + 1 = 0, 0-1 = 255)
- Seu programa não recebe nenhuma entrada. Se você usar
,
o código, ele definirá a célula atual para0
. - Não há células no lado esquerdo da posição inicial. Por exemplo,
<.
é inválido, mas.<
é válido, pois a execução é encerrada em.
. A fita não tem limites na outra direção. - Programas com colchetes não balanceados (
[
e]
) são inválidos. - Seu programa original pode ter menos de 100 bytes, pois é fácil estendê-lo para 100 bytes sem alterar a pontuação.
- Seu programa original não precisa ser um código BF válido.
Você pode usar este programa python3 (link ideone) para determinar a pontuação da sua resposta. (Para programas de longa execução, pode ser necessário modificar a maxstep
variável.)
Exemplo
(Para simplificar, este programa tem menos de 100 bytes.)
Solution: ++,+[-]+><.-,-.
Score: 3
Explanation:
Subprogram => Output
+,+[-]+><.-,-. => 1
+,+[-]+><.-,-. => 1
+++[-]+><.-,-. => 1
++,[-]+><.-,-. => 1
++,+-]+><.-,-. => None
++,+[]+><.-,-. => None
++,+[-+><.-,-. => None
++,+[-]><.-,-. => 0
++,+[-]+<.-,-. => None
++,+[-]+>.-,-. => 0
++,+[-]+><-,-. => 255
++,+[-]+><.,-. => 1
++,+[-]+><.--. => 1
++,+[-]+><.-,. => 1
++,+[-]+><.-,- => 1
Unique outputs are [0, 1, 255]
Score is 3 for ++,+[-]+><.-,-. (length = 15)
Em caso de empate, o vencedor é aquele com o código mais curto. (Seu programa pode ter menos de 100 bytes, conforme indicado na seção Detalhes.) Se os códigos tiverem o mesmo comprimento, o vencedor será o pôster anterior.
Quebra-cabeça bônus: sem a restrição em negrito, você pode encontrar um programa com pontuação 100?
fonte
Respostas:
Pontuação:
354169787983(Remova a nova linha.)
Experimente online!
Não sei exatamente por que isso funciona ...
Pontuação: 79
Experimente online!
Era para somar 2 * mem [i] * i e adicionar o número de células (+ const) onde os endereços são contados da direita para a esquerda. O multiplicador 2 e o número de células podem tornar a remoção + e> com paridade diferente.
De fato, funcionou assim na versão de 69 pontos. Mas a versão mais recente quebrou isso e conseguiu outra coisa por coincidência. Ele calcula soma (mem [i] * i + i + 1) e remover + e> faz quase o mesmo, exceto a soma (i) que tem uma diferença no número de células, que também é o número de saídas diferentes para remover + e>.
Para o bônus:
fonte
maxstep
valor (indef evaluate(r,maxstep=20000):
), pois alguns subprogramas são executados por um longo período de tempo.79
substituindo-a->+>+> ...
por->,>+> ...
Pontuação:
3743EDIT: Agora meu programa permite alguns colchetes. Não vou ganhar nenhum prêmio com isso, mas é o que eu ganho por fazer alguns RNGs ponderados fazerem o trabalho ocupado para mim.
Isso foi gerado por um programa que escrevi em C.
Para cada
N
caractere removido, aqui estão as saídas:Há um total de 37 saídas exclusivas, que são (em ordem numérica):
Estou
90%100% certo de que esta solução não é ótima, mas provando que isso pode ser extremamente difícil. Existem algumas coisas que estão claras. Não ter.
símbolos até o último caractere parecer ser o caminho a seguir, e colchetes (. Pensei um pouco aqui, que gostaria de descrever:[]
) parecem ser bastante inúteisSeja
L
o comprimento do código em bytes (no desafio100
) en
o número de saídas exclusivas dos subprogramas.Pois
L=3
existem várias soluções ótimas do formulário+-.
, onden=2
(nesse caso, as saídas são 1 e 255 para+.
e-.
, respectivamente.) Isso coloca a melhor proporção paraL = 3
emn/L = 66.67%
. Observe que essa proporção não pode ser ultrapassada por pelo menosL<10
.Pois
L=10
as soluções são simples o suficiente para forçá-lo a força bruta. Aqui estão todas as melhores soluções emn = 6
:O que gera uma taxa de pontuação de
n/L = 60%
.Como
L->infinity
é evidente, a razão deve se aproximar de 0, pois existem apenas 255 saídas possíveis para um potencial infinitoL
.A proporção NÃO, no entanto, diminui uniformemente. Não é possível construir uma solução para
n=6, L=9
, então a melhor razão possível paraL=9
é5/9 = 55.56% < 60%
.Isso levanta a questão: com que rapidez e de que maneira a proporção desce? Pois
L = 100
, e em10^9 checks/second
, levaria várias ordens de magnitude mais longas que a vida útil do universo para forçar uma solução ótima. Existe uma maneira elegante de fazer isso?Muito I dúvida de que é até37%
paraL = 100
.A proporção realmente aumenta, até
L=100
. Veja outras respostas para confirmar.Eu adoraria ouvir suas avaliações do que foi dito acima. Eu
poderia estaratrozmente errado, afinal.fonte