diff --git a/SwichGIT/Doc/Algorithme/FonctionAnalyseEmpiler.md b/SwichGIT/Doc/Algorithme/FonctionAnalyseEmpiler.md index 75ed500..e8b1e24 100644 --- a/SwichGIT/Doc/Algorithme/FonctionAnalyseEmpiler.md +++ b/SwichGIT/Doc/Algorithme/FonctionAnalyseEmpiler.md @@ -2,6 +2,8 @@ ## DEFINITION DES STRUCTURES ## ### ENUMERATION FORMEFIGURE ### +//formes géométriques possibles sur des cartes + - **Rond** :rond - **Carre** :carre - **Triangle** : triangle @@ -10,16 +12,18 @@ --- ### ENUMERATION TYPEFIGURE ### -- **Pleine** : pleine -- **Creuse** : creuse +//Tailles de Figure possibles sur des cartes +- **Petit** : petit +- **Moyen** : moyen +- **Grand** : grand --- ### STRUCTURE FIGURE ### ### Attributs ### -- **Figure.type** : TypeFigure +- **Figure.type** : TypeFigure [ ] - **Figure.forme** : FormeFigure -- **Figure.X** : entier -- **Figure.Y** : entier +- **Figure.X** : entier // Coordonnées X sur la **Carte** +- **Figure.Y** : entier // Coordonnées Y sur la **Carte** - **Figure.HTML** : code HTML ### Méthodes ### - **Figure.get...**: Retourne l'attributs voulus @@ -29,171 +33,103 @@ ### Attributs ### - **Carte.indentifiant** : entier -- **Carte.row** : eniter -- **Carte.column** : entier +- **Carte.row** : eniter // Nombre de lignes sur la carte +- **Carte.column** : entier // Nombre de colonnes sur la carte - **Carte.HTML**: code HTML - **Carte.Matrice**: entier[n][k]; -- **Carte.FigurePleine** : Figure -- **Carte.FigureCreuse** : Figure +- **Carte.lesFigures** : Figures [ ] ### Méthodes ### - **Carte.carteVerticale** : obtient sa carte verticalement symétrique. - **Carte.carteHorizontale** : obtient sa carte horizontalement symétrique. - **Carte.get...** : Retourne l'attributs voulus +--- +### STRUCTURE CODE ### + +### Attributs ### +- **Code.code** : entier //Nombre de liaisons +- **Code.Carte**: Carte + --- ## COMPARAISON DE CARTE ## -**ComparaisonDeCarte(CarteMere: Carte, CarteFille: Carte)** : entier +**ComparaisonDeCarte(CarteMere: Carte, CarteFille: Carte)** : entier,Carte **Entrées** : -- **CarteMere** : Carte témoin, "support" de l'assemblage, il est inutile de modifier sa structure. -- **CarteFille** : Carte sujet, "pièce" à tester sur le support. +- **CarteMere** : Carte témoin, "support" de l'assemblage. + +- **CarteFille** : Carte sujette, "pièce" à comparer sur le support. -**Objectif** : Determine si les Cartes possèdent une liaison ( FigurePleine <=> FigureCreuse ) +**Objectif** : Determine le nombre de liaison possible entre CarteMere et CarteFille. -**Sortie** : entier +**Sortie** : entier,Carte **Sortie Possible :** -- **2** : L'assemblage est parfait ou sans contrainte (Carte NULL). **Deux liaisons** possible. - -- **1** : L'assemblage n'est pas parfait. Cependant, **Une liaison** possible. +- **-1,CarteMere** : L'assemblage est impossible. -- **0** : L'assemblage est impossible. **Aucune liaison** possible. +- **nbliaisons,CarteMere** : L'assemblage est possible avec un certain nombre de liaisons entre les cartes. ### COMMENT FAIRE ### -- Recherhcer les coordonnées des **Figures** de **CarteMere** -- Comparer ces coordonnées sur l'attribut **Carte.Matrice** de **CarteFille** -> Si les coordonnées de **CarteMere.FigurePleine** sont égales aux coordonnées de **CarteFille.FigureCreuse** et inversement on considère ce cas comme **une liason**. -> -> Faire de même pour les autres **Figures**. - -- **Retourner l'entier correspondant à la situation** +- Pour chaque **Figure** contenu dans **CarteFille.lesFigures** + - On regarde chaque **Figure** contenu dans **CarteMere.lesFigures** + - Si des figures sont aux mêmes endroits, de même **forme** et de **type** différents, on incrémente le nombre de liaisons. + - Si des figures sont aux mêmes endroits mais que les **Types** sont identiques ou que les **Forme** sont différentes, le nombre de liaisons vaut -1 et on retourne le résultat dans ce cas. +- A la fin de la comparaison des **Figures**. On fait la mise à jour de **CarteMere** en faisant la somme des deux cartes puis on retourne le résultat avec le nombre de liaison. --- -## COMPARAISON TOTALE DE LA CARTE +## SOMME DE CARTE # -**ComparaisonTotal(CarteMere:Carte d'entiers,CarteFille:Carte, index entier)**:entier,Carte +**SommeDeCarte(CarteMere:Carte d'entiers,CarteFille:Carte)**:Carte **Entrees** : - - **CarteMere** : Carte témoin, "support" de l'assemblage, il est inutile de modifier sa structure. -- **CarteFille** : Carte sujet, "pièce" à tester sur le support. -- **index** : entier déterminant le nombre d'itération de la fonction + - **CarteMere** : Carte témoin, Carte mise à jour +- **CarteFille** : Carte sujette,Carte comportant les nouveaux ajouts -**Objectif** : Determine si les Cartes possèdent une liaison MAIS avec toutes les possibilitées de rotation de **CarteFille** +**Objectif** : Mettre à jour **CarteMere** en ajoutant les propriétés de **CarteFille** -**Sortie** : entier, Carte +**Sortie** : Carte -**Sortie Possible :** - -- **2,CarteMere** : L'assemblage est parfait ou sans contrainte (Carte NULL). **Deux liaisons** possible. -- **1,CarteFille** : **CarteMere** est NULL, L'assemblage est possible. -- **1,CarteMere** : L'assemblage n'est pas parfait. Cependant, **Une liaison** possible. -- **3,CarteFille** : Il existe deux possibilitées verticalement symétrique d'assemblage. On retourne la **CarteFille** qui peut s'assembler de deux façons. -- **4,CarteFille** : Il existe deux possibilitées horizontalement symétrique d'assemblage. On retourne la **CarteFille** qui peut s'assembler de deux façons. -- **-1,CarteMere** : Il est impossible d'assembler **CarteFille** avec **CarteMere** ### COMMENT FAIRE ### -- On regarde si **CarteMere** n'est pas NULL pour savoir si une comparaison d'assemblage est possible. ->Si **CarteMere** est NULL on retourne la sortie associée à ce cas (**1,CarteFille**) - -- On regarde **index** pour savoir quelle variante de **CarteFille** (carteverticale,cartehorizontale) tester sur **CarteMere**. Si toutes les variantes ont été testées, alors on retourne **-1,CarteMere**. -- On teste la variante avec la fonction **COMPARAISON DE CARTE** et on traite la sortie de cette comparaison en retournant des informations selon les cas. -### TRAITEMENT DE COMPARAISON DE CARTE ### -> **Si Sortie = 2** -> -> L'assemblage est parfait **CarteFille** est assemblée avec **CarteMere** et on retourne **2,CarteMere** -> ->--- ->**Si Sortie = 1** -> -> On reagarde si un assemblage symétrique (Verticalement ou Horizontalement) est possible. -> S'il en existe un on retourne **la sortie associée** au différent cas. -> -> **Sinon**,**CarteFille** est assemblée avec **CarteMere** et on retourne **1,CarteMere** -> ->--- ->**Si Sortie = 0** -> -> L'assemblage de la variante de **CarteFille** et **CarteMere** est impossible, on continue en testant **COMPARAISON_TOTAL_DE_LA_CARTE**(CarteMere,CarteFille,**index+1**) - +- Pour chaque **Figure** contenu dans **CarteFille.lesFigures** + - On regarde chaque **Figure** contenu dans **CarteMere.lesFigures** + - Si l'une des Figures de **CarteFille** est absente de **CarteMere** on l'ajoute à la liste **CarteMere.lesFigures**. + - Sinon on fait rien +- Une fois toutes les figures mises à jour dans **CarteMere.lesFigures**, **CarteMere.Matrice** est aussi mise à jour en faisant apparaitre les figures ainsi que les types par le biais de somme de puissance de 2. +- On retourne **CarteMere** mise à jour > --- # ASSEMBLAGE # -**Assemblage(TasDeCarte: Carte[], CarteMere:Carte** :entier, Carte +**Assemblage(TasDeCarte: Carte[], CarteMere:Carte** : Code[ ] **Entree** : - **TasDeCarte** : Liste de **Carte** selectioonnées afin de tester si un assemblage valide est possible. - - **CarteMere** : Carte témoin, "support" de l'assemblage, il est inutile de modifier sa structure. - -**Objectif** : Savoir si un tas de carte envoyé en paramètre peut être empiler ou non + - **CarteMere** : Carte témoin, "support" de l'assemblage. -**Sortie** : entier, Carte +**Objectif** : Tester tous les assemblages possibles du tas de cartes -**Sortie Possible** - -- **2,CarteMere** : L'assemblage final est correcte. -- **0,CarteMere** : L'assemblage final n'est pas correcte. +**Sortie** : Code[ ] ### COMMENT FAIRE ### -- On regarde si la liste **TasDeCarte** n'est pas vide pour savoir si des **Cartes** doivent être encore testées. -> Si **TasDeCarte** est vide on retourne **0,CarteMere** - -- On teste avec la fonction **COMPARAISON TOTALE DE CARTE** , **CarteMere** et la tête de liste de **TasDeCarte** et on traite les différentes sorties. - -### TRAITEMENT DE COMPARAISON TOTALE DE LA CARTE ### -> **TRAITEMENT** Si **TasDeCarte** est maintenant **vide** -> ->>--- -> ->> **Si Sortie = 2** -> ->> L'assemblage est valide on retourne **2,CarteMere** -> ->>--- ->>**Si Sortie != 2** -> ->> Il n'y plus de carte à tester et l'assemblage n'est pas parfait. L'assemblage n'est donc pas valide on retourne **0,CarteMere** -> ->>--- -> -> **TRAITEMENT** Si **TasDeCarte** n'est toujours **pas vide** -> ->>>--- -> ->> **Si Sortie = 2 ou -1** -> ->> L'assemblage est parfait ou impossible. Cependant il y a encore des cartes à tester. On ajoute donc la **Carte** contenue dans la **Sortie** de la fonction **COMPARAISON TOTALE** à la fin de la liste **TasDeCarte** et on retourne une nouvelle itération de la fonction **Assemblage** avec les variables remises à jour. -> ->>--- ->>**Si Sortie = 3** -> ->> Il y a plusieurs possibilités verticalement symétrique d'assemblage, on va donc tester les deux cas avec **Assemblage** et les nouvelles variables. Si la sélection est correcte, il y a au moins une possibilité de bonne. -> ->> Sinon on retourne **0,CarteMere** -> ->>--- ->>**Si Sortie = 4** -> ->> Il y a plusieurs possibilités horizontalement symétrique d'assemblage, on va donc tester les deux cas avec **Assemblage** et les nouvelles variables. Si la sélection est correcte, il y a au moins une possibilité de bonne. -> ->> Sinon on retourne **0,CarteMere** -> ->>--- -> ->>**Si Sortie = 1** -> ->> Il y a une seule possibilité d'assemblage. On continu de tester avec **Assemblage** et les nouvelles variables. -> ->>--- +- On supprime la tête de liste de **TasDeCarte** qui est égale à **CarteMere**. +- Si **TasDeCarte** est maintenant vide on retourne un **Code** avec **Code.code** = 0 et **Code.Carte** = **CarteMere**. + -Sinon on continue +- On appelle la même fonction **Assemblage** en envoyant la liste **TasDeCarte** et en testant avec toutes les variantes de rotation de la tête de **TasDeCarte**. +- Une fois toutes les listes de **Code** retournées par ces appelles de fonctions et récupérées dans une seule : + - Pour chaque **Code** de la liste : + - Si **Code.code** est différent de -1, on compare **Code.Carte** et **CarteMere**. Puis on ajoute le nombre de liaison à **Code.code**. +- On retourne la liste de **Code** mise à jour. + +---