pascal.lafourcade
/
swish
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Traduction Algorithme FonctionAnalyseEmpiler.md en Francais

Browse Source
Golfier
Yannis 5 years ago
parent 004cc4dc94
commit 92ee5945a7
2 changed files with 167 additions and 11 deletions
Show Stats Download Patch File Download Diff File

4
Doc/Algorithme/Algo_Generation-Manipulation_Carte.md
Unescape View File

@ -2,11 +2,11 @@
## CREATION DE CARTE
**CreationCarte(void):** Carte:Tableau(4,3) d'entiers
**CreationCarte(void):** Carte:Matrice(4,3)
**Entrées** : void
**Sortie** : Carte:Tableau(4,3) d'entiers
**Sortie** : Carte:Matrice(4,3)
### Début

172
Doc/Algorithme/FonctionAnalyseEmpiler.md
Unescape View File

@ -151,7 +151,7 @@
>
>>>// Les variantes horizontalement symétriques possèdent toutes les deux une liaison avec **CarteMere** on ne peut pas savoir laquelle est la bonne pour faire le tas final.
>
>>> retour **4, CarteMere**
>>> retour **4, CarteFille**
>
>>**Fin Si**
>
@ -171,27 +171,183 @@
>
>>**Si** **Code1** == 2 alors
>
>>>Code <- 2;
>>>// La variante verticalement symétrique s'assemble parfaitement, on l'assemble donc.
>
>>> TasDeCarte <- TasDeCarte + rotationVerticale(CarteFille)
>>> **CarteMere** <- **CarteMere** + **rotationVerticale(CarteFille)**
>
>>>retour Code, TasDeCarte
>>>retourne **2, CarteMere**
>
>>**Fin Si**
>
>> **Si** Code1 == 1 alors
>
>>> Code <- 3
>>>// Les variantes verticalement symétriques possèdent toutes les deux une liaison avec **CarteMere** on ne peut pas savoir laquelle est la bonne pour faire le tas final.
>
>>> retour Code,TasDeCarte
>>> retourne **3,CarteFille**
>
>>**Fin Si**
>
>**Fin si**
>
>**Si** Code == 0 alors
>// Si aucune liaison n'est possible, on appelle à nouveau la fonction en Incrémentant **index**
>
> retourne ComparaisonTotal(**CarteMere**,**CarteFille**,**index** + 1)
>
### FIN
#ASSEMBLAGE
**Assemblage(TasDeCarte: Liste Matrice(4,3),CarteMere:Matrice(4,3)** :entier, Matrice(4,3)
**Entree** : **TasDeCarte** Liste Matrice(4,3), CarteMere Matrice(4,3)
**Sortie** : entier, Matrice(4,3)
**Objectif** : Savoir si un tas de carte envoyé en paramètre peut être empiler ou non
###DEBUT
>###Variable locale
>
>**Carte** Matrice(4,3)
>
>**CopieCarteMere** Matrice(4,3)
>
>**Code** entier
>
>**CarteParallele** Matrice(4,3)
>
>---
>
>// Si le tas de carte est NULL il ne peut pas rapporter de point donc on ne peut pas l'assembler sinon on traite la première carte
>
>**Si** **TasDeCarte** est NULL
>
>>retourne **0, CarteMere**
>
>**Sinon**
>
>> **Carte** = teteL(**TasDeCarte**)
>
>> // On garde une copie de **CarteMere**
>
>> **CopieCarteMere** = **CarteMere**
>
>> // On regarde si **Carte** peut s'assembler avec **CarteMere**
>
>> **Code**,**CarteMere** = Comparaisontotal(**CarteMere**,**Carte**,**0**)
>
>
>**Fin si**
>
>// En fonction du Résultat obtenue on traite
>
>// Cas 1 : Si Code vaut 2 et que TasDeCarte est NULL on a atteint la fin du paquet et l'assemblage est parfait
>
>**Si** **Code** vaut 2 et **TasDeCarte** est NULL
>
>> retourne **2, CarteMere**
>
>**Fin si**
>
>// Cas 2 : TasDeCarte est NULL mais l'assemblage n'est pas parfait. On ne peut pas assembler correctement le tas de carte. On le signal
>
>**Si** **TasDeCarte** est NULL et **Code** different de 2
>
>> retourne **0,CarteMere**
>
>**Fin si**
>
>
>// **NOTE** : à ce stade si l'algorithme lit ces lignes nous savons que **TasDeCarte** n'est pas NULL. Seul la valeur de **Code** retourné par **ComparaisonTotal nous interesse
>
>//Cas 3 : **Code** vaut 2 ou 0, l'assemblage est parfait ou impossible mais il reste des cartes à traiter. Il faut donc insérer cette carte à la fin de la liste et continuer en traitant les autres carte.
>
>
>
>
>
>
>
>
>Si **Code** vaut 2 ou **Code** vaut 0 ou **Code** vaut -1
>
>> **TasDeCarte** = insrq(**TasDeCarte**,**Carte**)
>
>> retourne Assemblage(**TasDeCarte**,**CopieCarteMere**)
>
>**Fin si**
>
>// Cas 4: **Code** vaut 3, il y a plusieur possibilitées d'assemblage.On va donc essayer les deux possibilités proposées.
>
>//**NOTE** Dans ce cas la fonction **comparaisontotal** retourne la carte possédant la symétrie. Donc **CarteMere** est devenue cette carte. d'où l'importance de **CopieCarteMere**
>
>**Si** **Code** vaut 3
>
>> **CarteParallele** = **CarteMere**
>
>> // On teste les deux possibilité
>
>> **Code**,**CarteMere** = Assemblage(**TasDeCarte**,**CopieCarteMere** + **CarteParallele**)
>
>> **Code1**,**CarteMere1** = Assemblage(**TasDeCarte**,**CopieCarteMere** + rotationVerticale(**CarteParallele**))
>
>> // On regarde si l'une des deux possibilité fonctionne
>
>>**Si** **Code1** vaut 2
>
>>> retourne **2,CarteMere1**
>
>> **Fin si**
>
>>**Si** **Code** vaut 2
>
>>> retourne **2,CarteMere**
>
>>**Fin Si**
>
>>// Sinon aucun assemblage est bon
>
>> retourne **0,CarteMere**
>
>**Fin si**
>
>// Cas 5: **Code** vaut 4, il y a plusieur possibilitées d'assemblage.On va donc essayer les deux possibilités proposées.
>
>**Si** **Code** vaut 4
>
>> **CarteParallele** = **CarteMere**
>
>> // On teste les deux possibilité
>
>> **Code**,**CarteMere** = Assemblage(**TasDeCarte**,**CopieCarteMere** + **CarteParallele**)
>
>> **Code1**,**CarteMere1** = Assemblage(**TasDeCarte**,**CopieCarteMere** + rotationHorizontale(**CarteParallele**))
>
>> // On regarde si l'une des deux possibilité fonctionne
>
>>**Si** **Code1** vaut 2
>
>>> retourne **2,CarteMere1**
>
>> **Fin si**
>
>>**Si** **Code** vaut 2
>
>>> retourne **2,CarteMere**
>
>>**Fin Si**
>
>>// Sinon aucun assemblage est bon
>
>> retourne **0,CarteMere**
>
>**Fin si**
>
>// Cas 6 : Code vaut 1 On continue l'assemblage en appelant une nouvelle instance de l'algorithme.
>
>**Si** Code vaut 1
>
>> retour ComparaisonTotal(TasDeCarte,CarteFille,index + 1)
>> retourne Assemblage(**TasDeCarte**,**CarteMere**)
>
>**Fin si**
>

Write Preview
Loading…
Cancel
Save