Voir la source de Brainfuck

{{confusion|Mindfuck}}
{{Infobox Langage de programmation
 | image                    = Hello_World_Brainfuck.png
 | légende                  = Programme "Hello World!" en brainfuck
 | nom                      = Brainfuck
 | date de première version = 1993
 | auteur                   = Urban Müller
 | a influencé              = [[Ook]], [[Whitespace]], Spoon, SegFaultProg
}}
'''{{Langue|en|Brainfuck}}''' est un [[langage de programmation]] [[Langage de programmation exotique|exotique]], inventé par Urban Müller en [[1993]]. Il tire son nom de l’union de deux mots anglais, ''{{Lang|en|brain}}'' (« cerveau ») et ''{{Lang|en|fuck}}'' (« niquer »), et joue sur les mots, puisque ce langage est volontairement simpliste, et parce que l'expression ''Brain Fuck'' évoque, en argot, ce qui met le cerveau dans un état de confusion par sa complexité apparente. Ce vocabulaire peu flatteur lui a d'ailleurs valu d'être écrit sous d'autres orthographes plus prudes, telles que Brainf*ck, Brainf*** ou encore BF.

== Présentation du langage ==
L'objectif de Müller était de créer un langage de programmation simple, destiné à fonctionner sur une [[machine de Turing]], et dont le [[compilateur]] aurait la taille la plus réduite possible. Le langage se satisfait en effet de seulement huit instructions. La version 2 du compilateur originel de Müller, écrit pour l'[[Amiga]], ne pesait lui-même que 240 [[octet]]s, la version actuelle se contentant de 171 [[octet]]s. Le brainfuck est pourtant un langage [[Turing-complet]]<ref>{{en}} [http://www.iwriteiam.nl/Ha_bf_Turing.html Preuve de la Turing-complétude de brainfuck en anglais]</ref>, ce qui signifie que, malgré les apparences, il est théoriquement possible d'écrire n'importe quel programme informatique en brainfuck.

La contrepartie est que les programmes produits sont inefficaces et difficiles à comprendre. Il suit un modèle de machine simple, consistant en un tableau d'octets initialisés à 0, d'un pointeur sur le tableau (positionné sur le premier octet du tableau) et de deux files d'octets pour les entrées et sorties.

== Implémentation ==

=== Structure du brainfuck ===
Le brainfuck utilise un tableau de 30 000 cases dans lequel il stocke des valeurs. Chacune de ces cases prend une valeur entière codée sur 8 bits, ce qui permet des valeurs entre 0 et 255 ou entre -128 et 127. Il utilise également un [[Pointeur (programmation)|pointeur]], c'est-à-dire une variable qui prend des valeurs entières positives indiquant l'indice de la case du tableau que l'on modifie actuellement. Par convention, on attribue en informatique l'indice 0 à la première case du tableau.

Au lancement du code brainfuck, le pointeur est initialisé à 0 et toutes les cases du tableau sont nulles.

Dans les nouvelles implémentations du brainfuck, la taille du tableau n'est pas restreinte à 30 000 cases et celles-ci peuvent prendre des valeurs plus élevées. Le pointeur, lui, peut prendre des valeurs négatives, c'est-à-dire que le tableau peut s'étendre à gauche de la case d'indice nul.

=== Instructions ===
Les huit instructions du langage, chacune codée par un seul caractère, sont les suivantes :
{| class="wikitable"
|-----
! Caract.
! Signification
|-----
| {{Code|>}}
| incrémente (augmente de 1) le pointeur.
|-----
| {{Code|<}}
| décrémente (diminue de 1) le pointeur.
|-----
| {{Code|+}}
| incrémente l'octet du tableau sur lequel est positionné le pointeur (l'octet pointé).
|-----
| {{Code|-}}
| décrémente l'octet pointé.
|-----
| {{Code|.}}
| sortie de l'octet pointé (valeur ASCII).
|-----
| {{Code|,}}
| entrée d'un octet dans le tableau à l'endroit où est positionné le pointeur (valeur ASCII).
|-----
| {{Code|[}}
| saute à l'instruction après le ] correspondant si l'octet pointé est à 0.
|-----
| {{Code|]}}
| retourne à l'instruction après le [ si l'octet pointé est différent de 0.
|}
(Alternativement, {{Code|]}} peut être défini par « retourne au {{Code|[}} correspondant ». La formulation est plus courte, mais moins symétrique et moins efficace en temps. Le choix de l'une ou l'autre de ces deux syntaxes n'influe pas sur le comportement final du programme.)

(Une troisième version équivalente, quoique moins considérée, est :
{{Code|[}} signifie « saute à l'instruction {{Code|]}} correspondante », et {{Code|]}} signifie « retourne à l'instruction après le {{Code|[}} correspondant si l'octet pointé est différent de 0 ».)

Les programmes brainfuck peuvent être traduits en C en utilisant les substitutions suivantes, en considérant que <code>ptr</code> est du type <code>unsigned char*</code> :
{| class="wikitable"
|-----
! Brainfuck
! C
|-----
| align="center" | {{Code|>}} || {{Code|ptr++;}}
|-----
| align="center" | {{Code|<}} || {{Code|ptr--;}}
|-----
| align="center" | {{Code|+}} || {{Code|++(*ptr);}}
|-----
| align="center" | {{Code|-}} || {{Code|--(*ptr);}}
|-----
| align="center" | {{Code|.}} || {{Code|putchar(*ptr);}}
|-----
| align="center" | {{Code|,}} || {{Code|1=(*ptr) = getchar();}}
|-----
| align="center" | {{Code|[}} || {{Code|while(*ptr) {}}
|-----
| align="center" | {{Code|]}} || <code>}</code>
|}

=== Traducteur de brainfuck en ligne ===
Lien pour traducteur:

https://www.dcode.fr/brainfuck-language

Lien pour explication:

https://www.codingame.com/playgrounds/50426/getting-started-with-brainfuck/welcome

=== Entrées / Sorties ===

==== Entrées ====
Les différents interpréteurs de brainfuck gèrent les entrées différemment. Prenons pour exemple le programme suivant :<syntaxhighlight lang="brainfuck" line="1">
,[>,]        ',' : prend une première entrée, puis '[>,]': se déplace à droite, demande une nouvelle entrée et continue tant que l'entrée n'est pas nulle.
</syntaxhighlight>Celui-ci se charge d'inscrire les entrées les unes à la suite des autres dans le tableau jusqu'à ce qu'une des entrées soit 0.

Certains interpréteurs demanderont à l'utilisateur à chaque fois qu'ils rencontrent la commande "," une entrée. Par exemple, l'utilisateur rentrera 12, puis 15, puis 2, puis 36, puis 0, et obtiendra le tableau [12,15,2,36,0,0, etc.]

D'autres ne demanderont qu'une seule entrée à plusieurs chiffres, comme 1215236, et la découperont chiffre par chiffre pour obtenir toutes les entrées requises: 1, puis 2, puis 1, puis 5 ... Dès qu'il n'y a plus de chiffres à mettre en entrée, l'interpréteur les remplace automatiquement par des 0. Ainsi dans notre exemple, on obtiendra le tableau [1,2,1,5,2,3,6,0,0, etc.]. Si l'utilisateur rentre un nombre avec un 0 à l'intérieur, le programme s'arrêtera comme prévu à ce 0 sans copier le reste du nombre. Par exemple, 12150236 donnera [1,2,1,5,0,0, etc.]

<nowiki>En général, comme on vient de le faire, les entrées sont des nombres, mais peuvent être également des caractères ASCII, l'interpréteur se charge de les remplacer par leur code équivalent. Par exemple, si l'on rentre "Hello World" avec le code précédent, on obtient alors : [72,101,108,108,111,32,87,111,114,108,100,0,0,...].</nowiki>

==== Sorties ====
Comme pour les entrées, les sorties peuvent soit être exprimées en ASCII, soit directement numériquement.

== Exemples ==
=== Hello World! - Exemple #1 ===
Le programme suivant affiche le traditionnel « [[Hello world|Hello World!]] » et une nouvelle ligne à l'écran :

<syntaxhighlight lang="bf">

++++++++++          Affecte 10 à la case 0
[                   Boucle initiale qui affecte des valeurs utiles au tableau 
   >                avance à la case 1 
   +++++++          affecte 7 à la case 1
   >                avance à la case 2
   ++++++++++       affecte 10 à la case 2 
   >                avance à la case 3
   +++              affecte 3 à la case 3
   >                avance à la case 4
   +                affecte 1 à la case 4
   <<<<             retourne à la case 0
   -                enlève 1 à la case 0
]                   jusqu'à ce que la case 0 soit = à 0
la boucle initialise le tableau selon les valeurs suivantes :
Case : Valeur
0 : 0
1 : 70
2 : 100
3 : 30
4 : 10

>++                    ajoute 2 à la case 1 (70 plus 2 = 72)
.                      imprime le caractère 'H' (72)
>+                     ajoute 1 à la case 2 (100 plus 1 = 101)
.                      imprime le caractère 'e' (101)
+++++++                ajoute 7 à la case 2 (101 plus 7 = 108)
.                      imprime le caractère 'l'  (108)
.                      imprime le caractère 'l'  (108)
+++                    ajoute 3 à la case 2 (108 plus 3 = 111)
.                      imprime le caractère 'o' (111)
>++                    ajoute 2 à la case 3 (30 plus 2 = 32)
.                      imprime le caractère ' '(espace) (32)
<<                     revient à la case 1
+++++++++++++++        ajoute 15 à la case 1 (72 plus 15 = 87)
.                      imprime le caractère 'W' (87)
>                      repart à la case 2
.                      imprime le caractère 'o' (111)
+++                    ajoute 3 à la case 2 (111 plus 3 = 114)
.                      imprime le caractère 'r' (114)
------                 enlève 6 à la case 2 (114 moins 6 = 108)
.                      imprime le caractère 'l'  (108)
--------               enlève 8 à la case 2 (108 moins 8 = 100)
.                      imprime le caractère 'd'  (100)
>                      repart à la case 3
+                      ajoute 1 à la case 3 (32 plus 1 = 33)
.                      imprime le caractère '!' (33)
>                      va à la case 4
.                      imprime le caractère '\n'(nouvelle ligne) (10)
</syntaxhighlight>

Par souci de lisibilité, le code a été divisé en plusieurs lignes et des commentaires ont été ajoutés. Brainfuck considère comme étant des commentaires tous les caractères sauf <code>+-<>[],.</code>. Le code effectivement compilé peut donc se réduire à la ligne suivante :

<syntaxhighlight lang="bf">
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
</syntaxhighlight>


La première ligne initialise <code>a[0] = 10</code> par de simples incréments successifs à partir de 0. La boucle des lignes 2 à 4 définit de façon effective les valeurs initiales du tableau : <code>a[1] = 70</code> (proche de 72, le code [[ASCII]] du caractère 'H'), <code>a[2] = 100</code> (proche de 101 ou 'e'), <code>a[3] = 30</code> (proche de 32, espace) et <code>a[4] = 10</code> (nouvelle ligne). La boucle fonctionne en multipliant les valeurs de <code>a[0]</code>, <code>10</code>, par 7, 10, 3, et 1, qu'elle stocke dans les cellules voisines. Quand la boucle s'achève, <code>a[0]</code> vaut zéro. <code>>++.</code> déplace alors le pointeur à <code>a[1]</code>, qui contient <code>70</code>, y ajoute 2 (72 étant le code [[ASCII]] de la lettre 'H' majuscule), et l'affiche.

La ligne suivante déplace le pointeur vers <code>a[2]</code> et l'incrémente de 1, le résultat, <code>101</code>, correspondant à 'e', qui est alors affiché.

'l' étant la septième lettre de l'alphabet après 'e', pour obtenir 'll' il faut ajouter 7 (<code>+++++++</code>) à <code>a[2]</code> et l'afficher deux fois.

'o' est la troisième lettre de l'alphabet après 'l', on incrémente donc <code>a[2]</code> trois fois avant d'afficher le résultat.

Le reste du programme fonctionne selon le même principe. Pour les espaces et les lettres en majuscule, ce sont d'autres cellules du tableau qui sont sélectionnées et incrémentées.

=== Exemple #2 ===
 ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++++++++++++++.>+++++++++++++++++.<<++.>+++++++++++++.>--.<<.>+++.+.--.>----.++++++.+.<++.>----.++.<<.>>+.-------.<<.>>++.<.>+++++.<<.>-.+.<.>---.>---.<-.++++++++.>----.<---.>+++++++.<---.++++++++. 
{{Passage non pertinent|Ce programme donne un texte, comme l'exemple précédent. Essayez de le faire fonctionner pour savoir ce qui est caché derrière ce texte.}}

=== Remise à zéro de l'octet pointé ===
<syntaxhighlight lang="bf">,     ciblage de l’octet
[     boucle 
-     enlever 1 à la case courante 
]     jusqu'à ce que la case soit à zéro</syntaxhighlight>

L'octet est décrémenté (boucle [ ]) jusqu'à ce que sa valeur ait atteint 0.

=== Entrée/Sortie d'un caractère ===
<syntaxhighlight lang="bf">,  saisit un caractère de la ligne de commande dans la case courante
.  imprime le caractère correspondant à la valeur de la case courante</syntaxhighlight>

Affiche à l'écran un caractère entré au clavier.

=== Boucle simple ===
<syntaxhighlight lang="bf">[,.] ou ,[.,]</syntaxhighlight>

Boucle affichant les caractères entrés au clavier. La fin de la saisie est ici signalée par un 0 (les implémentations peuvent différer sur ce point).

=== Manipulation de pointeur ===
* Enregistrer une chaîne de caractères
<syntaxhighlight lang="bf"> ,[.>,]</syntaxhighlight>

Une version améliorée de la boucle précédente, dans laquelle les caractères saisis par l'utilisateur sont stockés dans un tableau en vue d'une utilisation future, en déplaçant le pointeur à chaque fois.
 
* Utilisation de bloc de mémoire (taille quelconque, mais ne contenant pas de valeur nulle)

En notant P le pointeur, - - - - un bloc de données quelconques non nulles et 0 un octet dont la valeur est nulle, si la mémoire est organisée de la manière suivante :

<syntaxhighlight lang="bf"> 0P- - - -00- - - -00- - - -00- - - -00- - - ... avec les blocs - - - - numérotés de 1 à n
</syntaxhighlight>
Alors nous pouvons nous déplacer de bloc en bloc de la manière suivante (avec le pointeur initialement sur P ) :

<syntaxhighlight lang="bf">
[-[-[>]>+<<[<]>]]
</syntaxhighlight>
Par exemple, si P=3, à chaque exécution de la boucle principale, la mémoire sera organisée de cette façon :

<syntaxhighlight lang="bf">
 0P- - - -00- - - -00- - - -00- - - -00- - - ... avec P = 3
 00- - - -0P- - - -00- - - -00- - - -00- - - ... avec P = 2
 00- - - -00- - - -0P- - - -00- - - -00- - - ... avec P = 1
 00- - - -00- - - -00- - - -0P- - - -00- - - ... avec P = 0
</syntaxhighlight>
Arrivée à ce point, la boucle s'arrête, et nous sommes arrivés sur le bloc pointé. Cette technique permet de manipuler des blocs de taille quelconque, à condition qu'ils ne contiennent pas de valeurs nulles.

* Utilisation de bloc de mémoire (taille fixe, pouvant contenir des valeurs nulles)
En reprenant la technique précédente, mais cette fois avec des blocs de tailles constantes (par exemple 4, on obtient) :
<syntaxhighlight lang="bf">
0P- - - -00- - - -00- - - -00- - - -00- - - ... avec les blocs - - - - numérotés de 1 à n
[-[->>>>>>+<<<<<<]]   Il faut 4 (taille des blocs) + 2 (les séparateurs) décalages
</syntaxhighlight>
Cette technique permet d'avoir des données nulles dans les blocs, mais est plus longue à écrire pour des blocs de grande taille.

=== Copie d'un octet ===
On peut distinguer deux manières de copier le contenu d'un octet dans un autre : en effaçant les données de l'octet initial ou en les conservant. Le premier cas est plus simple, le second requérant une variable intermédiaire.

Pour la copie destructive d'un octet dans l'octet suivant, en supposant que le pointeur est sur l'octet à copier:
<syntaxhighlight lang="bf">
>[-]<  effacer l'octet suivant et revenir sur l'octet initial (facultatif si on sait que l'octet cible est nul)
[->+<] tant qu'il n'est pas nul lui enlever 1 et ajouter un à l'octet suivant
</syntaxhighlight>
Pour une copie conservative d'un octet (pointé au départ) dans l'octet suivant, nous allons utiliser l'octet encore après comme [[variable temporaire]]. Encore une fois, la première ligne est facultative si on sait que les deux octets suivant l'octet à copier sont nuls.
<syntaxhighlight lang="bf">
>[-]>[-]<< on efface les deux octets suivants l'octet à copier puis on revient sur lui

[>+>+<<-] on incrémente les deux octets suivants et on décrémente l'octet à copier jusqu'à ce qu'il soit vide. On a donc réalisé deux copies en le détruisant

>>[-<<+>>] on se place sur la deuxième copie et on la copie destructivement sur le premier octet.
</syntaxhighlight>

=== Instructions conditionnelles ===
<syntaxhighlight lang="bf">
,----------[----------------------.,----------]
</syntaxhighlight>
Ce programme prend un caractère minuscule en entrée et le met en [[majuscule]]. La touche {{touche|Entrée}} arrête la saisie (code 10 en brainfuck dans la plupart des compilateurs).

Au début, on récupère le premier caractère (, ) et on lui soustrait immédiatement 10 (10 fois -). Si l'utilisateur a appuyé sur {{touche|Entrée}}, on a 0 dans l'octet pointé et l'instruction de boucle ([) saute à la fin du programme. Si le caractère entré n'est pas 10, on considère que c'est une lettre minuscule et on entre dans la boucle, où on va lui soustraire le nombre 22 (22 fois -), ce qui va faire 32 en tout, 32 étant la différence numérique entre la lettre minuscule et la même lettre en [[majuscule]] en code ASCII.

Le caractère est affiché, puis un nouveau caractère est récupéré, et à nouveau on lui soustrait 10. Le programme revient alors au début de la boucle : si la touche qu'a validé l'utilisateur est Entrée (10), la boucle s'arrête, sinon elle se poursuit.

==== If ====

Voici un moyen simple d'écrire un bloc « if » en brainfuck :
<syntaxhighlight lang="bf">>[code<]<[>]</syntaxhighlight>

Ce bloc d'instruction nécessite une mémoire de la forme :
<pre>1 0 n
  ^</pre>
Avec le curseur sur le « 0 », il exécute le code « code » si et seulement si <math>n</math> est non nul, avec le curseur sur le « 0 » à l'état final comme initial.

Décomposons ce code en étapes :

">" : on met le pointeur sur n

Si n est égal à 0, la boucle ne s'exécute pas et le pointeur est toujours sur n, on revient alors en arrière ("<", on est alors sur le {{2e}} octet) puis la boucle ne s'exécute pas puisque nous sommes sur le 0 ([>] revient à dire "va sur le premier octet nul en partant de l'octet pointé inclus").

Si n est différent de 0, la boucle s'exécute et le code aussi, le pointeur revient alors sur le {{2e}} octet et la boucle s'arrête, puisque cet octet est égal à 0. Le pointeur est donc sur le {{2e}} octet. On revient ensuite en arrière ("<"), donc sur le premier octet (égal à 1) puis, comme dit, la boucle [>] emmène le pointeur sur le premier octet nul suivant l'octet pointé inclus, or le premier est différent de 0 et le second égal à 0, ce qui amène le pointeur sur le deuxième octet.

Si on a besoin de faire une condition après laquelle le code s'arrête, on peut se contenter de ">[code<]" , puisque la partie "<[>]" sert uniquement à mettre le pointeur, à l'état final, sur le deuxième octet dans les deux cas.

==== If, else ====
Ce bloc d'instruction nécessite une mémoire de la forme :
<pre>
+-+-+-+
|V|C|T| 
+-+-+-+
 ^</pre>
Où V est la variable à tester, C est sa copie et T le témoin du passage dans le bloc if. Dans notre exemple, le pointeur de départ est sur V et celui d'arrivée est sur C. Dans chaque bloc de code (if et else), le pointeur de départ et d'arrivée est sur C. C et T sont nulles après exécution.
<syntaxhighlight lang="bf">
>[-]>[-]<<                   Mise à zero des 2 variables suivantes (facultatif si connues pour être nulles)
[>+>+<<-]                    Double copie de V dans C et T
>>[-<<+>>]<                  Restauration de V à partir de T (T = 0) / retour sur la copie de la variable
 	>[-]+                Initialisation du témoin (T = 1)
        <                    Retour sur la copie de la variable
	[                    Si la copie de la variable = true
		code_if
 	[-]>-<]              Destruction de la copie de la variable / destruction du témoin 
 	>                    Déplacement sur le témoin
 	[<                   Si le block if ne s'est pas exécuté (témoin = 1) / Retour sur la (copie de la) variable
		code_else    
 	>-<]                  Destruction du témoin (dans ce cas (la copie de) la variable est déjà nulle vu que if ne s'est pas exécuté)
                            Retour sur la (copie de la) variable détruite
</syntaxhighlight>
Soit en condensé
<syntaxhighlight lang="bf">
>[-]>[-]<<[>+>+<<-]>>[-<<+>>]>>[-]+<[ code_if [-]>-<]>[< code_else >-]<
</syntaxhighlight>

Une manière plus simple d'exécuter un bloc If, else est la suivante :

Pour exécuter cette structure, la mémoire doit être sous cette forme :
<pre>
0 1 0 n
      ^
</pre>
avec n l'octet à tester.
<syntaxhighlight lang="bf">
[ code_if <]<<[>> code_else <<<]>>>  
</syntaxhighlight>

Les codes « code_if » et « code_else » ne doivent utiliser que les cases à droite de l'octet considéré et revenir à l'octet à la fin de leur
exécution. Soit en totalité :
<syntaxhighlight lang="bf">initialisation variable <<<[-]>[-]+>[-]>[ code_if <]<<[>> code_else <<<]>>></syntaxhighlight>

=== Opérations ===

==== Addition ====

Ce bloc d'instruction nécessite une mémoire de la forme :

<pre>
index      0 1
          +-+-+
Variable  |V|A| 
          +-+-+
</pre>

Où "V" est la variable de base "A" est la variable à additionner. À la fin du programme "A" est détruite et "V" contient le résultat de l'addition.

Ce code ajoute l'octet suivant (en le détruisant, il est donc remis à 0) à l'octet courant.

<syntaxhighlight lang="bf">
++>+++++++++<   index0 = 2 / index1 = 8 /  retour sur index 0

>[-<+>]<        Détruit index1 en l'additionnant avec index0</syntaxhighlight>

ou

<syntaxhighlight lang="bf">
++>++++++++<    index0 = 2 / index1 = 8 / retour sur index 0

>[<+>-]<        Additionne index1 avec index0 en détruisant index1</syntaxhighlight>

Soit index[0] = 2 et index[1] = 8, « > » Se place sur index[1], « [ » débute la boucle, « - » et index[1] = 7, « < » on pointe sur index[0], « + » et index[0] = 3, « > » on pointe sur index[1], « ] » si index[1] != 0 on recommence.
À la fin, on aura bien index[1] = 0 ce qui arrête la boucle, et index[0] = 10.

==== Addition (ASCII) ====
<syntaxhighlight lang="bf">,>++++++[<-------->-],[<+>-]<.</syntaxhighlight>

Ce programme additionne 2 nombres à un seul chiffre et affiche le résultat si celui-ci n'a aussi qu'un seul chiffre :

<code>4+3</code>

<code>7</code>

(Maintenant les choses vont être un peu plus compliquées. Nous allons nous référer aux octets du tableau ainsi : [0], [1], [2], etc.)

Le premier nombre est entré dans [0], et on lui soustrait 48 pour avoir sa valeur décimale (les codes ASCII pour les chiffres 0-9 sont 48-57). Cela est fait en mettant 6 dans [1] et en utilisant une boucle pour soustraire 8 de [0] autant de fois que dans [1], soit 6 × 8 = 48. C'est une méthode plus commode pour ajouter ou soustraire des grands nombres que de mettre 48 fois « - » dans le programme. Le code qui fait cela est :

<syntaxhighlight lang="bf">>++++++[<-------->-]</syntaxhighlight>

<code>>++++++</code> pour mettre 6 dans [1], puis on attaque la boucle, « < » pour revenir sur [0], on soustrait 8, « > » on repasse sur [1], qu'on décrémente et on retourne dans la boucle. La boucle est alors exécutée 6 fois, jusqu'à ce que [1] soit égal à 0.

Ensuite, on récupère le signe + qu'on met dans [1], puis le second chiffre qui écrase le signe +.

La boucle suivante <code>[<+>-]</code> ajoute effectivement le nombre de la seconde cellule dans la première cellule et remet [1] à zéro. À chaque boucle, il ajoute 1 dans [0] et retire 1 de [1] ; ainsi [1] finit par être à 0. Tout ce qui a été ajouté à [0] a été retiré de [1]. Ensuite la touche entrée est mise dans [1].

Puis le pointeur est remis sur [0], qui est affiché ([0] est maintenant a + (b + 48), puisqu'on n'a pas corrigé b ; ce qui est identique à (a + b) + 48, qui est ce que l'on veut). Le pointeur est ensuite déplacé sur [1], qui contient la touche entrée, que l'on affiche. L'exécution est terminée.

==== Soustraction ====

Cette opération nécessite une mémoire de la forme :
<pre>
index      0 1 
          +-+-+
variable  |V|S|
          +-+-+
</pre>
Où "V" est la variable de base "S" est la variable à soustraire. À la fin du programme "S" est détruite et "V" contient le résultat de la soustraction.

<syntaxhighlight lang="bf">
++++++++>++++<   V = 8 / S = 4 /  retour sur V

>[-<->]<        Détruit S et le soustrait a V
</syntaxhighlight>

ou

<syntaxhighlight lang="bf">
++>++++++++<    index0 = 2 / index1 = 8 / retour sur index 0

>[<->-]<        Soustrait S a V en détruisant S
</syntaxhighlight>

Soit V = 8 et S = 4, « > » Se place sur S, « [ » débute la boucle, « - » et S = 3, « < » on pointe sur V, « - » et V = 7, « > » on pointe sur S, « ] » si S != 0 on recommence. À la fin, on aura bien S = 0 ce qui arrête la boucle, et V = 4.

==== Multiplication ====

Cette opération nécessite une mémoire de la forme :
<pre>
index      0 1 2 3 
          +-+-+-+-+
variable  |R|T|O|M|
          +-+-+-+-+
</pre>
Où "R" est le résultat, "T" est une variable temporaire, O est l'opérande et M le multiplicateur. Au début de l’exécution le pointeur est sur R et à la fin de l’exécution le pointeur est sur R.
<syntaxhighlight lang="bf">
                                     Initialisation
[-]                                  R = 0
>[-]                                 T = 0
>[-]+++                              O = 0 / O = 3 (changez ici le nombre d'incrémentation pour modifier le résultat)
>[-]+++++                            M = 0 / M = 5 (changez ici le nombre d'incrémentation pour modifier le résultat)

<                                    Reviens à O
[                                    Tant que O différent de 0
        >                                Passe à M
        [                                Tant que M différent de 0
                <<+                          Reviens à T / Incrémenter T
                <+                           Reviens à R / Incrémenter R
                >>>-                         Passe à M / Décrémenter M
        ]                                Retour boucle
	<<[>>+<<-]		     Reinitialise M / Détruit T	
	>-			     Décrémente O
]                                    Retour boucle
>[-]				     Retourne à M / M = 0
<				     Retourne O déjà = 0
<[-]                                 Retourne à T / T = 0
<                                    Retourne à R
</syntaxhighlight>

Soit en condensé :
<syntaxhighlight lang="bf">
[-]>[-]>[-]+++>[-]+++++<[>[<<+<+>>>-]<<[>>+<<-]>-]>[-]<<[-]<
</syntaxhighlight>

==== Multiplication (ASCII) ====
<syntaxhighlight lang="bf">
,>,>>++++++++++++++++[-<+++<---<--->>>]<<[<[>>+>+<<<-]>>>[<<<+>>>-]<<-]>.
</syntaxhighlight>

Comme le précédent, mais effectue une multiplication basée sur les caractères, pas sur des nombres enregistrés en mémoire.

Le premier nombre est entré dans [0], l'astérisque et le deuxième nombre dans [1] et les 2 nombres sont corrigés en leur soustrayant 48 (note : il y a une boucle de 16 itérations pour soustraire 3 aux deux nombres ainsi qu'ajouter 3 au futur résultat à chaque [[itération]] !).

Ensuite on entre dans la boucle de multiplication principale. L'idée de base est qu'à chaque boucle on soustrait 1 de [1] et on ajoute [0] dans le total cumulé gardé en [2] (3 * 2 = 2 + 2 + 2). En particulier : la première boucle cumule [0] dans [2] et [3], tout en remettant [0] à 0. (C'est la manière la plus simple de dupliquer un nombre.) La deuxième boucle remet [3] dans [0], en remettant à 0 [3]. Puis on décrémente [1] et on est à la fin de la boucle principale. À la sortie de cette boucle, [1] contient 0, [0] contient encore le deuxième nombre, et [2] contient le produit des 2 nombres (pour garder la valeur, il suffit de l'ajouter dans [4] à chaque itération de la boucle principale, puis de déplacer la valeur de [4] dans [1].)

Exemple : 3 * 2
{| class="wikitable"
|-----
| [0] || [1] || [2] || [3]
|-----
| '''3''' || '''2''' || 0 || 0
|-----
| colspan="4" | {{1re}} boucle : <code>>[>+>+<<-]</code>
|-----
| 3 || 1 || 1 || 1
|-----
| 3 || 0 || 2 || 2
|-----
| colspan="4" | {{2e}} boucle : <code>>>[<<+>>-]</code>
|-----
| 3 || 1 || 2 || 1
|-----
| 3 || 2 || 2 || 0
|-----
| colspan="4" | Fin boucle princ : <code><<<-]</code>
|-----
| 2 || 2 || 2 || 0
|-----
| colspan="4" | {{1re}} boucle : <code>>[>+>+<<-]</code>
|-----
| 2 || 1 || 3 || 1
|-----
| 2 || 0 || 4 || 2
|-----
| colspan="4" | {{2e}} boucle : <code>>>[<<+>>-]</code>
|-----
| 2 || 1 || 4 || 1
|-----
| 2 || 2 || 4 || 0
|-----
| colspan="4" | Fin boucle princ : <code><<<-]</code>
|-----
| 1 || 2 || 4 || 0
|-----
| colspan="4" | {{1re}} boucle : <code>>[>+>+<<-]</code>
|-----
| 1 || 1 || 5 || 1
|-----
| 1 || 0 || 6 || 2
|-----
| colspan="4" | {{2e}} boucle : <code>>>[<<+>>-]</code>
|-----
| 1 || 1 || 6 || 1
|-----
| 1 || 2 || 6 || 0
|-----
| colspan="4" | Fin boucle princ : <code><<<-]</code>
|-----
| 0 || 2 || '''6''' || 0
|}

Ensuite, il ne reste plus qu'à ajouter 48 au produit, récupérer la touche entrée dans [3], et afficher le produit en [[ASCII]] et l'entrée qui vient juste d'être stockée.

==== Minimum ====

Cette section présente un code permettant de calculer le minimum de deux entiers, chose plus ardue qu'on pourrait le penser.

Il prend en argument une bande de la forme
<syntaxhighlight lang="bf">
n 1 0 m 0 0 0
</syntaxhighlight>

Avec le curseur sur le <math>n</math>, et renvoie une bande de la forme
<syntaxhighlight lang="bf">
n' 1 0 m' M 0 0
</syntaxhighlight>

Avec le curseur sur le <math>M</math> et <math>M = \min(n, m)</math>, <math>n' = n - M</math> et <math>m' = m - M</math>

<syntaxhighlight lang="bf">
[->>              On commence une boucle sur n
  >[              On teste si m est nulle ou non
    >>>>>+<<<<<   On remplace le 0 de la case juste après M par un 1
    ->+<          On ajoute 1 au minimum tout en enlevant 1 à m
  <]<[>]          Fin du If
  >>>>
  >[              Cette ligne fait un If après le M : ceci revient en fait à un Else du bloc If
    -<<->>>>>>>   On efface le 1 en trop à la fin et on s'éloigne de la bande (ce qui permet de quitter le programme en revenant sur la place du M)
  ]<[>]
  <<<<<<          On revient sur le n (ou sur le 0 après le M sinon)
]
>[>>>>->]<<       Cette ligne permet de se placer sur la case du M que ce soit m ou n le plus petit
</syntaxhighlight>

On peut ensuite ajouter du code de mise en forme.
Ainsi le code suivant prend en argument une bande du type <pre>n m 0 0...</pre> avec un curseur sur le <math>n</math> et renvoie <pre>0 0 0 0 M 0...</pre> avec le curseur sur le <math>M</math>.
Voici le code : (les lignes 2 et 4 sont des lignes de mise en forme, 1 et 5 des entrées sorties)
<syntaxhighlight lang="bf">
,>,
[->>+<<]+<
[->>>[>>>>>+<<<<<->+<<]<[>]>>>>>[-<<->>>>>>>]<[>]<<<<<<]>[>>>>->]<<
<<<<[-]>[-]>>[-]>
.
</syntaxhighlight>

== Macro-définition brainfuck ==
Les [[macro-définition|macros-définitions]] ci-dessous définissent des techniques permettant de retrouver des structures ou des instructions utilisées habituellement en [[algorithmique]] ou dans les [[Programmation|langages de programmation]]. Elles facilitent la création de programmes brainfuck. Il existe des implémentations de brainfuck acceptant la définition de macros.

Les symboles comme <code>a</code>, <code>b</code> ou <code>s</code> représentent chacun un octet différent dans le tableau mémoire. Le symbole <code>t</code> indique un octet utilisé temporairement pour les besoins de la macro. Le symbole <code>s</code> représente un octet utilisé comme source et <code>d</code> un octet utilisé comme destination.

* Déplacement du pointeur

La macro <code>to(a)</code> consiste à déplacer le pointeur dans le tableau mémoire au niveau de l'octet <code>a</code>. Elle s'obtient avec une série de <code>&lt;</code> ou de <code>&gt;</code>.

* Ajout d'une constante
La macro <code>addCst(n)</code> ajoute à l'octet pointé la valeur ''n''. Elle s'obtient avec une série de <code>+</code> ou de <code>-</code> selon le signe de ''n''.
* Mise à zéro d'un octet
:{{Code|zero(m): to(m) [-]}}
* Déplacer un octet
:{{Code|move(s d): to(s) [- to(d)+ to(s)]}}
* Déplacer un octet vers deux autres octets
:{{Code|move2(s d1 d2): to(s) [- to(d1)+ to(d2)+ to(s)]}}
* Copie d'un octet vers un autre
:{{Code|copy(s d t): move2(s d t) move(t s)}}
* Structure conditionnelle simple
:{{Code|if(a)   : to(a) [}}
:{{Code|endif(a): zero(a) <nowiki>]</nowiki>}}
* Structure conditionnelle avec alternative
:{{Code|ifelse(a t): to(t)+ to(a) [ to(t)-}}
:{{Code|else(a t)  : zero(a) <nowiki>]</nowiki> to(t) [}}
:{{Code|endelse(t) : to(t)- <nowiki>]</nowiki>}}
* Structure répétitive
:{{Code|for(s) : to(s) [}}
:{{Code|next(s): to(s)- <nowiki>]</nowiki>}}
* Échange de deux octets
:{{Code|swap(a b t): move(a t) move(b a) move(t b)}}

== Commentaire ==
On peut noter que, dans la version initiale, comme chaque cellule du tableau est un octet, l'instruction « - » est superflue et peut être remplacée par 255 « + ». De la même manière, les {{formatnum:30000}} cellules formant un tableau circulaire, « < » peut-être remplacé par {{formatnum:29999}} « > ». Cela réduirait le langage à six instructions.

Cependant, la taille du tableau, la taille des cellules et les possibilités de "wrapping" (i.e. que faire > sur la dernière case ramène à la première ou que + sur un octet plein le met à 0) ne font pas partie des spécifications du langage et sont laissées à la liberté des compilateurs. Ainsi, cette réduction à six instructions n'est pas toujours possible. Quand bien même, jouer sur le wrapping peut nuire à la portabilité du langage.

La seule contrainte imposée par le concepteur du langage est au moins {{formatnum:30000}} cellules et au moins un octet par cellule. Certaines implémentations proposent deux, quatre ou huit octets par cellule, voire aucune limitation !

== Variantes ==
Brainfuck a de nombreux descendants. La plupart se contentent de rendre le code encore plus inextricable (par exemple [https://web.archive.org/web/20050318095341/http://www.chilliwilli.co.uk/ff/ f*ckf*ck], le
[http://esoteric.voxelperfect.net/wiki/Pi langage Pi], ou bien ''Ook!'' décrit ci-dessous) ; d'autres ajoutent de réelles fonctionnalités.

=== Ook! ===
Le langage '''Ook''' est une variante de brainfuck. C'est un langage [[Turing-complet]], conçu pour être parfaitement lisible par un [[orang-outan]], en référence au personnage du [[Le bibliothécaire (Disque-monde)|bibliothécaire]] de l'univers du [[Disque-monde]] de [[Terry Pratchett]].

{| class="wikitable"
|-
! Ook !! Brainfuck !! Signification
|-
| Ook. Ook? || > || incrémente (augmente de 1) le pointeur.
|-
| Ook? Ook. || < || décrémente (diminue de 1) le pointeur.
|-
| Ook. Ook. || + || incrémente l'octet du tableau sur lequel est positionné le pointeur (l'octet pointé).
|-
| Ook! Ook! || - || décrémente l'octet pointé.
|-
| Ook! Ook. || . || sortie de l'octet pointé (valeur ASCII).
|-
| Ook. Ook! ||, || entrée d'un octet dans le tableau à l'endroit où est positionné le pointeur (valeur ASCII).
|-
| Ook! Ook? || [ || saute à l'instruction après le Ook? Ook! correspondant si l'octet pointé est à 0.
|-
| Ook? Ook! || ] || retourne à l'instruction après le Ook! Ook? si l'octet pointé est différent de 0.
|-
| Ook? Ook? ||   || fin du programme.
|}

'''Hello World!''' en Ook :
<syntaxhighlight lang="text">
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook?
</syntaxhighlight>

=== Spoon ===
Le langage '''spoon''' est équivalent au langage brainfuck mais avec des mots constitués de 0 et 1, utilisant un [[codage de Huffman]].

{| class="wikitable"
|-
! Spoon !! Brainfuck !! Signification
|-
| 010 || > || incrémente (augmente de 1) le pointeur.
|-
| 011 || < || décrémente (diminue de 1) le pointeur.
|-
| 1 || + || incrémente l'octet du tableau sur lequel est positionné le pointeur (l'octet pointé).
|-
| 000 || - || décrémente l'octet pointé.
|-
| 0010110 ||, || entrée d'un octet dans le tableau à l'endroit où est positionné le pointeur (valeur ASCII).
|-
| 001010 || . || sortie de l'octet pointé (valeur ASCII).
|-
| 00100 || [ || saute à l'instruction après le 0011 correspondant si l'octet pointé est à 0.
|-
| 0011 || ] || retourne à l'instruction après le 00100 si l'octet pointé est différent de 0.
|}

De plus, il possède deux instructions supplémentaires non disponibles dans le langage brainfuck :

{| class="wikitable"
|-
! Spoon !! Signification
|-
| 00101110 || sortie de tout le tableau mémoire.
|-
| 00101111 || fin immédiate du programme.
|}

'''Hello world''' en spoon :
<syntaxhighlight lang="text">
1 1 1 1 1 1 1 1 1 1 00100 010 1 1 1 1 1 1 1 010 1 1 1 1 1 1 1 1 1 1 010 1 1 1 010 1 011 011 011 011 000 0011 010 1 1 001010 010 1 001010 1 1 1 1 1 1 1 001010 001010 1 1 1 001010 010 1 1 001010 011 011 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 001010 010 001010 1 1 1 001010 000 000 000 000 000 000 001010 000 000 000 000 000 000 000 000 001010 010 1 001010 010 001010
</syntaxhighlight>

Les espaces peuvent être supprimés :

'''Hello world''' en spoon (sans espace)
<syntaxhighlight lang="text">
11111111110010001011111110101111111111010111010101101101101100000110101100101001010010101111111001010001010111001010010110010100110111111111111111110010100100010101110010100000000000000000000010100000000000000000000000000010100101001010010001010
</syntaxhighlight>

Cela fait bien entendu référence à un [[fichier binaire]] (exécutable).

=== SegFaultProg ===
Le langage '''Segfaultprog''' est une variante du brainfuck, enrichie, extensible, destinée à être exécutée en machine virtuelle, sur de petites architectures ([[Atmel AVR|AVR]], [[Microcontrôleur PIC|PIC]], [[Architecture MIPS|MIPS]]...). Son développement a débuté en {{date-|mai 2010}}. Ce langage propose une simplification de la syntaxe du brainfuck (par exemple, avec l'adressage direct, et en évitant les répétitions), et rétro-compatibilité avec celui-ci. 

'''Hello world''' en SegFaultProg V1
<syntaxhighlight lang="text">
*A+H.[-]+e.+7..+3.*B+32.*A+8.-8.+3.[-]+d.
</syntaxhighlight>

'''Hello World''' en SegFaultProg V2
<syntaxhighlight lang="text">
*$0x00$+cH.-$3$.+$7$..>+&+$0x03$.>+c .>+$0x57$.<<.+$3$.<.-$0x08$.
</syntaxhighlight>

=== Whitespace ===
{{Article détaillé|Whitespace}}
Le langage '''Whitespace''' est équivalent au brainfuck mais n'utilise en tant qu'instructions que des tabulations, des espaces et des retours à la ligne, afin de générer un programme dont le code est invisible.


Hello World en Whitespace (lien):

https://github.com/rdebath/whitespace/blob/master/tests/rdebath/helloworld.ws

== Notes et références ==
{{références}}

== Voir aussi ==
{{Autres projets|wikibooks=Programmation Brainfuck}}

=== Articles connexes ===
* [[Langage de programmation exotique]]
* [[Turing-complet]]

=== Liens externes ===
* {{en}} [http://esoteric.sange.fi/brainfuck/impl/interp/i.html Interpréteur brainfuck]
* {{en}} [http://copy.sh/brainfuck/ Un autre interpréteur brainfuck]
* {{en}} [http://www.iamcal.com/misc/bf_debug/ Encore un autre interpréteur brainfuck]
* {{en}} [http://www.bf.doleczek.pl/ Brainfuck] un interpréteur en-ligne en [[JavaScript]] avec une collection de programmes
* {{fr}} [http://fayedu39.1s.fr/brainfuck/spoon2.php Interpréteur Spoon]

{{Palette|Langage de programmation exotique}}
{{Portail|programmation informatique}}

[[Catégorie:Langage de programmation exotique]]