Tutoriel S'amuser avec le BrainFuck

[wigycs]

(Remarque juste après avoir écris tout ça : je viens de voir qu'un sujet/tuto un peu semblable existe déjà - ici -, désolé :/)

Bonjour, je suis nouveau sur le forum et je souhaites vous faire partager le "plaisir" du développement en BrainFuck, qui, comme son nom l'indique, consiste en une sorte de masturbation intellectuelle.

Donc voilà un bref tutoriel sur le BrainFuck.

Quel est l'utilité du BrainFuck ?
Le BrainFuck, aussi abrégé BF, n'a pas vraiment d'utilité propre, c'est plutôt un divertissement, très étrange je vous l'accorde, un moyen de se lancer des petits challenges.

Qu'est-ce que le BrainFuck ?
Le BrainFuck, c'est un langage de programmation pour le moins minimaliste. En effet, lorsqu'on développe en BF, on ne dispose que d'un nombre très limité d'instructions.
Il n'existe en effet que huit instructions, soit beaucoup moins que les différentes instructions possible sur un processeur moderne...

Théoriquement, on est censé pouvoir écrire n'importe quel programme en brainfuck, en effet, celui-ci est dit "turing complet".

Principe du BrainFuck
L’environnement du brainfuck nous fournit deux éléments simple pour stoker de l'information : une bande et un pointeur.

------------------------------------------------------------------
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
----------------------/^\---------------------------------------


La bande est constituée, comme vous pouvez le voir, d'un ensemble de valeurs, 0 par défaut.
Il est possible de déplacer le pointeur vers la droite ou vers la gauche, de case en case.

Instructions BF

• > : Déplace le pointeur d'une case vers la droite
• < : Déplace le pointeur d'une case vers la gauche
• + : Augmente de 1 la valeur de la case pointé par... le pointeur
• - : Soustrait de 1 la valeur de la case pointé par le pointeur
• ? : Demande à l'utilisateur une valeur puis écrase la case pointé avec la nouvelle valeur
• . : Affiche la valeur de la case pointée.

En réalité, dans le "vrai" BF, l'instruction "." affiche le caractère correspondant à la valeur de la case pointée en se référant au code ASCII.

Aussi, il existe deux autres instructions :

• [
• ]

Ces instructions sont fondamentales : elle permettent de faire des boucles conditionnelles en BF.

Lorsque l'ordinateur croise dans le code BrainFuck l'instruction "[", alors il regarde la valeur de la case pointée :

• Si celle-ci vaut 0, alors il saute jusqu'à la fin de la boucle, soit jusqu'à "]"
• Si celle-ci est différente de 0, alors il continue la lecture du code, puis, lorsqu'il croise l’instruction "]", il revient à l'instruction "[".

En gros, tant que la valeur de la case pointée est différente de zéro, ce qui est entre crochets se répétera.

Voilà, vous savez tout sur le BrainFuck. Toutefois, pour réaliser réellement un programme plus aisément, je vais vous donner quelques briques supplémentaires.

Copier des données
Il vous arrivera souvent d'avoir à copier une case vers une ou plusieurs autres.
Vous ne disposez toute fois d'aucune commande du type "COPY". Vous n'avez que +-><[] pour manipuler des nombres...
En fait, nous allons utiliser une petite astuce, nous allons utiliser les crochets. Par exemple pour copier la valeur une case dans les deux suivante :

N°	Opération	Instruction BF	Position pointeur
1	Tant que la case est différente de 0	[	Case n°1
2	Soustraire de 1 la case pointée	-	Case n°1
3	Se déplacer vers la droite	>	Case n°2
4	Ajouter 1 à la case pointée	+	Case n°2
5	Se déplacer vers la droite	>	Case n°3
6	Ajouter 1 à la case pointée	+	Case n°3
7	Revenir à la première position	<<	Case n°1
8	Fin de la boucle	]	Case n°1

En résumé, le code : [>+>+<<]

Additionner
Pour additionner, la logique est strictement identique à celle de la copie : on copie en fait une case non nulle sur une case non nulle par incrémentation (addition de 1, avec l'instruction "+") ce qui produit en somme une addition.

S'entrainer

Pour vous entrainer au BF, je vous conseille d'utiliser un petit script de ma conception (HTML/JS) qui aide à la compréhension du BF puisqu’il permet de visualiser la bande mémoire et le pointeur pendant l’exécution du code.

(Attention, ce script n'a aucunement pour objectif les performances lors de l’exécution du code BF, aussi il a été codé plutôt rapidement...)

Télécharger : http://dl.free.fr/v7ALNq9rB

Exemple de programme : la suite de Fibonacci
Ce programme BF ne fonctionne pas sur un interpréteur affichant le caractère ASCII correspondant à la valeur d'une case lorsque l'on utilise l'instruction ".". Cela ne respecte pas donc le "vrai" BF.

Code :

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

Très brève explication :

[_C_|_a'_|_a_|_a"_|_b_|_b'_]

C : nombre itérations
a : Nombre 1
b : Nombre 2
(Pour tout x) x' ou x'' : copie(s) de x


Voilà pour ce rapide tutoriel inutile

(Et désolé pour les éventuelles erreur / fautes / imprécisions !)

[Yarflam]

Génial ta petite application HTML !
Merci.

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

[wigycs]

Merci pour ton commentaire !
Par contre, mon truc en HTML, c'est vraiment pas très optimisé hein, faut pas regarder le code ^^
(C'est pas que ce soit le foutoir, non, pas du tout ^^)

Magnifique code BrainFuck

[Yarflam]

Ouai bof
Je suis en train de chercher pour compter en binaire.
http://www.google.com/doodles/alan-t...100th-birthday

Edit: J'ai réussi à créer un compteur en décimal "+[.+]". Mais un compteur en binaire qu'en on ne peut pas savoir la valeur existante, ça semble impossible.
Par exemple 1000 si on écrit [>] ça ne permet pas de retrouver le dernier chiffre. J'avais penser à mettre 1 pour 0 et 2 pour 1. Pas moyen, j'avais un 0 en plein milieu de ma ligne. Je lance le défi !

Edit: Ah un truc rigolo

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

[wigycs]

Ah c'est génial le petit "+[[+>]+[<]>]", je trouve ^^

En effet, ça m'a l'air assez chaud Oo
Vais tenter de relever ce défi
A celui qui y arrive en premier !

Comme quoi, le BrainFuck, c'est vraiment très intéressant

[wigycs]

Trouvé ! :P

Je pensais pas x)

Voilà mon code, lourd et moche, mais qui compte en binaire, et génère un résultat qui, normalement, marche avec n'importe quel interpréteur conventionnel :

+++++[->>>>>[>>>>>]+>+>>a>n<<<[<<<<<]<] >>>>> [>>>>>] <   set p0
<<< SE PLACE SUR 2nd 1 courant >>+<< [> go p0
    
    >[<>a[-<<<<<<]<[>]>]< >+<
    
 <[>>>>> revient au tout début ]<<<<<go p0 < [<<<<<]>>>>>[>>>

AFFICHE ASCII

a[-<+>>+<] copie dans 0 et n < reviens sur 0 et copie sur a [->+<]> reviens sur a > n
++++++++++++++++++++++++++++++++++++++++++++++++.[-] <


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

C'est très esthétique x)

Edit : Je viens de tester avec BFDev, ça marche très bien. Et le programme se termine en une faction de seconde

Edit2 : Après un petit moment de réflexion, je me suis dis que plus court, ce serait quand même pas du luxe. Nouvelle version, complétement différente de l'autre :

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

Edit3 : Le même mais qui s'arrête à un moment donné :

++>>>>>>> >>++ >  
Valeur compteur ici (à 10 par defaut) ++++++++++
  [<< +[-<]+ --[++>--]++ << --[++<--]++ >> --[++
<++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------>
>--]
++++++++++++++++++++++++++++++++.[-]++
>-]

[Yarflam]

Félicitation !!!
Utiliser les caractères ASCII est une très bonne idée.

J'ai bien rigolé en lisant la définition sur Wikipédia :

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.