Escreva o programa mais curto no seu idioma favorito para interpretar um programa de foda cerebral . O programa é lido de um arquivo. Entrada e saída são entrada e saída padrão.
- Tamanho da célula: 8 bits sem sinal. O estouro é indefinido.
- Tamanho da matriz: 30000 bytes (não circulado)
- Comandos incorretos não fazem parte da entrada
Os comentários começam com # e se estendem até o fim da linhacomentários são tudo não em+-.,[]<>
- nenhum símbolo EOF
Um teste muito bom pode ser encontrado aqui . Ele lê um número e depois imprime os números primos até esse número. Para evitar a podridão do link, aqui está uma cópia do código:
compute prime numbers
to use type the max number then push Alt 1 0
===================================================================
======================== OUTPUT STRING ============================
===================================================================
>++++++++[<++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++.[-]
>++++++++++[<++++++++++>-]<+++++++++.[-]
>++++++++++[<++++++++++>-]<+.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++.[-]
>+++++++[<+++++++>-]<+++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
===================================================================
======================== INPUT NUMBER ============================
===================================================================
+ cont=1
[
- cont=0
>,
======SUB10======
----------
[ not 10
<+> cont=1
=====SUB38======
----------
----------
----------
--------
>
=====MUL10=======
[>+>+<<-]>>[<<+>>-]< dup
>>>+++++++++
[
<<<
[>+>+<<-]>>[<<+>>-]< dup
[<<+>>-]
>>-
]
<<<[-]<
======RMOVE1======
<
[>+<-]
]
<
]
>>[<<+>>-]<<
===================================================================
======================= PROCESS NUMBER ===========================
===================================================================
==== ==== ==== ====
numd numu teid teiu
==== ==== ==== ====
>+<-
[
>+
======DUP======
[>+>+<<-]>>[<<+>>-]<
>+<--
>>>>>>>>+<<<<<<<< isprime=1
[
>+
<-
=====DUP3=====
<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<<<
=====DUP2=====
>[>>+>+<<<-]>>>[<<<+>>>-]<<< <
>>>
====DIVIDES=======
[>+>+<<-]>>[<<+>>-]< DUP i=div
<<
[
>>>>>+ bool=1
<<<
[>+>+<<-]>>[<<+>>-]< DUP
[>>[-]<<-] IF i THEN bool=0
>>
[ IF i=0
<<<<
[>+>+<<-]>>[<<+>>-]< i=div
>>>
- bool=0
]
<<<
- DEC i
<<
-
]
+>>[<<[-]>>-]<<
>[-]< CLR div
=====END DIVIDES====
[>>>>>>[-]<<<<<<-] if divides then isprime=0
<<
>>[-]>[-]<<<
]
>>>>>>>>
[
-
<<<<<<<[-]<<
[>>+>+<<<-]>>>[<<<+>>>-]<<<
>>
===================================================================
======================== OUTPUT NUMBER ===========================
===================================================================
[>+<-]>
[
======DUP======
[>+>+<<-]>>[<<+>>-]<
======MOD10====
>+++++++++<
[
>>>+<< bool= 1
[>+>[-]<<-] bool= ten==0
>[<+>-] ten = tmp
>[<<++++++++++>>-] if ten=0 ten=10
<<- dec ten
<- dec num
]
+++++++++ num=9
>[<->-]< dec num by ten
=======RROT======
[>+<-]
< [>+<-]
< [>+<-]
>>>[<<<+>>>-]
<
=======DIV10========
>+++++++++<
[
>>>+<< bool= 1
[>+>[-]<<-] bool= ten==0
>[<+>-] ten = tmp
>[<<++++++++++>>>+<-] if ten=0 ten=10 inc div
<<- dec ten
<- dec num
]
>>>>[<<<<+>>>>-]<<<< copy div to num
>[-]< clear ten
=======INC1=========
<+>
]
<
[
=======MOVER=========
[>+<-]
=======ADD48========
+++++++[<+++++++>-]<->
=======PUTC=======
<.[-]>
======MOVEL2========
>[<<+>>-]<
<-
]
>++++[<++++++++>-]<.[-]
===================================================================
=========================== END FOR ===============================
===================================================================
>>>>>>>
]
<<<<<<<<
>[-]<
[-]
<<-
]
======LF========
++++++++++.[-]
@
Exemplo de execução:
$ python2 bf.py PRIME.BF
Primes up to: 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
code-golf
interpreter
brainfuck
Alexandru
fonte
fonte
,
EOF? Ou que cabe a nós escolher um valor ao experimentar o,
EOF? Ou o comportamento indefinido do EOF é totalmente?Respostas:
Perl, 120
138Isso executa hello.bf e primes.bf na perfeição:
Inicialização: O opcode para a tabela de conversão Perl é armazenado
%c
. A forma legível fica assim:Etapa 1: Slurp a entrada do programa
$_
e a transforme em código Perl usando a tabela de conversão. Os comentários são automaticamente removidos (substituídos porundef
) nesta etapa.Etapa 2: descompacte todas as
$b[$p]
ocorrênciasEtapa 3: inicie o programa usando
eval
.fonte
qw
sintaxe do Perl para definir%c
diretamente - bom para 7 caracteres a menos (você terá que dizerprint+chr$b[$p]
eord(getc)
, no entanto)Python (sem avaliação), 317 bytes
fonte
f(u,c,k)
while b*c[c[0]]and j<1
porwhile b*c[c[0]]*(j<1)
Código de máquina 8086 de 16 bits: 168 bytes
Aqui está a versão codificada em base64 , converta e salve como 'bf.com' e execute no prompt de comando do Windows: 'bf progname'
EDITAR
Aqui está um montador (estilo A86) para criar o executável (eu tive que fazer engenharia reversa disso, pois havia extraviado a fonte original!)
fonte
brainfuck ,
843691 bytesEdit: decidiu revisitar isso e encontrou um número surpreendente de maneiras de jogar fora os bytes
Isso recebe a entrada no formato em
code!input
que!input
é opcional. Também simula células negativas sem usar as próprias células negativas e pode armazenar até(30000-(length of code+6))/2
células.Experimente online!
fonte
Ruby 1.8.7,
188185149147 147 caracteresVersão um pouco legível:
Como você vê, roubei descaradamente a sua ideia de traduzir para o idioma host e usar eval para executá-lo.
fonte
>0
em vez de testar a igualdade:!=0
. As especificações dizem não assinado e o excesso não é definido.3e4
também irá trabalhar em oposição a30000
File.read($*.pop).bytes
->$<.bytes
deve funcionar também{?a,"foo"}
que é equivalente a{?a=>"foo"}
. E os testes aqui mostram que você pode substituíFile.read($*.pop).bytes
-lo$<
sem problemas. Também incluir tudo em algo comoeval"a[0]..."+$<.bytes.map{?.,"putc a[i]",...}*";"
reduz a solução em mais alguns caracteres.Cálculo binário Lambda 112
O programa mostrado no dump hexadecimal abaixo
espera que sua entrada consista em um programa Brainfuck (olhando apenas os bits 0,1,4 para distinguir entre -. + <>] [) seguido de a], seguido pela entrada do programa Brainfuck.
Salve o dump hexadecimal acima com xxd -r> bf.Blc
Pegue um intérprete do blc em https://tromp.github.io/cl/cl.html
Olá Mundo!
fonte
Retina 0.8.2 ,
386391386 bytesO código contém
0x00
caracteres NUL ( ) não imprimíveis . Também não é super golfado ainda, porque já é muito lento, e se eu jogar mais, não sei quanto tempo levaria para terminar. Parece esgotar o tempo limite na amostra de localização privilegiada.Pode haver erros no intérprete online ou no meu programa (novas linhas principais não aparecem na saída?).
Toma entrada como
<code>│<input>
. Não, isso não é um pipe (|
). É o caractere UnicodeU+2502
. O código também usa os caracteres Unicodeÿ▶◀├║
. Caracteres Unicode são usados para suportar a entrada de todos os caracteres ASCII. Portanto, esses caracteres precisam ser separados do código por um caractere não ASCII.Experimente online
Observe que há uma nova linha final lá.
Breve explicação:
Zeros
0x00
são usados para a fita, que é infinita. A primeira substituição configura o intérprete no formulário▶<code>│<input>├<output>║▶<tape>
, onde o primeiro▶
é o ponteiro para o código e o segundo é o ponteiro para a fita.ÿ
é0xFF
(255), que é usado para transliteração (usada para implementar+
e-
) para quebrar as células de volta a zero.◀
é usado apenas para facilitar a leitura (caso o programa seja interrompido no meio ou você queira ver o programa no meio da execução). Caso contrário, você não poderia dizer para que lado o ponteiro estava se movendo.Código comentado:
Clique aqui para o código com zeros no lugar de bytes nulos. Quaisquer ocorrências de
$0
não devem ser substituídas por nulos.Editar : agora suporta entrada vazia e suprime a nova linha à direita.
Saída infinita agora é suportada. (403 bytes)
fonte
<code>
e o<tape>
próximo um do outro (embora houvesse mais caracteres) para que a transição para um intérprete SMBF fosse mais fácil, se eu decidisse fazer isso.TI-BASIC, 264 bytes
Devido às limitações no TI-BASIC, isso não se qualifica para esse desafio, pois quebra a regra 2; a RAM das calculadoras é muito limitada, e fazer algo do tipo
30000->dim(L1
(eu uso L1 para a pilha / matriz) forçará o lançamento de umERR:MEMORY
. Como tal, a pilha / matriz começa no tamanho de 1 e cresce se o ponteiro estiver apontando para um elemento após o final dele. Ele também viola a regra 3, porque já está violando a regra 2, então é melhor não me preocupar com um limite de tamanho de célula.Provavelmente ainda pode ser jogado, a propósito ... Eu fiz uma ou duas edições para esse fim desde o primeiro envio, mas se a versão abaixo não funcionar, volte para a edição de 6 de maio de 15 e use-a código em vez disso. Além disso, como realmente não há ASCII no TI-BASIC, isso leva números de qualquer tamanho (e qualquer coisa que retorne um número, como uma variável ou expressão) como entrada e gera números por vez.
Use o SourceCoder para compilá-lo em um arquivo .8xp e depois envie-o para a sua calculadora com TI-Connect ou TILP ou algo assim, e execute-o incluindo seu programa de foda cerebral entre aspas duplas seguido por dois-pontos e qualquer que seja o nome do programa TI-BASIC. Por exemplo, se você é chamado BRAINF, você executar um programa como este:
"brainfuck goes here":prgmBRAINF
. Se você tem um escudo em seu calc que intercepta outros comandos quando detecta oprgm
sinal, porém, fazer isso:"brainfuck goes here" -> press ENTER -> prgmBRAINF
.Se você não tem como conectar sua calculadora ao computador e deseja digitar isso no cálculo (não consigo imaginar por que você gostaria, mas discordo), observe que
->
é oSTO>
botão acima do botão ON ,~
é o símbolo negativo ao lado de ENTER e substitui todas as instânciasL<number>
pelo token de lista correspondente encontrado em2ND -> <number on keypad>
Agradeço a thomas-kwa (pelo menos, acho que esse é o nome de usuário do Stack) por me ajudar a otimizar isso, especialmente com as instruções
[
e]
.fonte
Ans+S
?S-sum(not(cumSum(L4(Ans)=seq(L4(X),X,Ans+1,dim(L4->S
. (a-a=0
) E ei, não se preocupe em esquecer UMA coisa de ordem de operação aqui, já vi várias pessoas esquecerem a ordem de operações para%
(mod) em um desafio.Pitão
275248255Eu decidi tentar.
fonte
exec t
?). Se você usar a dica de S.Mark e também transformar todo ofor
ciclo em uma linha, poderá reduzi-lo para 243 caracteres.[]
um programa bf válido, embora trivial. Sugeri uma edição que corrige isso, mas aumenta a contagem de caracteres. Para reduzir ainda mais a contagem de caracteres, você podefrom sys import *
usar e'i+=1,...'.split(',')
não usar['i+=1',...]
.+1
, mas muitas melhorias foram sugeridas e não implementadas.Haskell,
457413 caracteresEsse código "compila" o programa BF em uma
IO
ação da forma em queState -> IO State
o estado é um zíper em uma sequência infinita.Infelizmente, eu tive que gastar 29 caracteres para desativar o buffer. Sem eles, ele funciona, mas você não vê os prompts antes de digitar input. O compilador si (
b
,f
, ek
) é apenas de 99 caracteres, o tempo de execução (#
e%
) é 216. O motorista w / estado inicial outra 32.update 2011-02-15: Incorporou as sugestões de JB, renomeou um pouco e reforçou
main
fonte
IO
e os argumentos de apenasSystem
(-19). O problema de buffer também me incomoda, pois as especificações realmente não o mencionam e a resposta mais votada nem sequer faz E / S. Se você precisar mantê-lo, provavelmente será mais curtohFlush
depois de cada gravação do que alterar o modo de buffer global (-34 + 15).Transportadora, 953
Este pode ser o código mais bonito que você verá:
fonte
C
284362 (De um arquivo)Primes:
Compilado e executado com sucesso VS2008
A solução original falhou ao reconhecer os loops que foram inicialmente definidos como zero. Ainda há espaço para jogar golfe. Mas finalmente resolve o programa Prime Number.
Ungolfed:
Testes:
Olá Mundo
Rot13
fonte
l
) toda vez que faz um loop? Eu acho que você deve verificar a localização atual da cabeça (p
).l
no buffer atingiu zero e interrompe, caso contrário, redefine o fluxo de volta ao loop original[
. Isso é necessário para[
loops aninhados .break;else
porreturn;
.(c==62)?a:b
por(c-62)?b:a
.PHP 5,4,
296294273263261209191183178166 caracteres:Eu tentei sem usar o eval, mas eventualmente tive que usá-lo
Todos os comandos estão funcionando. Isso abusa fortemente de variáveis variáveis e vomita avisos. No entanto, se alguém mudar seu php.ini para silenciar avisos (ou canalizar stderr para / dev / null), isso funcionará muito bem.
Verificação (é o exemplo "Hello World!" Da Wikipedia ): http://codepad.viper-7.com/O9lYjl
Ungolfed,
367365335296267 caracteres:Isso deve ser executado através da linha de comando:
php bf.php hello.bf
fonte
Windows PowerShell, 204
Conversão bastante direta das instruções e, em seguida
Invoke-Expression
.História:
3e4
é mais curto que30000
.switch
.Write-Host
.fonte
C, 333 caracteres
Este é o meu primeiro intérprete de BF e o primeiro golfe que eu tive que depurar.
Isso executa o gerador de números primos no Mac OS X / GCC, mas
#include<string.h>
pode ser necessário um adicional a um custo de 19 caracteres a mais, se a definição implícita destrchr
não funcionar em outra plataforma. Além disso, assumeO_RDONLY == 0
. Além disso, deixar deint
fora a declaração deM
salvar três caracteres, mas isso não parece ser compatível com C99. Mesmo com o terceiro*
emb()
.Isso depende dos detalhes da codificação ASCII. Os operadores Brainfuck são todos pares complementares separados por uma distância de 2 no espaço de código ASCII. Cada função neste programa implementa um par de operadores.
fonte
#define
Consegui reduzir outros 4 caracteres com ajustes, e usar uma tabela em vez da função também provavelmente seria terser. Eu apenas gosto do número 333 e da tabela: v).||
.CJam, 75 bytes
Experimente on-line: reversor de string , Olá Mundo .
Explicação
Pega código na primeira linha do STDIN e insere em todas as linhas abaixo dele.
E a lista mágica?
A lista resultante é a seguinte:
Geramos os trechos para
+
e>
daqueles-
e para<
, simplesmente alterando os parênteses à esquerda ("decremento" de CJam) em parênteses à direita ("incremento") de CJam.fonte
F #: 489 caracteres
O programa a seguir não pula nas instruções '[' / ']', mas verifica o código-fonte para o próximo token correspondente. É claro que isso fica meio lento, mas ainda é possível encontrar os números primos abaixo de 100. Os tipos inteiros de F # não transbordam, mas envolvem.
Aqui está a versão curta:
Uma pegadinha desagradável foi que o programa primes.bf engasga com as novas linhas do Windows. Para executá-lo, tive que salvar o número de entrada em um documento de texto formatado em UNIX e alimentá-lo no programa com um pipe:
Editar: inserir Alt + 010 seguido de Enter também funciona no Windows cmd.exe
Aqui está a versão mais longa:
fonte
Delphi,
397382378371366364328 caracteresComa este Delphi!
Aqui o mesmo código, recuado e comentado:
Este me levou algumas horas, pois não é o tipo de código que eu normalmente escrevo, mas aproveite!
Nota: O teste principal funciona, mas não para em 100, porque lê # 13 (CR) antes de # 10 (LF) ... outros envios também sofrem esse problema ao executar em sistemas operacionais CRLF?
fonte
C, 260 + 23 = 283 bytes
Eu criei um programa C que pode ser encontrado aqui .
Precisa ser compilado via
gcc -D"q(a,b)"="*c-a||(b);" -o pmmbf pmmbf.c
e pode ser chamado da seguinte maneira:pmmbf ",[.-]" 30000
pelo qual o primeiro argumento (citado) contém o programa bf a ser executado, o segundo determina o tamanho da fita.fonte
-D"q(a,b)"="*c-a||(b);"
opção, pois isso parece (pelo menos para o meu entendimento) estar ajudando você a reduzir seu código.define
e a nova linha, mas não acho que seja realmente kosher. De qualquer forma, com as citações, comente egcc -D
não vejo a vantagem.C, 267
Execute como ./a.out primes.bf
Versão Ungolfed:
fonte
Python 2, 223
Admito que reciclei um programa antigo meu (mas tive que alterá-lo um pouco, porque a versão antiga não tinha entrada, mas verificação de erro ...).
Executa a calculadora de números primos bem.
Vejo agora que Alexandru tem uma resposta que tem algumas semelhanças. Vou postar minha resposta de qualquer maneira, porque acho que há algumas idéias novas nela.
fonte
C (gcc) Linux x86_64,
884 621 525 487 439 383 358354 bytesExperimente online!
Este é um JIT que compila o código BF na linguagem de máquina x86_64 em tempo de execução. Isso realiza uma tradução recta de modo que ocorre comumente sequências, tais como
>>>
,<<<
,+++
e---
não são fundiram-se em instruções mais rápidos.Versão menos golfe:
fonte
C,
374368Lê de um arquivo. Passa no teste PRIME.BF.
Uso: ./a.out PRIME.BF
Reformatado:
fonte
Lua, 285
Versão um pouco legível:
Funciona perfeitamente
Lua, 478, sem carga
Versão legível:
fonte
Brainfuck, 948 bytes
Bem, isso levou um tempo. Joguei um auto-intérprete de Brainfuck por ... não eu.
fonte
Lembre-se , 594 bytes
Em resumo: a Recall não possui operadores aritméticos no sentido clássico, apenas possui operações bit a bit. Você não pode simplesmente "adicionar um" etc. A rechamada também é estritamente baseada em pilha.
Exemplo 1: Imprimir algo
Entrada:
Resultado:
Exemplo 2: números quadrados de saída até 100
Entrada:
Resultado:
Este exemplo pode demorar alguns minutos para ser executado e pode causar uma mensagem "esta guia está congelada". Ignore isso e espere.
fonte
OCaml (lex), 497 caracteres
OCamllex faz parte da distribuição padrão do OCaml.
Salve como b.mll e execute com
Como não gosto de analisar manualmente, usei o gerador de lexer fornecido. A partir das fichas lidas, compomos uma função para todo o programa brainf * ck.
fonte
C # (2861 caracteres, ~ 84 linhas)
Essa não é a solução mais bonita para o problema, e provavelmente não é tudo isso 'Golf-ish', já que eu não estava tão preocupado com o comprimento quanto provavelmente deveria estar. (Não removi os comentários ou espaço em branco extra.) Só queria tentar algo em um novo idioma, para ver se era possível. Se eu fizesse novamente, abandonaria o uso da pilha para retornar de ']' e apenas olharia para trás. Executar sem argumentos de linha de comando, ele executa o programa hello world fornecido na descrição do problema. Ele aceita um argumento de linha de comando, o nome do arquivo do programa a ser executado.
Editar: referências não utilizadas removidas.
fonte
C (gcc) ,
273268 bytesExperimente online!
-5 graças a ceilingcat
Recebe entrada de stdin.
Isso depende um pouco do ambiente, mas é bastante consistente. Esta é efetivamente a solução de avaliação para c. Ele grava um programa C apropriado no arquivo wc, o compila e o executa como o executável desejado. Assim, como efeito bônus, na verdade, ele compila o código bf e o deixa
a.out
como um binário. Observe que, dependendo do sistema, pode ser necessário modificar a última string. Em particular, a maioria dos compiladores do Windows c chama o executável padrão "a.exe". Felizmente, tanto quanto posso dizer, todos têm o mesmo comprimento, portanto o número de bytes é o mesmo. (embora se você não tiver um cc definido, poderá ser necessário adicionar uma letra como gcc ao comando compile, adicionando 1 byte).Estou ciente de que esse segmento é um pouco antigo, mas ainda não vi esse estilo de solução C, então pensei em adicioná-lo.
fonte
[EDITAR]
C ++ 11, 355, lê do arquivo:
Teste
http://ideone.com/b7vO4
[VERSÃO ANTIGA]
C ++ 11, 391, para ver em execução: http://ideone.com/yZHVv
fonte