Brainfuck — Wikipédia

Ne doit pas être confondu avec Mindfuck.

Brainfuck
Programme "Hello World!" en brainfuck
Date de première version	1993
Auteur	Urban Müller
Influencé par	P′′ (en) FALSE (d)
A influencé	Ook, Whitespace, Spoon, SegFaultProg
Site web	brainfuck.org
Extension de fichier	b et bf
modifier

Brainfuck est un langage de programmation exotique, inventé par Urban Müller en 1993. Il tire son nom de l’union de deux mots anglais, brain (« cerveau ») et 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.

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 octets, la version actuelle se contentant de 171 octets. Le brainfuck est pourtant un langage Turing-complet^[1], 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.

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, 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.

Les huit instructions du langage, chacune codée par un seul caractère, sont les suivantes :

(Alternativement, ] peut être défini par « retourne au [ 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 : [ signifie « saute à l'instruction ] correspondante », et ] signifie « retourne à l'instruction après le [ 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 ptr est du type unsigned char* :

Lien pour traducteur:

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

Lien pour explication:

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

Les différents interpréteurs de brainfuck gèrent les entrées différemment. Prenons pour exemple le programme suivant :

,[>,]        ',' : 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. 

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.]

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,...].

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

Le programme suivant affiche le traditionnel « Hello World! » et une nouvelle ligne à l'écran :

++++++++++          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) 

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 +-<>[],.. Le code effectivement compilé peut donc se réduire à la ligne suivante :

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

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

La ligne suivante déplace le pointeur vers a[2] et l'incrémente de 1, le résultat, 101, 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 (+++++++) à a[2] et l'afficher deux fois.

'o' est la troisième lettre de l'alphabet après 'l', on incrémente donc a[2] 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.

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

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.^{[non pertinent]}

,     ciblage de l’octet [     boucle  -     enlever 1 à la case courante  ]     jusqu'à ce que la case soit à zéro 

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

,  saisit un caractère de la ligne de commande dans la case courante .  imprime le caractère correspondant à la valeur de la case courante 

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

[,.] ou ,[.,] 

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).

• Enregistrer une chaîne de caractères

 ,[.>,] 

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 :

 0P- - - -00- - - -00- - - -00- - - -00- - - ... avec les blocs - - - - numérotés de 1 à n 

Alors nous pouvons nous déplacer de bloc en bloc de la manière suivante (avec le pointeur initialement sur P ) :

[-[-[>]>+<<[<]>]] 

Par exemple, si P=3, à chaque exécution de la boucle principale, la mémoire sera organisée de cette façon :

 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 

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) :

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 

Cette technique permet d'avoir des données nulles dans les blocs, mais est plus longue à écrire pour des blocs de grande taille.

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:

>[-]<  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 

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.

>[-]>[-]<< 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. 

,----------[----------------------.,----------] 

Ce programme prend un caractère minuscule en entrée et le met en majuscule. La 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 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.

Voici un moyen simple d'écrire un bloc « if » en brainfuck :

>[code<]<[>] 

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

1 0 n   ^

Avec le curseur sur le « 0 », il exécute le code « code » si et seulement si ${\displaystyle n}$ 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 2^e 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 2^e octet et la boucle s'arrête, puisque cet octet est égal à 0. Le pointeur est donc sur le 2^e 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.

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

+-+-+-+ |V|C|T|  +-+-+-+  ^

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.

>[-]>[-]<<                   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 

Soit en condensé

>[-]>[-]<<[>+>+<<-]>>[-<<+>>]>>[-]+<[ code_if [-]>-<]>[< code_else >-]< 

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 :

0 1 0 n       ^ 

avec n l'octet à tester.

[ code_if <]<<[>> code_else <<<]>>> 

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é :

initialisation variable <<<[-]>[-]+>[-]>[ code_if <]<<[>> code_else <<<]>>> 

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

index      0 1           +-+-+ Variable  |V|A|            +-+-+ 

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.

++>+++++++++<   index0 = 2 / index1 = 8 /  retour sur index 0  >[-<+>]<        Détruit index1 en l'additionnant avec index0 

ou

++>++++++++<    index0 = 2 / index1 = 8 / retour sur index 0  >[<+>-]<        Additionne index1 avec index0 en détruisant index1 

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.

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

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

4+3

7

(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 :

>++++++[<-------->-] 

>++++++ 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 [<+>-] 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.

Cette opération nécessite une mémoire de la forme :

index      0 1            +-+-+ variable  |V|S|           +-+-+ 

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.

++++++++>++++<   V = 8 / S = 4 /  retour sur V  >[-<->]<        Détruit S et le soustrait a V 

ou

++>++++++++<    index0 = 2 / index1 = 8 / retour sur index 0  >[<->-]<        Soustrait S a V en détruisant S 

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.

Cette opération nécessite une mémoire de la forme :

index      0 1 2 3            +-+-+-+-+ variable  |R|T|O|M|           +-+-+-+-+ 

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.

                                     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 

Soit en condensé :

[-]>[-]>[-]+++>[-]+++++<[>[<<+<+>>>-]<<[>>+<<-]>-]>[-]<<[-]< 

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

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

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.

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

n 1 0 m 0 0 0 

Avec le curseur sur le ${\displaystyle n}$, et renvoie une bande de la forme

n' 1 0 m' M 0 0 

Avec le curseur sur le ${\displaystyle M}$ et ${\displaystyle M=\min(n,m)}$, ${\displaystyle n'=n-M}$ et ${\displaystyle m'=m-M}$

[->>              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 

On peut ensuite ajouter du code de mise en forme.

Ainsi le code suivant prend en argument une bande du type

n m 0 0...

avec un curseur sur le ${\displaystyle n}$ et renvoie

0 0 0 0 M 0...

avec le curseur sur le ${\displaystyle M}$.

Voici le code : (les lignes 2 et 4 sont des lignes de mise en forme, 1 et 5 des entrées sorties)

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

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

• Déplacement du pointeur

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

• Ajout d'une constante

La macro addCst(n) ajoute à l'octet pointé la valeur n. Elle s'obtient avec une série de + ou de - selon le signe de n.

• Mise à zéro d'un octet

zero(m): to(m) [-]

• Déplacer un octet

move(s d): to(s) [- to(d)+ to(s)]

• Déplacer un octet vers deux autres octets

move2(s d1 d2): to(s) [- to(d1)+ to(d2)+ to(s)]

• Copie d'un octet vers un autre

copy(s d t): move2(s d t) move(t s)

• Structure conditionnelle simple

if(a)  : to(a) [

endif(a): zero(a) ]

• Structure conditionnelle avec alternative

ifelse(a t): to(t)+ to(a) [ to(t)-

else(a t)  : zero(a) ] to(t) [

endelse(t) : to(t)- ]

• Structure répétitive

for(s) : to(s) [

next(s): to(s)- ]

• Échange de deux octets

swap(a b t): move(a t) move(b a) move(t b)

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 30 000 cellules formant un tableau circulaire, « < » peut-être remplacé par 29 999 « > ». 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 30 000 cellules et au moins un octet par cellule. Certaines implémentations proposent deux, quatre ou huit octets par cellule, voire aucune limitation !

Brainfuck a de nombreux descendants. La plupart se contentent de rendre le code encore plus inextricable (par exemple f*ckf*ck, le langage Pi, ou bien Ook! décrit ci-dessous) ; d'autres ajoutent de réelles fonctionnalités.

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 bibliothécaire de l'univers du Disque-monde de Terry Pratchett.

Hello World! en 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? Ook? 

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

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

Hello world en spoon :

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 

Les espaces peuvent être supprimés :

Hello world en spoon (sans espace)

11111111110010001011111110101111111111010111010101101101101100000110101100101001010010101111111001010001010111001010010110010100110111111111111111110010100100010101110010100000000000000000000010100000000000000000000000000010100101001010010001010 

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

Le langage Segfaultprog est une variante du brainfuck, enrichie, extensible, destinée à être exécutée en machine virtuelle, sur de petites architectures (AVR, PIC, MIPS...). Son développement a débuté en 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

*A+H.[-]+e.+7..+3.*B+32.*A+8.-8.+3.[-]+d. 

Hello World en SegFaultProg V2

*$0x00$+cH.-$3$.+$7$..>+&+$0x03$.>+c .>+$0x57$.<<.+$3$.<.-$0x08$. 

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

• Langage de programmation exotique
• Turing-complet

• (en) Interpréteur brainfuck
• (en) Un autre interpréteur brainfuck
• (en) Encore un autre interpréteur brainfuck
• (en) Brainfuck un interpréteur en-ligne en JavaScript avec une collection de programmes
• (fr) Interpréteur Spoon

v · m Langages de programmation exotiques
Beatnik (en) Befunge Brainfuck FRACTRAN HQ9+ INTERCAL Iota JSFuck (en) Leet (en) LOLCODE Malbolge Ordinateur à jeu d'instruction unique Piet Shakespeare Programming Language SNUSP Thue Unlambda Whitespace
Langage de programmation Turing tarpit

• Portail de la programmation informatique