Brainfuck é uma linguagem de programação esotérica criada por Urban Müller em 1993. O objetivo era criar a menor implementação possível de um compilador, pois a original ocupava apenas 240 bytes.
Apesar de ser Turing-completa (ou seja, capaz de computar qualquer coisa computável), ela possui apenas 8 comandos, todos representados por símbolos. Não é usada em produção, mas é muito popular como desafio intelectual e para estudo de teoria da computação.
+ - > < . , [ ]
Brainfuck opera sobre uma fita (array) de células de memória, cada uma iniciando em 0. Um ponteiro aponta para a célula atual e pode ser movido para esquerda ou direita.
| Índice | 0 | 1 ← ponteiro | 2 | 3 | ... |
|---|---|---|---|---|---|
| Valor | 0 | 5 | 0 | 0 | ... |
Quando o valor de uma célula ultrapassa 255, ele volta para 0 (overflow). Da mesma forma, decrementar abaixo de 0 vai para 255.
Brainfuck possui exatamente 8 comandos. Qualquer outro caractere no código é ignorado e pode ser usado como comentário.
| Comando | Descrição |
|---|---|
| + | Incrementa o valor da célula atual em 1 |
| - | Decrementa o valor da célula atual em 1 |
| > | Move o ponteiro para a próxima célula (direita) |
| < | Move o ponteiro para a célula anterior (esquerda) |
| . | Exibe o caractere ASCII da célula atual |
| , | Lê um caractere da entrada e armazena na célula atual |
| [ | Se a célula atual for 0, pula para o ] correspondente |
| ] | Se a célula atual for diferente de 0, volta para o [ correspondente |
O comando + adiciona 1 ao valor da célula onde o ponteiro está. Se o valor for 255, voltará para 0 (overflow de byte).
# Célula 0 começa em 0 +++ # célula 0 agora vale 3 ++ # célula 0 agora vale 5
É o comando mais usado para construir valores. Use com laços para evitar escrever + muitas vezes.
O comando - subtrai 1 do valor da célula atual. Se chegar a -1, volta para 255 (underflow).
# Célula 0 = 5 ----- # célula 0 agora vale 0
O comando > move o ponteiro uma célula para a direita na fita.
# Ponteiro na célula 0 > # agora ponteiro está na célula 1 > # agora ponteiro está na célula 2
O comando < move o ponteiro uma célula para a esquerda. Não use na célula 0 ou causará erro na maioria dos interpretadores.
# Ponteiro na célula 2 < # volta para célula 1 < # volta para célula 0
O comando . imprime o caractere cujo código ASCII corresponde ao valor da célula atual.
# Célula 0 = 72 (ASCII de 'H') ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ . # imprime 'H'
Para imprimir múltiplos caracteres, use vários . ou construa os valores com laços.
O comando , lê um único caractere da entrada padrão e armazena seu código ASCII na célula atual.
, # lê um caractere do usuário e guarda na célula 0 . # exibe o mesmo caractere de volta (eco)
[ e ] formam o único mecanismo de controle de fluxo do Brainfuck:
[ -> se a célula atual for 0, pula para depois do ] correspondente] -> se a célula atual for diferente de 0, volta para o [ correspondente+++++ # célula 0 = 5 [ # enquanto célula 0 != 0: >+< # incrementa célula 1, volta para célula 0 - # decrementa célula 0 ] # repete até célula 0 = 0 # Resultado: célula 1 = 5 (copiamos o valor!)
O padrão [-] é o jeito idiomático de zerar uma célula: decrementa até chegar a 0.
Veja os exemplos clássicos no menu à esquerda: Hello World, Somar dois números e um Contador com laço.
O clássico "Hello, World!" em Brainfuck. Cada letra é construída usando laços para atingir o valor ASCII desejado:
++++++++ # célula 0 = 8 [ >++++ # célula 1 += 4 [ >++>+++>+++>+<<<<- ] >+>+>->>+ [<]<- ] >>. # H >---. # e +++++++.. # ll +++. # o >>. # , <-. # (espaço) <. # W +++. # o ------. # r --------. # l >>+. # d >++. # !
Este é um dos programas mais famosos em Brainfuck. Usa laços aninhados para calcular os valores ASCII de cada letra de forma eficiente.
Somando 3 + 5 e exibindo o resultado como dígito:
+++ # célula 0 = 3 >+++++ # célula 1 = 5 [<+>-] # enquanto célula 1 != 0: célula 0++, célula 1-- # Resultado: célula 0 = 8, célula 1 = 0 < # volta para célula 0 # Para exibir como dígito ASCII, some 48 (ASCII de '0'): ++++++++++++++++++++++++++++++++++++++++++++++++ # 48 sinais + (célula 0 agora = 56, ASCII de '8 ') . # exibe: 8
Exibe os caracteres ASCII de 'A' (65) até 'E' (69) usando um laço simples:
# célula 0 começa em 65 (ASCII de 'A') +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # 65 sinais + . # A (65) +. # B (66) +. # C (67) +. # D (68) +. # E (69)
[-] # decrementa até 0 — zera qualquer célula
# Copia célula 0 para célula 1 (destrói o original) [>+<-] # Copia célula 0 para célula 1 preservando o original (usa célula 2 como temp) [>+>+<<-]>>[<<+>>-]
# Multiplica células 0 e 1, resultado na célula 2 [>[>+>+<<-]>>[<<+>>-]<<<-]
Comentários em Brainfuck: qualquer caractere que não seja + - > < . , [ ] é ignorado pelo interpretador, portanto pode ser usado livremente como comentário ou espaçamento.