Informatique Tronc Commun MP : Théorie, Algorithmes, Python, SQL

Informatique Tronc Commun MP
L’Intégrale : Théorie, Algorithmes, Code Python & SQL
Table des matières
1 Architecture et Représentation des Nombres 1
1.1 Entiers:LeComplémentà2 ............................................ 1
1.2 LesFlottants(Nombresàvirgule) ......................................... 1
2 Algorithmique, Complexité et Tris 1
2.1 TableauRécapitulatifdesTris............................................ 2
2.2 Preuve d’algorithme : La Recherche Dichotomique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
3 Programmation Dynamique 2
4 Théorie des Graphes et Plus Courts Chemins 3
4.1 ReprésentationetParcours ............................................. 3
5 Intelligence Artificielle et Algorithmes de Jeux 4
5.1 Apprentissage Automatique (Machine Learning) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
5.2 Algorithme Min-Max (Jeux à deux joueurs) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
6 Bases de Données (SQL) - Maîtrise des Requêtes 4
6.1 PrincipesFondamentaux............................................... 4
6.2 Requêtes d’Annale (BDD Bibliothèque) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1 Architecture et Représentation des Nombres
1.1 Entiers : Le Complément à 2
Pour représenter les entiers négatifs en machine, on utilise le complément à 2.
Convertir un nombre négatif (ex : -6 sur 4 bits)
1. On prend la valeur absolue en binaire : |−6|= 6 =⇒01102. 2. On inverse tous les bits (les 0 deviennent 1, les
1 deviennent 0) : 10012. 3. On ajoute 1 au résultat : 10012+ 1 = 10102. Donc −6s’écrit 10102sur 4 bits.
1.2 Les Flottants (Nombres à virgule)
Les réels ne sont pas tous représentables exactement en machine à cause de la taille mémoire finie (64 bits pour un float
classique). La norme IEEE 754 utilise une écriture scientifique binaire : (−1)s×m×2e.
Le danger des flottants
Ne jamais tester l’égalité stricte entre deux flottants (a == b). À cause des erreurs d’arrondi, 0.1 + 0.2ne vaut pas
exactement 0.3en Python. Il faut utiliser une tolérance absolue : abs(a - b) < 1e-9.
2 Algorithmique, Complexité et Tris
La complexité asymptotique O(f(n)) mesure comment le temps d’exécution (ou l’espace mémoire) croît avec la taille n
des données.
1

2.1 Tableau Récapitulatif des Tris
Algorithme Principe Complexité pire cas
Sélection On cherche le minimum de la liste restante et on
l’échange avec le premier élément non trié.
O(n2)
Insertion On insère les éléments un par un à leur bonne place
dans la partie déjà triée (comme des cartes à jouer).
O(n2)
À Bulles On parcourt la liste en permutant les éléments consé-
cutifs s’ils sont dans le mauvais ordre.
O(n2)
Fusion On coupe la liste en 2, on trie récursivement chaque
moitié, puis on fusionne les deux listes.
O(nlog n)
Rapide (Quicksort) On choisit un pivot. On place les éléments plus petits
à gauche, les plus grands à droite, et on trie récursi-
vement.
O(n2)(Moy : O(nlog n))
2.2 Preuve d’algorithme : La Recherche Dichotomique
Pour trouver un élément dans une liste triée, on coupe l’espace de recherche en deux à chaque itération.
—Variant de boucle (Terminaison) : La quantité j−i(indice de fin - indice de début) est un entier strictement
décroissant et minoré par 0.
—Invariant de boucle (Correction) : Si l’élément cherché est dans la liste, alors il est forcément situé entre les
indices iet jactuels.
3 Programmation Dynamique
La programmation dynamique résout le problème du chevauchement des sous-problèmes en stockant les résultats intermé-
diaires, contrairement à un algorithme glouton qui fait un choix optimal local sans garantie de succès global.
Problème type : Trouver le chemin maximisant la somme dans une pyramide de nombres, du sommet vers la base.
1. Approche Top-Down (Récursif avec Mémoïsation)
On part du sommet. Si un calcul a déjà été fait, on lit le dictionnaire memo.
1def max_path_top_down(pyramide, i=0, j=0, memo=None):
2if memo is None:
3memo ={} # Initialisation du dictionnaire mémoire
4
5# Condition d'arrêt : on est sur la dernière ligne (la base)
6if i== len(pyramide) - 1:
7return pyramide[i][j]
8
9# Si le résultat est déjà connu, on le renvoie directement !
10 if (i, j) in memo:
11 return memo[(i, j)]
12
13 # Sinon, on calcule les chemins gauche et droit
14 gauche =max_path_top_down(pyramide, i+1, j, memo)
15 droite =max_path_top_down(pyramide, i+1, j+1, memo)
16
17 # On stocke le résultat maximal dans la mémoire
18 res =pyramide[i][j] +max(gauche, droite)
19 memo[(i, j)] =res
20
21 return res
2

2. Approche Bottom-Up (Itératif)
On part de la base (la dernière ligne) et on remonte vers le sommet en écrasant les valeurs avec les maximums
cumulés. Plus rapide car on évite la pile d’appels récursifs.
1def max_path_bottom_up(pyramide):
2# Copie de la dernière ligne
3dp =list(pyramide[-1])
4
5# On remonte de l'avant-dernière ligne jusqu'au sommet
6for iin range(len(pyramide)-2,-1,-1):
7for jin range(len(pyramide[i])):
8# Le chemin max est la case actuelle + le max des deux cases en dessous
9dp[j] =pyramide[i][j] +max(dp[j], dp[j+1])
10
11 return dp[0]# Le résultat final est au sommet
4 Théorie des Graphes et Plus Courts Chemins
4.1 Représentation et Parcours
—Matrice d’adjacence :M[i][j] = 1 s’il y a une arête de ivers j. Lourde en mémoire O(S2).
—Liste d’adjacence :graphe[0] = [(1, poids), (5, poids)]. Idéale pour les graphes creux.
—Parcours en Largeur (BFS) : Utilise une File (Queue). Explore en cercles concentriques.
—Parcours en Profondeur (DFS) : Utilise une Pile (Stack) ou la récursivité.
Algorithme de Dijkstra (Plus Court Chemin)
L’algorithme de Dijkstra cherche la distance minimale entre un sommet de départ et tous les autres dans un graphe
à pondérations positives. S’il y a une heuristique pour guider la recherche, cela devient l’algorithme A*.
1def dijkstra(graphe, depart):
2n=len(graphe)
3distances =[float('inf')] *n
4distances[depart] = 0
5a_traiter =list(range(n)) # Sommets non fixés
6
7while len(a_traiter) > 0:
8# 1. On cherche le sommet 'u'non visité de distance minimale
9u=a_traiter[0]
10 for sin a_traiter:
11 if distances[s] <distances[u]:
12 u=s
13
14 a_traiter.remove(u)
15
16 # Si la distance minimale est infinie, le reste est inaccessible
17 if distances[u] == float('inf'):
18 break
19
20 # 2. Relâchement (Mise à jour des voisins)
21 for voisin, poids in graphe[u]:
22 nouvelle_dist =distances[u] +poids
23 if nouvelle_dist <distances[voisin]:
24 distances[voisin] =nouvelle_dist
25
26 return distances
3

5 Intelligence Artificielle et Algorithmes de Jeux
5.1 Apprentissage Automatique (Machine Learning)
Il faut systématiquement centrer et réduire (normaliser) les données avant de calculer des distances.
—Supervisé (K-NN - K Plus Proches Voisins) : On calcule la distance entre un inconnu et toute la base. On
prend les Kplus proches, et la classe majoritaire l’emporte. On évalue la fiabilité avec une Matrice de Confusion
(Diagonale = bonnes prédictions).
—Non-Supervisé (K-Means) : On veut regrouper un nuage de points sans étiquette en kclusters. On itère en
attribuant les points au centre le plus proche, puis on recalcule les centres.
5.2 Algorithme Min-Max (Jeux à deux joueurs)
S’applique aux jeux à information parfaite (Échecs, Wythoff). L’arbre des possibles est un graphe biparti. Le joueur MAX
cherche le coup qui maximise le score, en simulant que le joueur MIN jouera toujours le coup qui minimise ce score.
Implémentation de l’Algorithme Min-Max
1def min_max(position, profondeur, joueur_max):
2# Condition d'arrêt : fin du jeu ou limite de profondeur
3if profondeur ==0or est_partie_terminee(position):
4return evaluer_heuristique(position)
5
6if joueur_max == True:# Tour du joueur 1 (MAX)
7max_eval = -float('inf')
8for coup in coups_possibles(position):
9# On simule le coup et on passe le tour (False)
10 evaluation =min_max(jouer_coup(position, coup), profondeur - 1,False)
11 max_eval =max(max_eval, evaluation)
12 return max_eval
13
14 else:# Tour du joueur 2 (MIN)
15 min_eval =float('inf')
16 for coup in coups_possibles(position):
17 # On simule le coup et on repasse le tour (True)
18 evaluation =min_max(jouer_coup(position, coup), profondeur - 1,True)
19 min_eval =min(min_eval, evaluation)
20 return min_eval
6 Bases de Données (SQL) - Maîtrise des Requêtes
En prépa, on exige de maîtriser les jointures (JOIN), les fonctions d’agrégation avec filtrage (GROUP BY ... HAVING), et
les sous-requêtes.
6.1 Principes Fondamentaux
—Clé Primaire : Attribut unique identifiant une ligne (ex : isbn).
—Clé Étrangère : Attribut qui fait référence à la clé primaire d’une autre table (création du lien relationnel).
—Différence WHERE / HAVING :WHERE filtre les lignes avant le regroupement. HAVING filtre après un GROUP
BY (indispensable si on veut filtrer avec un COUNT ou un AVG).
6.2 Requêtes d’Annale (BDD Bibliothèque)
Noms des bibliothèques possédant au moins 3 livres différents
SELECT Bibliotheque.nom, AVG(Livre.annee) AS annee_moyenne
FROM Bibliotheque
JOIN Inventaire ON Bibliotheque.id =Inventaire.biblio
JOIN Livre ON Inventaire.isbn =Livre.isbn
GROUP BY Bibliotheque.id, Bibliotheque.nom
HAVING COUNT(DISTINCT Livre.isbn) >= 3;
4

Noms des auteurs en vie ayant écrit plus de livres que la moyenne
Utilisation obligatoire d’une sous-requête pour calculer la moyenne globale.
SELECT Auteur.nom, Auteur.prenom
FROM Auteur
JOIN Livre ON Auteur.id =Livre.auteur
WHERE Auteur.mort IS NULL -- Filtre avant regroupement (Auteurs en vie)
GROUP BY Auteur.id, Auteur.nom, Auteur.prenom
HAVING COUNT(Livre.isbn) >(
-- Sous-requête scalaire (Moyenne de livres par auteur)
SELECT CAST(COUNT(isbn) AS FLOAT)/COUNT(DISTINCT auteur)
FROM Livre
);
Statistiques complètes de l’inventaire des livres
SELECT
Livre.titre AS Titre_Livre,
COUNT(DISTINCT Inventaire.biblio) AS Nombre_Bibliotheques,
SUM(Inventaire.nb_ex) AS Total_Exemplaires,
CAST(SUM(Inventaire.nb_ex) AS FLOAT)/COUNT(DISTINCT Inventaire.biblio)
AS Moyenne_Par_Biblio
FROM Livre
JOIN Inventaire ON Livre.isbn =Inventaire.isbn
GROUP BY Livre.isbn, Livre.titre;
5