From 3c100a08fe2288e06e85857a0bcd60335ae7860d Mon Sep 17 00:00:00 2001
From: LordBaryhobal <lordbaryhobal@gmail.com>
Date: Tue, 28 Jan 2025 15:01:53 +0100
Subject: [PATCH] added ex3

---
 src/Ex3.py        | 76 +++++++++++++++++++++++++++++++++++++++++++++++
 tests/test_ex3.py | 21 ++++++++++++-
 2 files changed, 96 insertions(+), 1 deletion(-)
 create mode 100644 src/Ex3.py

diff --git a/src/Ex3.py b/src/Ex3.py
new file mode 100644
index 0000000..993d513
--- /dev/null
+++ b/src/Ex3.py
@@ -0,0 +1,76 @@
+
+"""
+Nom/Prénom: Heredero/Louis
+Explications:
+
+Comme indiqué dans la donnée de l'exercice, il s'agit ici de trouvé un sous-graphe
+connexe dans un graphe quelconque de consoles interconnectées
+
+Pour ce faire nous pouvons procéder ainsi:
+Étape 1 :
+- Compter le nombre de voisins de chaque nœud (console)
+- Éliminer ceux ayant moins de voisins que la taille de sous-graphe recherché
+  - Supprimer également les arêtes connectées à ces nœuds
+- Recommencer jusqu'à ce que :
+  a) il y ait moins de nœuds que la taille du sous-graphe recherché
+     -> il n'est donc pas possible de trouver un sous-graphe connexe de taille n
+  b) aucun nœud du graphe n'ait moins de voisins que voulu (aucune suppression de nœud)
+     -> il peut exister un sous-graphe connexe de taille n (Cf. étape 2)
+
+Étape 2 :
+- Pour chaque nœud du graphe :
+  - Calculer l'ensemble des nœuds communs entre ses voisins (et lui-même),
+    et les voisins des ses voisins (et eux-mêmes)'
+    C'est-à-dire, si N1 et un nœuds et nb(N1) = {N2, N3, ...} est l'ensemble de ses voisins,
+    on cherche l'intersection de {N1} U nb(N1), {N2} U nb(N2), {N3} U nb(N3), etc.
+  - Si c'est ensemble contient au moins n éléments, il s'agit alors d'un sous-graphe connexe.
+    On peut ainsi en extraire les n premiers nœuds comme résultat
+"""
+
+
+def findTightlyLinkedConsoles(n: int, consoles: list[tuple[int, int]]) -> list[int]:
+    nodes: dict[int, set[int]] = {}
+
+    for i1, i2 in consoles:
+        if i1 not in nodes:
+            nodes[i1] = set()
+        if i2 not in nodes:
+            nodes[i2] = set()
+        nodes[i1].add(i2)
+        nodes[i2].add(i1)
+
+    while True:
+        removed: set[int] = set()
+        for node, neighbors in nodes.items():
+            if len(neighbors) < n - 1:
+                removed.add(node)
+
+        if len(removed) == 0:
+            break
+
+        new_nodes = {}
+        for node, neighbors in nodes.items():
+            if node in removed:
+                continue
+            new_nodes[node] = neighbors - removed
+
+        nodes = new_nodes
+
+        if len(nodes) < n:
+            return []
+
+    for node, neighbors in nodes.items():
+        common: set[int] = neighbors | {node}
+        for nb in neighbors:
+            common = common.intersection(nodes[nb] | {nb})
+
+        if len(common) >= n:
+            return list(sorted(common))[:n]
+
+    return []
+
+
+if __name__ == '__main__':
+    print(findTightlyLinkedConsoles(3,[(0,1),(0,4),(2,1),(3,1),(4,2),(2,3)]) == [1,2,3])
+    print(findTightlyLinkedConsoles(4,[(0,1),(0,4),(2,1),(3,1),(4,2),(2,3)]) == [])
+    print(findTightlyLinkedConsoles(4,[(0,1),(0,4),(2,1),(3,1),(4,2),(2,3),(1,4),(4,3)]) == [1,2,3,4])
diff --git a/tests/test_ex3.py b/tests/test_ex3.py
index b24a888..2a68eed 100644
--- a/tests/test_ex3.py
+++ b/tests/test_ex3.py
@@ -1,8 +1,27 @@
 import unittest
 
+from Ex3 import findTightlyLinkedConsoles
+
+
 class MyTestCase(unittest.TestCase):
     def test_simple1(self):
-        pass
+        self.assertEqual(
+            findTightlyLinkedConsoles(3,[(0,1),(0,4),(2,1),(3,1),(4,2),(2,3)]),
+            [1,2,3]
+        )
+
+    def test_simple2(self):
+        self.assertEqual(
+            findTightlyLinkedConsoles(4,[(0,1),(0,4),(2,1),(3,1),(4,2),(2,3)]),
+            []
+        )
+
+    def test_simple3(self):
+        self.assertEqual(
+            findTightlyLinkedConsoles(4,[(0,1),(0,4),(2,1),(3,1),(4,2),(2,3),(1,4),(4,3)]),
+            [1,2,3,4]
+        )
+
 
 if __name__ == '__main__':
     unittest.main()