brainfuck

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Question book.svg
Esta página ou secção não cita nenhuma fonte ou referência, o que compromete sua credibilidade (desde janeiro de 2014).
Por favor, melhore este artigo providenciando fontes fiáveis e independentes, inserindo-as no corpo do texto por meio de notas de rodapé. Encontre fontes: Googlenotícias, livros, acadêmicoYahoo!Bing. Veja como referenciar e citar as fontes.
brainfuck
Paradigma Programação esotérica
Surgido em 1993
Última versão 2 (1993)
Criado por Urban Dominik Müller
Influenciada por FALSE, P′′
Influenciou Braintwist, L00P, PATH, Pbrain, SNUSP
Licença: Domínio público

brainfuck, também conhecido como brainf*ck ou BF, é uma linguagem de programação esotérica notada pelo seu extremo minimalismo, criada por Urban Müller, em 1993. Ela é uma linguagem Turing completa, desenhada para desafiar e confundir os programadores, e não é útil para uso prático. Pela sua simplicidade, o desenvolvimento de compiladores e interpretadores para essa linguagem é muito mais fácil do que para outras linguagens. O nome da linguagem é geralmente não-capitalizado (começa com uma letra minúscula), apesar de ser um substantivo próprio.

História[editar | editar código-fonte]

Urban Müller criou brainfuck em 1993, com a intenção de fazer uma linguagem que pudesse ser implementada com o menor compilador possível, inspirado pelo compilador de 1024 bytes de FALSE. Alguns compiladores foram feitos menores do que 200 bytes.

Exceto pelos seus dois comandos de E/S, brainfuck é uma variação da linguagem de programação P′′, criada por Corrado Böhm em 1964. Todos os outros seis comandos de brainfuck são idênticos ao de P′′.

Características[editar | editar código-fonte]

O brainfuck acessa a memória RAM através de células de memória, e um ponteiro que aponta inicialmente a primeira célula. O tamanho de cada célula de memória depende do compilador ou interpretador usado. Na versão original, eram usadas 30000 células de memória, de 1 byte cada, porém é comum em implementações mais novas, terem apenas 5000 células. Existem versões com até 1 Dword (4 bytes) por célula de memória.

Algumas implementações possuem células de memória dinâmica, que podem aumentar de tamanho durante a execução, sempre que houver necessidade. Essas versões são mais flexíveis, porém mais lentas.

Na versão original, cada célula pode ter um valor entre -128 e 127, porém, em implementações mais novas, cada célula pode ter um valor entre 0 e 255. Sendo os números finitos, algumas implementações reportam erro quando esses valores são excedidos, mas isso é bem incomum, sendo o mais comum, os valores girarem automaticamente (se o valor da célula for igual a 255 e seu valor for aumentado novamente, esse valor passa a ser 0 e, se o valor for 0 e for diminuido novamente, esse valor passa a ser 255). A maioria das implementações reconhece a tecla Enter como ASCII 10.

Normalmente, a extensão usada pelos códigos fonte em brainfuck é .b ou .bf.

Comandos[editar | editar código-fonte]

A linguagem possui apenas oito comandos, cada qual formado por apenas um caractere. Outros caracteres são considerados comentários, e são ignorados.

Caractere Descrição Equivalente em C
> Incrementa o ponteiro (acessa a célula de memória seguinte). ptr++;
< Decrementa o ponteiro (acessa a célula de memória anterior). ptr--;
+ Incrementa em um, o valor da célula de memória selecionada. array[ptr]++;
- Decrementa em um, o valor da célula de memória selecionada. array[ptr]--;
. Imprime na tela o caractere relativo à célula de memória selecionada. putchar(array[ptr]);
, Salva na célula de memória selecionada o código da próxima tecla a ser pressionada. array[ptr]=getchar();
[ Estrutura de controle que repete os comandos, enquanto a célula selecionada for diferente de zero. while(array[ptr]) {
] Fim da estrutura [. }

Exemplos[editar | editar código-fonte]

Programa Olá Mundo[editar | editar código-fonte]

++++++++++[>++++++++>+++++++++++
>---------->+++>++++++++>+++++++
+++++>+++++++++++>++++++++++>+++
++++++++>+++<<<<<<<<<<-]>-.>--.>
++++.>++.>---.>---.>.>.>+.>+++.,

O programa acima imprime na tela o texto (sem aspas): “Olá Mundo!”. Esse código poderia ser feito em uma única linha. Mais abaixo ainda, segue o mesmo código, escrito de forma mais legível, para explicar seu funcionamento:

++++++++++
[>++++++++>+++++++++++>---------->+++>++++++++>++++++++++++>+++++++++++>++++++++++>+++++++++++>+++
<<<<<<<<<<-]                    Inicia as células com os valores: 80, 110, 156 (256 - 100), 30, 80,
                                   120, 110, 100, 110, 30
>-.                             Imprime 'O'
>--.                            Imprime 'l'
>++++.                          Imprime 'á'
>++.                            Imprime ' '
>---.                           Imprime 'M'
>---.                           Imprime 'u'
>.                              Imprime 'n'
>.                              Imprime 'd'
>+.                             Imprime 'o'
>+++.                           Imprime '!'
,                               Aguarda alguma tecla ser pressionada

brainfuck ignora todos os caracteres, exceto os oito: +-<>[].,. Por este motivo, todo o resto é considerado comentário. A primeira linha aloca o valor 10 na primeira célula. A segunda linha inicia um laço de repetição, que adiciona os valores seguintes nas células seguintes, e repete esse processo até que o valor da primeira célula seja igual a 0. Na linha seguinte, o ponteiro volta dez células, e diminui em 1, o valor dessa célula. Esse procedimento age como uma multiplicação, fazendo com que os valores seguintes sejam iguais aos valores iniciais de cada célula vezes a primeira célula (10). Os caracteres > e < avançam e retrocedem a célula atual, respectivamente. Os caracteres [ e ] abrem e encerram o laço, respectivamente.

Na quarta linha, e ordenado que avance para a célula seguinte e diminua em um o valor dessa célula, resultando em 80 - 1 = 79, que é o equivalente a 'O', em ASCII. Em seguida, o caractere . imprime na tela o valor da célula atual. Na última linha, o caractere , aguarda até que uma tecla seja pressionada, impedindo que o programa encerre automaticamente.

Reconhecendo teclas[editar | editar código-fonte]

O código a seguir pega uma letra minúscula digitada e, a retorna maiúscula. Se a tecla Enter for pressionada, o programa encerra.

,>++[<----->-]<[----------
------------.,----------],

Ver também[editar | editar código-fonte]

Ligações externas[editar | editar código-fonte]


Ícone de esboço Este artigo sobre programação de computadores é um esboço. Você pode ajudar a Wikipédia expandindo-o.