[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
Explications :
Notations:
Trois "variables" sont stockées sous forme de tableau de leur chiffres : A, B, C.
Le i eme chiffre de la variable X est note X_i
La k eme case à droite du chiffre X_i est notée X_i^k
Pour des raisons pratiques, m est utilisé pour dénoter - et p pour +.
Dans le code @X_i^k indique qu'a cette position le pointeur est en X_i^k
La constante D est le nombre de case entre deux chiffres d'une même variable (i.e. 11)
Quand la position du pointeur dans le code n'est pas constante, i ou j est utilise.
Le nombre de chiffre dans A est a, dans B, b et dans C, c.
Les minuscules sont aussi utilisée pour désigner un chiffre de A, B ou C.
Remarquez que A_a est fixe mais A_0 ne l'est pas (il est shift de D cases sur la droite a chaque fois que le nombre perd un chiffre, idem pour B et C).
Parfois la mémoire autour du pointeur est donnée, dans quel cas un * indique la position actuelle du pointeur.
L'algorithme est divisé en:
Setup :
- Centering : Shift du pointer sur la droite histoire de pouvoir pointer sur A_m1^mx (avec x<d) par la suite
- Reading : Lecture de A, puis B
- Copying : Copie de B en C
GCD : A=pgcd(A, B) et B=0
- Check B : Test si B est nul
- Check A gt b : Test si A>B
- Substracting B : si A>B
- Raw sub B : pour chaque nombre B_i on fait A_i-=B_i
- Normalisation A : pour chaque nombre A_i on fait remonter les retenues
- Substracting A : sinon
- Raw sub A : pour chaque nombre A_i on fait B_i-=A_i
- Normalisation B : pour chaque nombre B_i on fait remonter les retenues
Division : B=C/A
- Increment B
- Substracting A :
- Raw sub A : pour chaque nombre A_i on fait C_i-=A_i
- Normalisation C : pour chaque nombre C_i on fait remonter les retenues
Output :
- Display B
- Mort par intoxication au brainfuck
La mémoire est divise en 3 variables, dans l'ordre A, B et C.
Chaque variable est divise en un nombre variable de bloc (avec un bloc par chiffre)
Les variables sont séparées par au moins un bloc vide (au début, elles ne sont séparées que par un bloc,
mais des 0 apparaissent ou disparaissent en début de chaque nombre au fur et a mesure (après soustraction ou addition))
Chaque bloc est divise en un nombre D de cases.
On peut voir X_i comme le centre d'un bloc, mais en fait X_i^k peut être utilise par X_ip1^kmD dans une autre partie de l'algorithme.
Chaque chiffre X_i a un 1 a sa gauche (en X_i^m1) ce qui permet de naviguer en fin de nombre (avec [>>>>>>>>>>>]) ou entre nombre (avec -[+>>>>>>>>>>>-]+).
Finalement, une méthode simple aurait été de séparer A_0, B_0 et C_0 de D*10 blocs, pour faire A_i-=B_i il suffirait de mettre D*10*2 signes > et <
c'est a dire plus d'une centaine, mais ça ne serait pas joli pas vrai ? Au lieu j'utilise des indices que je suis oblige de trainer avec moi en permanence,
c'est plutôt tordu, mais c'est beau, non ? Et surtout, la taille des nombres n'est limitée que par la taille de la mémoire.
La partie check B est un peu tordu et aurait pu être grandement simplifiée, une méthode un peu plus jolie a été utilisée pour A dans la partie Division.
Bonne chance au die hard brainfuck organisateur
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$ Part 0 : Setup $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$
$ Centering $
$$$$$$$$$$$$$
>>>>>>>>>>>>>>>>>>>>>>
@A_0
$$$$$$$$$$$
$ Reading $
$$$$$$$$$$$
,----------[
>+++[<->-------]<-
<+>>>>>>>>>>>>,
----------
]
>>>>>>>>>>>
,----------[
>+++[<->-------]<-
<+>>>>>>>>>>>>,
----------
]
@B_b
$$$$$$$$$$$$$
$ Copying B $
$$$$$$$$$$$$$
On place des marques en B_i^m2
<<<<<<<<<<<<[<+<<<<<<<<<<]
>>>>>>>>>>
@B_0^m2
[ @B_i^m2
->>
@B_i
[->+>+<<]
>>[-<<+>>]
<
@B_i^1 sur une copie du chiffre
<<[ On se déplace à travers B
>>[->>>>>>>>>>>+<<<<<<<<<<<]>>>>>>>>>]
On laisse un espace vide entre B et C:
>>[->>>>>>>>>>>+<<<<<<<<<<<]>>>>>>>>>>>
<<
@C_0^m1
[ On se déplace à travers C
>>[->>>>>>>>>>>+<<<<<<<<<<<]>>>>>>>>> ]
+ On met le marqueur
>>[-<+>]<< On place le nombre
@C_i^m1
[<<<<<<<<<<<]
<<<<<<<<<<<
@B_bm1^m1
<[<<<<<<<<<<<]>>>>>>>>>>>
]
>>
@B_b
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$ Part 1 : PGCD $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
<<<<<<<<<<<<
@B_bm1^m1
[<<<<<<<<<<<]
-[+<<<<<<<<<<<-]+
>>>>>>>>
+
$$$$$$$$$$$
$ Check B $
$$$$$$$$$$$
[
@A_a^m4
>>>-[+>>>>>>>>>>>-]+
[>>>>>>>>>>>]
<<<<<<<<<<<
@B_bm1^m1
$$$$$$$$$$$$$$$$
$ Check A gt B $
$$$$$$$$$$$$$$$$
Premièrement comptons le nombre de chiffre dans A et B
De B :
[ @B_i^m1 >>>>>>>>>> @B_ip1^m2 [-<<<<<<<<<<<+>>>>>>>>>>>]<<<<<<<<<<<+ <<<<<<<<<< ]
@B_m1^m1
Avec B_0^m2 = le nombre de chiffre de B
Copions le en B_m1^m3
>>>>>>>>>>[ -<<<<<<<<<<<<+>>>>>>>>>>>> ]
<<<<<<<<<<
@B_m1^m1
Copions le maintenant en A_a^m3
<<<<<<<<<<<-[+ >>>>>>>>>[-<<<<<<<<<<<+>>>>>>>>>>>]<<<<<<<<<<< <<<<<<<<<-]+
@A_am1^m1
De A :
@A_am1^m1
[ @A_i^m1 >>>>>>>>>> @A_ip1^m2 [-<<<<<<<<<<<+>>>>>>>>>>>]<<<<<<<<<<<+ <<<<<<<<<< ]
@A_m1^m1
Remontons le nombre de chiffre de A (actuellement en A_0^m2) en A_a^m2
>>>>>>>>>>>
[ @A_i^m1 <[->>>>>>>>>>>+<<<<<<<<<<<]>>>>>>>>>>>> ]
<
@A_a^m2
Maintenant le but est de mettre 1 en A_a^1 si A gt B et 0 sinon
Traitons d'abord les cas simples : A et B ont un nombre de chiffre diffèrent
Mémoire | 0 | b | a | 0 | 0 | 0 | 0 |
* A_a
Copions copions
[->>+>+<<<]
<[->+>>>>+<<<<<]
@A_a^m3
Mémoire | 0 | 0 | b | 0 | a | a | b |
* A_a
>>>[-<<->>] mettons b m a en A_a^m2
Mémoire | 0 | 0 |bma| 0 | 0 | a | b |
A_a
<<
@A_a^m2
[ b != a
[-]<-> On met 0xff en A_a^m3 comme marque
On check si a gt b
@A_a^m2
>>>
@A_a^1
>>>>+<<<[>+>+<<-]
>>[<<+>>-]
<<<[>>>+<<<-] +
>>>[>-]>[<<<<->>[-]>>->]<+<
<[>-[>-]>[<<<<->>[-]+>>->]<+<<-]
[-]>[-]>[-]>[-]<<<<[-]<
@A_a^1 1 si a gt b 0 sinon et donc 1 si A gt B et 0 sinon
<<<
@A_a^m2
]<+[ b == a
-
Raaa dur dur la vie
il va falloir vérifier chiffre par chiffre
@A_a^m3
>>>>>[-] Le b ne sert plus a rien puisque a==b
<[-<<<+>>>] Plaçons le a en A_a^m2 pour commencer a compter
@A_a^1
<<
C'est parti !
Copions a en A_0^m2
@A_a^m1
<<<<<<<<<<<[>>>>>>>>>>[-<<<<<<<<<<<+>>>>>>>>>>>]<<<<<<<<<<<<<<<<<<<<<]
@A_m1^m1
>>>>>>>>>>>
@A_0^m1
<<+>>
[>>>>>>>>>>>]@A_a^m1
>+@A_a
[- @A_a
<<<
-[+<<<<<<<<<<<-] @A_i^m3
>>>>>>>>>>>+<<<<<<<<<<
@A_i^m2
[->>>+>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>>>>-<<<<<<<<<<<
@A_i^m2
>>[->>>+<<<]
>>>[-<+<<+>>>]
@A_i^3
Mémoire | 0 | 0 | 1 | d | i | d | 0
A_i *
<<<<
Avançons !
Parmi A:
[ @A_j^m1
>>[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>]
@A_a^m1
Avançons !
Parmi le vide inter A B:
-[+
>>[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>-]+
@B_0^m1
Avançons !
Parmi B:
[ @B_j^m1
>>[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>]
@B_b^m1
Reculons!
Maintenant on peut indexer B
>> @B_b^1
[
-
[-<<<<<<<<<<<+>>>>>>>>>>>]
>[-<<<<<<<<<<<+>>>>>>>>>>>]
<<<<<<<<<<<<]
@B_i^1 Finalement
Mémoire : | 0 | 1 | b | 0 | a | 0 | 0 avec b le ieme chiffre de B et a le ieme chiffre de A
B_i *
Copions copions !
<[-<<+>>]
<<[->>+>+<<<]
>>>>[->>+<<]
>>[-<+<+>>]
@B_i^4
Mémoire : | 0 | 1 | b | b | a | a | 0
B_i *
But : Mettre dans B_i^3 : 1 pour a gt b ou 0 pour a=b ou m1 pour b gt a
<<[-<->]<
[ Pas égaux hard time ahead
[-]>-<
@B_i^1
Mémoire : | 0 | 1 | b | 0 |255| a | 0 | 0 | 0
B_i *
>>>>+<
<<<<[>+>>>+<<<<-]
>[<+>-]
>>[<<+>>-]-
>[>-]>[<<++<<[-]>>>>->]<+<
<<<[>>>-[>-]>[<<++<<[-]+>>>>->]<+<<<<-]
>>>[-]>[-]>[-]<<<
@B_i^3
Mémoire : | 0 | 1 | b | 0 |255| m | 0 | 0 | 0
B_i *
<<
@B_i^1
]>+[- Égaux
@B_i^2
>[-] On met a zéro
<
@B_i^2
]
Pour des raisons de rapidité de transport on ajoute 1 ainsi au lieu d'avoir m1 0 ou 1 on aura 0 1 ou 2
>+[-<<+>>]<< m @B_i^1 ici
<<[>>[-<<<<<<<<<<<+>>>>>>>>>>>]<<<<<<<<<<<<<]
@B_m1^m1
<<<<<<<<<<<-[+>>>>>>>>>>>>>[-<<<<<<<<<<<+>>>>>>>>>>>]<<<<<<<<<<<<<<<<<<<<<<<<-]+
>>>>>>>>>>> @A_a^m1
>>[-<<+>>]<<
@A_a^m1
On retransforme 0 1 ou 2 en m1 0 ou 1
-
[+[-- a gt b
>>+<<
] b gt a : rien a faire
<+>]<-[+ a == b
>>+<<]
<@A_a^m3
[->>>[-]<<<]
>>>
@A_a
] Fin de la boucle sur les nombres de A et B
Nettoyons les compteurs
<<<<<<<<<<<<[<[-]<[-]<<<<<<<<<]
@A_m1^m1
>>>>>>>>>>>[>>>>>>>>>>>]<<
@A_a^m3
] Fin du branchement sur le nombre de chiffre de A et B
Maintenant le byte A_a^1 indique si A gt B
>>>>[-<+>]< Déplacé en A_a
[ Si a gt b
- Ça fait mal au cœur de virer un flag qui a été calcule par 200 lignes de code brainfuck
@A_a
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$ Substracting B: Raw sub B $
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
Premièrement comptons le nombre de chiffre dans B
<-[+>>>>>>>>>>>-]+
@B_0^m1
[>>>>>>>>>>>]
@B_b^m1
<<<<<<<<<<<
[ @B_i^m1
On récupère le dernier nombre de chiffre
>>>>>>>>>>[-<<<<<<<<<<<+>>>>>>>>>>>]<<<<<<<<<<<
@B_i^m2
+
<<<<<<<<<<
]
>>>>>>>>>>>
@B_0^m1
<
[ @B_i^m2
Mémoire | 1 | i | 1 | d | 0 | 0 | 0 avec d le chiffre B_i
* B_i
Copions copions
[->>>+>>>>>>>>+<<<<<<<<<<<]>>>>>>>>>>>-<
+<<<<<<<<<<
@B_i^m2
>>[->>>+<<<]
>>>[-<+<<+>>>]
@B_i^3
Mémoire | 0 | 0 | 1 | d | i | d | 0
B_i *
<<<< @B_i^m1
Reculons parmi B
[ >>[-<<<<<<<<<<<+>>>>>>>>>>>]
>[-<<<<<<<<<<<+>>>>>>>>>>>]
<<<<<<<<<<<<<<]
@B_m1^m1
Reculons parmi le vide inter A B
-[+ >>[-<<<<<<<<<<<+>>>>>>>>>>>]
>[-<<<<<<<<<<<+>>>>>>>>>>>]
<<<<<<<<<<<<<<-]+
@A_am1^m1
Indexons
>>-[
-[-<<<<<<<<<<<+>>>>>>>>>>>]
>[-<<<<<<<<<<<+>>>>>>>>>>>]
<<<<<<<<<<<<]
@A_i^1
Mémoire | 0 | 1 | a | 0 | b | 0
A_i *
Soustraction proprement dite
>[-<<->>]
@A_i^2
On se replace :
<<<[>>>>>>>>>>>]
-[+>>>>>>>>>>>-]+
<<-[+>>>>>>>>>>>-]
@B_i^m3
>
@B_ip1^m2
]
>
@B_b^m1
Retournons en A
<<<<<<<<<<<[<<<<<<<<<<<]
-[+<<<<<<<<<<<-]+
@A_am1^m1
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$ Substracting B: Normalisation A $
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
[ @A_i^m1
Mémoire | 0 | 1 | d | 0 | 0 | 0
* A_i
>[->+>+<<]
>>[-<<+>>]
Mémoire | 0 | 1 | d | d | 0 | 0
A_i *
++++++++++
<++++++++++
>>>>+<
<<<[>>+>+<<<-]
>>>[<<<+>>>-]
<<[>>+<<-]+
>>[>-]>[<<<->[-]>>->]<+<
<[>-[>-]>[<<<->[-]+>>->]<+<<-]
>[-]>[-]>[-]<<<<
<[-]>
@A_i^2
[ A_i doit etre normalise
-
<<++++++++++
<<<<<<<<<<<->>>>>>>>>>>
>>]
<<<
@A_i^m1
<<<<<<<<<<<]
@A_m1^m1
Maintenant virons les 1 devant les chiffres qui ne font plus partie du nombre (leading 0s)
>>>>>>>>>>>
[ @A_i^m1
<+ On met un flag en A_i^m2 qui sera mis a zéro si le chiffre est utile
<<<<<<<<<<[>>>>>>>>>>[-]<<<<<<<<<<-<+>]<[->+<]>>>>>>>>>>>>
@A_i^m1
>[->>+<<]
>>[-<+<+>>]
@A_i^2
<[ Si x non null
<<<[-]>>>
[-]]
@A_i^1
<<<
@A_i^m2
[- Le chiffre est inutile C'est un leading zéro
>- On enlève le flag
<]
>>>>>>>>>>>>]
@A_a^m1
+> Le flag du else en A_a^m1
@A_a
]<-[+ Si non a gt b
@A_a^m1
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$ Substracting A: Raw sub A $
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
Premièrement comptons le nombre de chiffre dans A
<<<<<<<<<<<
[ @A_i^m1
>>>>>>>>>>[-<<<<<<<<<<<+>>>>>>>>>>>]<<<<<<<<<<<
+
<<<<<<<<<<]
>>>>>>>>>>>
@A_0^m1
<<+>
[ @A_i^m2
Mémoire | 1 | i | 1 | d | 0 | 0 | 0
* A_i
Copions copions
[->>>+>>>>>>>>+<<<<<<<<<<<]>>>>>>>>>>>-<<<<<<<<<<<
<->>>>>>>>>>>+<<<<<<<<<<
@A_i^m2
>>[->>>+<<<]
>>>[-<+<<+>>>]
@A_i^3
Mémoire | 0 | 0 | 1 | d | i | d | 0
A_i *
<<<< @A_i^m1
Avançons parmi A
[ >>[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>]
@A_a^m1
Avançons parmi le vide inter A B
-[+ >>[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>-]+
@B_0^m1
Avançons parmi B
>>>>>>>>>>>[ <<<<<<<<<[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]>>>>>>>>
>>>>>>>>>>>]
<<<<<<<<<<<
@B_bm1^m1
Indexons
>>-[
-[-<<<<<<<<<<<+>>>>>>>>>>>]
>[-<<<<<<<<<<<+>>>>>>>>>>>]
<<<<<<<<<<<<]
@B_i^1
Mémoire | 0 | 1 | b | 0 | a | 0
B_i *
Soustraction proprement dite
>[-<<->>]
@B_i^2
On se replace :
<<<[<<<<<<<<<<<]
@B_m1^m1
<<-[+<<<<<<<<<<<-]+
@A_ip1^m3
>
@A_ip1^m2
]
<-> On vire le flag
>
@A_a^m1
Retournons en B
-[+>>>>>>>>>>>-]+
@B_0^m1
[>>>>>>>>>>>]
<<<<<<<<<<<
@B_bm1^m1
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$ Substracting A: Normalisation B $
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
[ @B_i^m1
Mémoire | 0 | 1 | d | 0 | 0 | 0
* B_i
>[->+>+<<]
>>[-<<+>>]
Mémoire | 0 | 1 | d | d | 0 | 0
B_i *
++++++++++
<++++++++++
>>>>+<
<<<[>>+>+<<<-]
>>>[<<<+>>>-]
<<[>>+<<-]+
>>[>-]>[<<<->[-]>>->]<+<
<[>-[>-]>[<<<->[-]+>>->]<+<<-]
>[-]>[-]>[-]<<<<
<[-]>
@B_i^2
[ B_i doit être normalise
-
<<++++++++++
<<<<<<<<<<<->>>>>>>>>>>
>>]
<<<
@B_i^m1
<<<<<<<<<<<]
@B_m1^m1
Maintenant virons les 1 devant les chiffres qui ne font plus partie du nombre (leading 0s)
>>>>>>>>>>>
[ @B_i^m1
<+ On met un flag en B_i^m2 qui sera mis a zéro si le chiffre est utile
<<<<<<<<<<[>>>>>>>>>>[-]<<<<<<<<<<-<+>]<[->+<]>>>>>>>>>>>>
@B_i^m1
>[->>+<<]
>>[-<+<+>>]
@B_i^2
<[ Si x non null
<<<[-]>>>
[-]]
@B_i^1
<<<
@B_i^m2
[- Le chiffre est inutile C'est un leading zéro
>- On enlève le flag
<]
>>>>>>>>>>>>]
@B_b^m1
<<<<<<<<<<<[ B n'est pas nul
@B_bm1^m1
[<<<<<<<<<<<]
-[+<<<<<<<<<<<-]+
>>>>>>>>>>>
]
Si B=0 @~B_bm1^m1
Sinon @~A_a^m1
<<<<<<<<<<<-[+ B is null here
@B_bm2^m1
-[+<<<<<<<<<<<-]+
@A_am1^m1
>>>>>>>>>>>
@A_a^m1
<<<[-]
<<<<<<<<
-
]
@A_am1^m1
+
>>>>>>>>>>>
] Fin du si sur a gt b
@A_a^m1
<<<
] Fin du while B
@A_a^m4
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$ Part 2 : Division $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
>>>-[+>>>>>>>>>>>-]+
<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>> On remarque B
[>>>>>>>>>>>]<<<<<<<<<<<
@C_cm1^m1
[
$$$$$$$$$$$$$$$
$ Increment B $
$$$$$$$$$$$$$$$
[<<<<<<<<<<<]
-[+<<<<<<<<<<<-]+
@B_bm1^m1
>+
Il faut faire monter les retenues maintenant
<[ @B_i^m1
Vérifions si il y a une retenue
>[->+>+<<]
>>[-<<+>>]
<----------
[>+<[-]]
>
@B_i^2
-[+ Il y a une retenue bon sang de bon soir
<<----------<<<<<<<<<<<+
Ajout du flag si nécessaire
<[-]+>
>>>>>>>>>>>>>]
<<<<<<<<<<<<<<
]
@B_m1^m1
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$ Substracting A: Raw sub A $
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
On commence par compter le nombre de chiffre de A
-[+<<<<<<<<<<<-]+
@A_am1^m1
[ <+[-<<<<<<<<<<<+>>>>>>>>>>>]<<<<<<<<<< ]
@A_m1^m1
<[->>>>>>>>>>>+<<<<<<<<<<<]>>>>>>>>>>>>
@A_0^m1
Avec le nombre de chiffre de A en A_0^m2
<<+>
[ @A_i^m2
Mémoire | 1 | i | 1 | d | 0 | 0 | 0
* A_i
Copions copions
[->>>+>>>>>>>>+<<<<<<<<<<<]>>>>>>>>>>>-<<<<<<<<<<<
<->>>>>>>>>>>+<<<<<<<<<<
@A_i^m2
>>[->>>+<<<]
>>>[-<+<<+>>>]
@A_i^3
Mémoire | 0 | 0 | 1 | d | i | d | 0
A_i *
<<<< @A_i^m1
Avançons parmi A
[ >>[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>]
@A_a^m1
Avançons parmi le vide inter A B
-[+ >>[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>-]+
@B_0^m1
Avançons parmi B
[ >>[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>]
@B_b^m1
Avançons parmi le vide inter B C
-[+ >>[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]
>>>>>>>>-]+
@C_0^m1
Avançons parmi C
>>>>>>>>>>>[ <<<<<<<<<[->>>>>>>>>>>+<<<<<<<<<<<]
>[->>>>>>>>>>>+<<<<<<<<<<<]>>>>>>>>
>>>>>>>>>>>]
@C_c^m1
<<<<<<<<<<<
@C_cm1^m1
Indexons
>>-[
-[-<<<<<<<<<<<+>>>>>>>>>>>]
>[-<<<<<<<<<<<+>>>>>>>>>>>]
<<<<<<<<<<<<]
@C_i^1
Mémoire | 0 | 1 | c | 0 | a | 0
C_i *
Soustraction proprement dite
>[-<<->>]
@C_i^2
On se replace :
<<<[<<<<<<<<<<<]
@C_m1^m1
-[+<<<<<<<<<<<-]+
@B_bm1^m1
[<<<<<<<<<<<]
@B_m1^m1
<<-[+<<<<<<<<<<<-]+
@A_ip1^m3
>
@A_ip1^m2
]
<-> On vire le flag
>
@A_a^m1
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$ Substracting A: Normalisation C $
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
-[+>>>>>>>>>>>-]+
[>>>>>>>>>>>]
-[+>>>>>>>>>>>-]+
[>>>>>>>>>>>]
<<<<<<<<<<<
@C_cm1^m1
[ @C_i^m1
Mémoire | 0 | 1 | d | 0 | 0 | 0
* C_i
>[->+>+<<]
>>[-<<+>>]
Mémoire | 0 | 1 | d | d | 0 | 0
C_i *
++++++++++
<++++++++++
>>>>+<
<<<[>>+>+<<<-]
>>>[<<<+>>>-]
<<[>>+<<-]+
>>[>-]>[<<<->[-]>>->]<+<
<[>-[>-]>[<<<->[-]+>>->]<+<<-]
>[-]>[-]>[-]<<<<
<[-]>
@C_i^2
[ C_i doit être normalise
-
<<++++++++++
<<<<<<<<<<<->>>>>>>>>>>
>>]
<<<
@C_i^m1
<<<<<<<<<<<]
@C_m1^m1
Maintenant virons les 1 devant les chiffres qui ne font plus partie du nombre (leading 0s)
>>>>>>>>>>>
[ @C_i^m1
<+ On met un flag en C_i^m2 qui sera mis a zéro si le chiffre est utile
<<<<<<<<<<[>>>>>>>>>>[-]<<<<<<<<<<-<+>]<[->+<]>>>>>>>>>>>>
@C_i^m1
>[->>+<<]
>>[-<+<+>>]
@C_i^2
<[ Si x non null
<<<[-]>>>
[-]]
@C_i^1
<<<
@C_i^m2
[- Le chiffre est inutile C'est un leading zéro
>- On enlève le flag
<]
>>>>>>>>>>>>]
@C_c^m1
<<<<<<<<<<<
@C_cm1^m1
] Fin du while sur C
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$ Part 3 : Output $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
-[+<<<<<<<<<<<-]+
[<<<<<<<<<<<]
>>>>>>>>>>>
[>>+[<+>+++++]<---.
>>>>>>>>>>]
++++++++++.
Huhuuuu ! C'est fini !