Brainfuck — Wikipédia

Wiki Loves Monuments : photographiez un monument historique, aidez Wikipédia et gagnez !

# Brainfuck

Un article de Wikipédia, l'encyclopédie libre.

Brainfuck est un langage de programmation minimaliste, inventé par Urban Müller en 1993. Il tire son nom de l’union de deux mots anglais, brain (« cerveau ») et fuck (« baiser »), allusion transparente à l'expression « masturbation intellectuelle ». 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[ modifier | modifier le code]

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, comme son nom ne le suggère peut-être pas pour un non-anglophone, le langage brainfuck produit des programmes 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.

## Instructions[ modifier | modifier le code]

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

Caract. | Signification
--- | ---
``>​`` | incrémente (augmente de 1) le pointeur.
``<​`` | décrémente (diminue de 1) le pointeur.
``+​`` | incrémente l'octet du tableau sur lequel est positionné le pointeur (l'octet pointé).
``-​`` | décrémente l'octet pointé.
``.​`` | sortie de l'octet pointé (valeur ASCII).
``,​`` | entrée d'un octet dans le tableau à l'endroit où est positionné le pointeur (valeur ASCII).
``[​`` | saute à l'instruction après le ] correspondant si l'octet pointé est à 0.
``]​`` | retourne à l'instruction après le [ si l'octet pointé est différent de 0.

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

Brainfuck | C
--- | ---
``>​`` | ``ptr++;​``
``< ​`` | ``ptr--;​``
``+​`` | ``(*ptr)++;​``
``-​`` | ``(*ptr)--;​``
``.​`` | ``putchar(*ptr);​``
``,​`` | ``(*ptr) = getchar();​``
``[​`` | ``while(*ptr) {​``
``]​`` | `}`

## Exemples[ modifier | modifier le code]

### Hello World![ modifier | modifier le code]

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

    ++++++++++
    [                   Boucle initiale qui affecte des valeurs utiles au tableau
       >+++++++>++++++++++>+++>+<<<<-
    ]
                        à la sortie de la boucle le tableau contient:
    >++.                      'H'    = 72  (70  plus 2)
    >+.                       'e'    = 101 (100 plus 1)
    +++++++.                  'l'    = 108 (101 plus 7)
    .                         'l'    = 108
    +++.                      'o'    = 111 (108 plus 3)
    >++.                      espace = 32  (30  plus 2)
    <<+++++++++++++++.        'W'    = 87  (72  plus 15)
    >.                        'o'    = 111
    +++.                      'r'    = 114 (111 plus  3)
    ------.                   'l'    = 108 (114 moins 6)
    --------.                 'd'    = 100 (108 moins 8)
    >+.                       '!'    = 33  (32  plus  1)
    >.                        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.

### Remise à zéro de l'octet pointé[ modifier | modifier le code]

    [-]

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

### Entrée/Sortie d'un caractère[ modifier | modifier le code]

    ,.

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

### Boucle simple[ modifier | modifier le code]

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

### Manipulation de pointeur[ modifier | modifier le code]

- Enregistrer une chaine 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, xxxx un bloc de données quelconques non nulle, et 0 un octet dont la valeur est nulle, si la mémoire est organisée de la manière suivante :

     0Pxxxx00xxxx00xxxx00xxxx00xxx ... avec les blocs xxxx 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 :

    0Pxxxx00xxxx00xxxx00xxxx00xxx ... Avec P = 3
    00xxxx0Pxxxx00xxxx00xxxx00xxx ... Avec P = 2
    00xxxx00xxxx0Pxxxx00xxxx00xxx ... Avec P = 1
    00xxxx00xxxx00xxxx0Pxxxx00xxx ... Avec P =

Arrivée à ce point, la boucle s'arrête, et nous sommes arrivé sur le bloc pointé. Cette technique permet de manipuler des blocs de tailles quelconques, à conditions 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) :

    0Pxxxx00xxxx00xxxx00xxxx00xxx ... avec les blocs xxxx 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és nulles dans les blocs, mais est plus longue à écrire pour des blocs de grandes tailles.

### Copie d'un octet[ modifier | modifier le code]

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.

### Instructions conditionnelles[ modifier | modifier le code]

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

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.

#### If[ modifier | modifier le code]

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

    >[code<]<[>]

Ce bloc d'instruction prend 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 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[ modifier | modifier le code]

    >[-]>[-]<<                   Mise à zero des 2 variables suivantes (facultatif si connues pour être nulles)
    [>+>+<<-]                    Double copie
    >>[-<<+>>]<                  Restauration de la variable initiale / retour sur la copie de la variable
     	>[-]+                Initialisation du témoin
            <                    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)
    <                            Retour sur la (copie de la) variable détruite

Soit en condensé

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

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

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

Ou 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 block 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.

### Opérations[ modifier | modifier le code]

#### Addition[ modifier | modifier le code]

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

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

Ou "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 1

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

ou

    ++>++++++++<    index0 = 2 / index1 = 8 / retour sur index 1

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

#### Addition (ASCII)[ modifier | modifier le code]

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

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.

#### Soustraction[ modifier | modifier le code]

Cette opération prend une mémoire de la forme :

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

Ou "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 1

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

#### Multiplication[ modifier | modifier le code]

Cette opération prend 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é :

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

#### Multiplication (ASCII)[ modifier | modifier le code]

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

Comme le précédent, mais effectue une multiplication, pas une addition.

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

[0] | [1] | [2] | [3]
3 | 2 | 0 | 0
1re boucle : `>[>+>+<<-]`
3 | 1 | 1 | 1
3 | 0 | 2 | 2
2e boucle : `>>[<<+>>-]`
3 | 1 | 2 | 1
3 | 2 | 2 | 0
Fin boucle princ : `<<<-]`
2 | 2 | 2 | 0
1re boucle : `>[>+>+<<-]`
2 | 1 | 3 | 1
2 | 0 | 4 | 2
2e boucle : `>>[<<+>>-]`
2 | 1 | 4 | 1
2 | 2 | 4 | 0
Fin boucle princ : `<<<-]`
1 | 2 | 4 | 0
1re boucle : `>[>+>+<<-]`
1 | 1 | 5 | 1
1 | 0 | 6 | 2
2e boucle : `>>[<<+>>-]`
1 | 1 | 6 | 1
1 | 2 | 6 | 0
Fin boucle princ : `<<<-]`
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[ modifier | modifier le code]

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

Il prend en argument une bande de la forme

    n 1 0 m 0 0 0

Avec le curseur sur le , et renvoie une bande de la forme

    n' 1 0 m' M 0 0

Avec le curseur sur le et , et

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

    0 0 0 0 M 0 ...

avec le curseur sur le .

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

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

## Macro-définition Brainfuck[ modifier | modifier le code]

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)​``

## Commentaire[ modifier | modifier le code]

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, il peut nuire à la portabilité de jouer sur le wrapping.

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!

## Variantes[ modifier | modifier le code]

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.

### Ook![ modifier | modifier le code]

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.

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 :

Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook?

### Spoon[ modifier | modifier le code]

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

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 :

Spoon | Signification
--- | ---
00101110 | sortie de tout le tableau mémoire.
00101111 | fin immédiate du programme.

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

On peut trouver un intérpreteur spoon ici : http://fayedu39.1s.fr/brainfuck/spoon2.php

### SegFaultProg[ modifier | modifier le code]

Le langage Segfaultprog est une variante du brainfuck conçue par Gery DUBIEF, 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. Le projet SegFaultProg (qui définit la syntaxe et les normes du langage) développe actuellement la version 2 du langage.

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

## Notes et références[ modifier | modifier le code]

1. ↑ (en) Preuve de la Turing-complétude de Brainfuck en anglais [archive]

## Voir aussi[ modifier | modifier le code]

### Liens externes[ modifier | modifier le code]

- (en) Brainfuck sur le wiki des langages exotiques
- (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 des programmes

- Portail de la programmation informatique

Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Brainfuck&oldid=116906002 ».
Catégorie :

- Langage de programmation exotique

| [+]
Catégories cachées :

- Portail:Programmation informatique/Articles liés
- Portail:Informatique/Articles liés