From 92ee5945a7ef43ffa16b84b07280415d93edf64c Mon Sep 17 00:00:00 2001 From: Yannis Date: Sun, 8 Nov 2020 16:10:37 +0100 Subject: [PATCH] Traduction Algorithme FonctionAnalyseEmpiler.md en Francais --- .../Algo_Generation-Manipulation_Carte.md | 4 +- Doc/Algorithme/FonctionAnalyseEmpiler.md | 174 +++++++++++++++++- 2 files changed, 167 insertions(+), 11 deletions(-) diff --git a/Doc/Algorithme/Algo_Generation-Manipulation_Carte.md b/Doc/Algorithme/Algo_Generation-Manipulation_Carte.md index 5b7dd7a..45849f1 100644 --- a/Doc/Algorithme/Algo_Generation-Manipulation_Carte.md +++ b/Doc/Algorithme/Algo_Generation-Manipulation_Carte.md @@ -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 diff --git a/Doc/Algorithme/FonctionAnalyseEmpiler.md b/Doc/Algorithme/FonctionAnalyseEmpiler.md index 60304bd..faad78c 100644 --- a/Doc/Algorithme/FonctionAnalyseEmpiler.md +++ b/Doc/Algorithme/FonctionAnalyseEmpiler.md @@ -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,28 +171,184 @@ > >>**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 > ->> retour ComparaisonTotal(TasDeCarte,CarteFille,index + 1) +>// 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** > -### FIN +>// 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 +> +>> retourne Assemblage(**TasDeCarte**,**CarteMere**) +> +>**Fin si** +> +###FIN \ No newline at end of file