Exercise definition

.gitignore

@@ -0,0 +1,2 @@
+.pytest_cache/
+.idea/

.idea/.gitignore

@@ -1,3 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml

README.md

@@ -3,69 +3,50 @@
 Vous trouverez ici un ensemble d'exercices permettant de pratiquer python mais également découvrir quelques pans annexes de l'informatique en général.
 Ces exercices sont issus d'un livre réalisé par Pascal Lafourcade et Malika More.
 
-## Exercice : A ski
+## Exercice : Arbre quaternaire
-Décryptez le message stocké dans le fichier `files/a_ski.txt`.
+Un quadtree ou arbre quaternaire (arbre Q) est une structure de données de type arbre dans laquelle chaque nœud a quatre fils. Les quadtrees sont le plus souvent utilisés pour partitionner un espace bidimensionnel en le subdivisant récursivement en quatre nœuds. 
+![img.png](files/quadtree.png)
 
-Après avoir compris la technique de codage utilisé, saurez-vous implémenter un programme en python permettant de le déchiffrer?
+Il existe plusieurs types de quadtree. Dans notre cas il s'agit d'un quadtree "region".
+Le quadtree «région» représente une partition de l'espace en deux dimensions en décomposant la région en quatre quadrants égaux, puis chaque quadrant en quatre sous-quadrants, et ainsi de suite, avec chaque «nœud terminal» comprenant des données correspondant à une sous-région spécifique. Chaque nœud de l'arbre a exactement : soit quatre enfants, soit aucun (cas d'un nœud terminal).
+Chaque `Noeud` comportant quatre éléments. Il s'agit d'une technique connue pour l'encodage d'images.  Pour simplifier, les images sont carrées, de couleur noir et blanc 
+et de côté 2^n.
 
-> Ici vous allez découvrir la manipulation de fichiers, la conversion de str en int et quelques méthodes natives du langage python. 
+Un noeud à quatre fils est représenté : 
-
-## Exercice cryptarithme
-Chaque lettre de l'opération représente un chiffre différent entre 0 et 9. Ecrivez un programme permettant de déterminer la valeur de chaque lettre pour que l'opération soit correcte, sachant que le premier chiffre de chaque nombre ne peut être un `0`.
-> SEND + MORE = MONEY
-
-> HUIT + HUIT = SEIZE
-
-> UN + UN + ONZE = TREIZE
-
-> CINQ + CINQ + VINGT = TRENTE
-
-Saurez-vous implémenter un script python permettant de trouver les chiffres associés aux lettres?
-
-Vous avez le fichier `files/cryptarithme.txt` à votre disposition si vous le souhaitez. 
-
-> Cet exercice implique l'utilisation de boucles imbriquées.
-
-## Exercice: Compter comme un shadok
-> Pour compte les matins, les Shadoks ont un système de numérotation basé uniquement sur les syllabes suivantes : 
->GA, BU, ZO et MEU.
->Voici par exemple un nombre shadok : BU MEU ZO MEU GA GA
-
-Saurez-vous programmer un convertisseur de nombre shadoks  en nombres décimaux pour découvrir quel est le nombre caché derrière le fichier `files/shadoks.txt` et ainsi découvrir la date de diffusion du premier épisode de cette série culte?
-
-> Cet exercice implique la compréhension des bases en mathématiques.
-
-## Exercice : Stéganographie
-Le principe de stéganographie est d'utiliser une technique pour passer un message secret d'une manière dissimulée tout en restant lisible pour celui qui sait comment trouver. 
-Au sein du fichier `stegano.png` se cache un texte secret. Chaque pixel a été très légèremet modifié.
-Il faut extraire le bit de poids faible de chaque couleur de chaque pixel.
-Puis d'en refaire des octets de 8 bits.
-
-Exemple: 
 ```python
-pixel = image[0][0]
+from __future__ import annotations
-r = red(pixel) % 2
-g = green(pixel) % 2
-b = blue(pixel) % 2
-a = alpha(pixel) % 2 
 
-pixel1 = image[1][0]
+class QuadTree:
-r1 = red(pixel1) % 2
+    def __init(hg: bool|QuadTree, hd: bool|QuadTree, bg: bool|QuadTree, bd: bool|QuadTree):
-g1 = green(pixel1) % 2
+        pass
-b1 = blue(pixel1) % 2
+    @property
-a1 = alpha(pixel1) % 2 
+    def depth(self) -> int:
+        """ Recursion depth of the quadtree"""
+        return 1
+    @staticmethod
+    def fromFile(filename):
+        # Your code here
+        pass
+    @staticmethod
+    def fromList(data):
+        pass 
+    
+    def paint(self):
+        """ Textual representation of the QuadTree"""
 
-first_letter = chr(bin2dec(''.join((r,g,b,a,r1,g1,b1,a1))))
+class TkQuadTree(QuadTree):
+    def paint(self):
+        """ TK representation of a Quadtree"""
 ```
-Vous aurez très probablement besoin d'utiliser PIL.
+
+Assurez-vous que la lecture du fichier se passe sans encombre, en lançant les tests unitaires :
 ```shell
-pip install pillow
+python -m pytest tests/test_quadtree.py -x
 ```
 
-## Exercice : Canaux cachés
+A partir du fichier `files/quadtree.txt`, générez le QuadTree associé. 
-La fonction fournie dans le fichier `files/canaux_caches.py` permets de vérifier si
+Puis, réalisez une interface graphique en utilisant la classe `TkQuadTree`, permettant de la représenter. 
-un code saisi est contenu dans la variable essai
 
-Saurez-vous écrire un programme qui permets à votre ordinateur à coup sûr en moins de 3 minutes de découvrir le code PIN saisi par l'utilisateur ? 
+Bonus : 
-L'ordinateur ne doit pas utiliser la variable pin mais uniquement la méthode checkpin.
+Remplacez les valeurs binaires des feuilles par des valeurs numériques, combinez celà à un [tileset](https://docs.godotengine.org/en/stable/_images/using_tilesets_kenney_abstract_platformer_tile_sheet.webp). 
-La fonction checkpin fournie ne dois pas être modifiée.
+Et voilà, vous avez généré votre tilemap par le biais d'un quadtree.

__init__.py

@@ -0,0 +1 @@
+import src

files/a_ski.txt

@@ -1 +0,0 @@
-67 104 97 113 117 101 32 103 233 110 233 114 97 116 105 111 110 32 97 32 115 111 110 32 112 104 105 108 111 115 111 112 104 101 44 32 233 99 114 105 118 97 105 110 32 111 117 32 97 114 116 105 115 116 101 32 113 117 105 32 115 97 105 115 105 116 32 101 116 10 105 110 99 97 114 110 101 32 108 39 105 109 97 103 105 110 97 105 114 101 32 100 117 32 109 111 109 101 110 116 46 32 73 108 32 97 114 114 105 118 101 32 113 117 101 32 99 101 115 32 112 104 105 108 111 115 111 112 104 101 115 32 115 111 105 101 110 116 10 114 101 99 111 110 110 117 115 32 100 101 32 108 101 117 114 32 118 105 118 97 110 116 44 32 109 97 105 115 32 108 101 32 112 108 117 115 32 115 111 117 118 101 110 116 32 105 108 32 102 97 117 116 32 97 116 116 101 110 100 114 101 32 113 117 101 32 108 97 10 112 97 116 105 110 101 32 100 117 32 116 101 109 112 115 32 102 97 115 115 101 32 115 111 110 32 101 102 102 101 116 46 32 81 117 101 32 99 101 116 116 101 32 114 101 99 111 110 110 97 105 115 115 97 110 99 101 32 115 111 105 116 10 105 109 109 233 100 105 97 116 101 32 111 117 32 100 105 102 102 233 114 233 101 44 32 117 110 101 32 233 112 111 113 117 101 32 101 115 116 32 109 97 114 113 117 233 101 32 112 97 114 32 99 101 115 32 104 111 109 109 101 115 32 113 117 105 10 101 120 112 114 105 109 101 110 116 32 108 101 117 114 115 32 105 100 233 97 117 120 44 32 100 97 110 115 32 108 101 115 32 109 117 114 109 117 114 101 115 32 100 39 117 110 32 112 111 232 109 101 32 111 117 32 100 97 110 115 32 108 101 10 103 114 111 110 100 101 109 101 110 116 32 100 39 117 110 32 109 111 117 118 101 109 101 110 116 32 112 111 108 105 116 105 113 117 101 46 32 78 111 116 114 101 32 103 233 110 233 114 97 116 105 111 110 32 97 32 117 110 10 112 104 105 108 111 115 111 112 104 101 46 32 67 101 32 110 39 101 115 116 32 110 105 32 117 110 32 97 114 116 105 115 116 101 32 110 105 32 117 110 32 233 99 114 105 118 97 105 110 46 32 67 39 101 115 116 32 117 110 10 105 110 102 111 114 109 97 116 105 99 105 101 110 46 10 

files/canaux_caches.py

@@ -1,12 +0,0 @@
-import time
-
-global pin
-
-def checkpin(essai):
-    for i in range(len(pin)):
-        time.sleep(1)
-        if pin[i]!= essai[i]:
-            return(False)
-    return(True)
-
-pin=input("Entrez un code PIN constitué de 6 chiffres entre 0 et 9 que l'ordinateur doit deviner : ")

files/cryptarithme.txt

@@ -1 +0,0 @@
-SEND + MORE = MONEY

files/quadtree.txt

@@ -0,0 +1,6 @@
+[
+       [0,0,0,[1,0,0,0]],
+       [0,0,[0,1,0,0],0],
+       [0,0,0,[[1,0,0,1],[0,0,1,1],0,0]],
+       [0,0,[[0,0,1,1],[0,1,1,0],0,0],0]
+]

files/quadtree_easy.txt

@@ -0,0 +1 @@
+[0,1,0,1]

files/shadoks.txt

@@ -1 +0,0 @@
-BU MEU ZO MEU GA GA

src/__init__.py

@@ -0,0 +1 @@
+from .quadtree import QuadTree, TkQuadTree

src/quadtree.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+class QuadTree:
+    NB_NODES : int = 4
+    def __init__(self, hg: bool | QuadTree, hd: bool | QuadTree, bd: bool | QuadTree,bg: bool | QuadTree):
+        pass
+
+    @property
+    def depth(self) -> int:
+        """ Recursion depth of the quadtree"""
+        return 1
+
+    @staticmethod
+    def fromFile(filename: str) -> QuadTree:
+        """ Open a given file, containing a textual representation of a list"""
+        pass
+
+    @staticmethod
+    def fromList(data: list) -> QuadTree:
+        """ Generates a Quadtree from a list representation"""
+        pass
+
+class TkQuadTree(QuadTree):
+    def paint(self):
+        """ TK representation of a Quadtree"""
+        pass

tests/test_quadtree.py

@@ -0,0 +1,15 @@
+
+import sys, os
+sys.path.append(os.path.realpath(os.path.dirname(__file__)+"/.."))
+
+from src import QuadTree, TkQuadTree
+
+def test_sample():
+    filename = "files/quadtree.txt"
+    q = QuadTree.fromFile(filename)
+    assert q.depth == 4
+
+def test_single():
+    filename = "files/quadtree_easy.txt"
+    q = QuadTree.fromFile(filename)
+    assert q.depth == 1