diff --git a/architecture/historique/README.md b/architecture/historique/README.md index 2b4f2e7..23ee16c 100644 --- a/architecture/historique/README.md +++ b/architecture/historique/README.md @@ -14,7 +14,7 @@ Cependant, tout n'est pas réalisable pour ces machines, et il faudra attendre q -Mais plus encore que Bubbage, c'est une femme du nom d'[Ada Lovelace](https://www.franceculture.fr/numerique/ada-lovelace-la-premiere-codeuse-de-lhistoire) qui fera la plus belle percée dans ce domaine : +Mais plus encore que Babbage, c'est une femme du nom d'[Ada Lovelace](https://www.franceculture.fr/numerique/ada-lovelace-la-premiere-codeuse-de-lhistoire) qui fera la plus belle percée dans ce domaine : Elle souhaite avant tout créer une science poétique, dans laquelle on pourrait voir les prémisses de l’intelligence artificielle d’aujourd’hui. diff --git a/architecture/os/nsi.vbox b/architecture/os/nsi.vbox deleted file mode 100644 index fac99bf..0000000 --- a/architecture/os/nsi.vbox +++ /dev/null @@ -1,82 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/representation_construits/chapitre_1/projet/correction 2.py b/representation_construits/chapitre_1/projet/correction 2.py new file mode 100644 index 0000000..d2754a0 --- /dev/null +++ b/representation_construits/chapitre_1/projet/correction 2.py @@ -0,0 +1,161 @@ +#! /usr/bin/env python3 +# -*- coding : utf-8 -*- +# Author : Philippe BODDAERT +# Date : 01/08/2021 +# License : CC-BY-NC-SA + +import random, sys +from paint import dessiner, ROUGE, JAUNE, BLANC, BLEU, VERT + +def creer_fils(couleur, longueur = 10): + ''' + Créé un fils d'une longueur donnée + :param couleur: (int) la couleur du fils + :param longueur: (int) la longueur du fils + :return: (list) Un fils sous la forme d'un tableau + ''' + return [couleur] * longueur + +def creer_bombe(couleurs): + ''' + Créé une bombe de fils + :param couleurs: (list) les couleurs des fils + :return: (list) Un tableau de fils + ''' + bombe = [] + for c in couleurs: + bombe.append(creer_fils(c, 20)) + return bombe + +def creer_combinaison(longueur): + ''' + Créé une combinaison de couleurs de fils + :param longueur: (int) le nombre de fils + :return: (list) Un tableau de couleurs + ''' + return [ random.choice([ROUGE, VERT, JAUNE, BLEU, BLANC]) for _ in range(longueur)] + +def creer_numero_serie(longueur = 8): + ''' + Créé un numéro de série d'une longueur donnée + :param longueur: (int) longueur du numéro + :return: (str) un numéro de longueurdonnée + ''' + return str(random.randrange(0, 10**longueur)).zfill(8) + +def afficher_bombe(bombe): + ''' + Affiche une bombe de fils + :param bombe: (list) une bombe de fils + ''' + dessiner(bombe) + +def couleur_fils(fils): + ''' + Obtient la couleur d'un fils + :param fils: (list) Un fil + :return: (int) la couleur du fil + ''' + return fils[0] + +def compter_fils(bombe, couleur): + ''' + Compte le nombre de fils de la couleur donnée + :param bombe: (list) un tableau de fils + :pram couleur: (int) une couleur + :return: (int) Le nombre de fils de la couleur donnée + ''' + nb = 0 + for fils in bombe: + if couleur_fils(fils) == couleur: + nb += 1 + return nb + +def indice_dernier_fils(bombe, couleur): + ''' + Détermine le dernier indice du fils de la couleur donnée + :param bombe: (list) une bombe de fils + :param couleur: (int) une couleur + :return: (int) l'indice du fils, -1 sinon + ''' + i = len(bombe) - 1 + while i >= 0 and couleur_fils(bombe[i]) != couleur: + i -= 1 + return i + +def est_dernier_chiffre_impair(numero): + ''' + Détermine si le dernier chiffre du numéro de série est impair + :param numero: (str) un numéro de série + :return: (bool) True si le dernier chiffre est impair, False sinon + ''' + return int(numero) % 2 == 1 + +def est_bon_fil_a_couper(bombe, indice, numero_serie=None): + ''' + Détermine si le fil à l'indice donné est celui à couper + :param bombe: (list) une bombe de fils + :param indice: (int) l'indice du fils à couper + :return: (bool) True si le fils est le bon, False sinon + ''' + n = len(bombe) + if n == 3: + if compter_fils(bombe, ROUGE) == 0: + return indice == 1 + elif couleur_fils(bombe[n - 1]) == BLANC: + return indice == n - 1 + elif compter_fils(bombe, BLEU) > 1: + return indice == indice_dernier_fils(bombe, BLEU) + else: + return indice == n - 1 + elif n == 4: + if compter_fils(bombe, ROUGE) > 1 and est_dernier_chiffre_impair(numero_serie): + return indice == indice_dernier_fils(bombe, ROUGE) + elif couleur_fils(bombe[n - 1]) == JAUNE and compter_fils(bombe, ROUGE) == 0: + return indice == 0 + elif compter_fils(bombe, BLEU) == 1: + return indice == 0 + elif compter_fils(bombe, JAUNE) > 1: + return indice == n - 1 + else: + return indice == 1 + elif n == 5: + if couleur_fils(bombe[n - 1]) == VERT and est_dernier_chiffre_impair(numero_serie): + return indice == 3 + elif compter_fils(bombe, ROUGE) == 1 and compter_fils(bombe, JAUNE) > 1: + return indice == 0 + elif compter_fils(bombe, VERT) == 0: + return indice == 1 + else: + return indice == 0 + else: + if compter_fils(bombe, JAUNE) == 0 and est_dernier_chiffre_impair(numero_serie): + return indice == 2 + elif compter_fils(bombe, JAUNE) == 1 and compter_fils(bombe, BLANC) > 1: + return indice == 3 + elif compter_fils(bombe, ROUGE) == 0: + return indice == n - 1 + else: + return indice == 3 + +if __name__ == '__main__': + combinaison = 3 + numero_serie = None + if len(sys.argv) > 1: + combinaison = int(sys.argv[1]) + if combinaison > 3: + numero_serie = creer_numero_serie() + + bombe = creer_bombe(creer_combinaison(combinaison)) + + if numero_serie is not None: + print(f"n°{numero_serie}") + + afficher_bombe(bombe) + + indice = input('Indice du fils à couper : ') + + if est_bon_fil_a_couper(bombe, int(indice), numero_serie): + print('Sauvé !!!') + else: + print('Perdu, la bombe a explosé') \ No newline at end of file diff --git a/representation_construits/chapitre_1/projet/correction.py b/representation_construits/chapitre_1/projet/correction.py new file mode 100644 index 0000000..d2754a0 --- /dev/null +++ b/representation_construits/chapitre_1/projet/correction.py @@ -0,0 +1,161 @@ +#! /usr/bin/env python3 +# -*- coding : utf-8 -*- +# Author : Philippe BODDAERT +# Date : 01/08/2021 +# License : CC-BY-NC-SA + +import random, sys +from paint import dessiner, ROUGE, JAUNE, BLANC, BLEU, VERT + +def creer_fils(couleur, longueur = 10): + ''' + Créé un fils d'une longueur donnée + :param couleur: (int) la couleur du fils + :param longueur: (int) la longueur du fils + :return: (list) Un fils sous la forme d'un tableau + ''' + return [couleur] * longueur + +def creer_bombe(couleurs): + ''' + Créé une bombe de fils + :param couleurs: (list) les couleurs des fils + :return: (list) Un tableau de fils + ''' + bombe = [] + for c in couleurs: + bombe.append(creer_fils(c, 20)) + return bombe + +def creer_combinaison(longueur): + ''' + Créé une combinaison de couleurs de fils + :param longueur: (int) le nombre de fils + :return: (list) Un tableau de couleurs + ''' + return [ random.choice([ROUGE, VERT, JAUNE, BLEU, BLANC]) for _ in range(longueur)] + +def creer_numero_serie(longueur = 8): + ''' + Créé un numéro de série d'une longueur donnée + :param longueur: (int) longueur du numéro + :return: (str) un numéro de longueurdonnée + ''' + return str(random.randrange(0, 10**longueur)).zfill(8) + +def afficher_bombe(bombe): + ''' + Affiche une bombe de fils + :param bombe: (list) une bombe de fils + ''' + dessiner(bombe) + +def couleur_fils(fils): + ''' + Obtient la couleur d'un fils + :param fils: (list) Un fil + :return: (int) la couleur du fil + ''' + return fils[0] + +def compter_fils(bombe, couleur): + ''' + Compte le nombre de fils de la couleur donnée + :param bombe: (list) un tableau de fils + :pram couleur: (int) une couleur + :return: (int) Le nombre de fils de la couleur donnée + ''' + nb = 0 + for fils in bombe: + if couleur_fils(fils) == couleur: + nb += 1 + return nb + +def indice_dernier_fils(bombe, couleur): + ''' + Détermine le dernier indice du fils de la couleur donnée + :param bombe: (list) une bombe de fils + :param couleur: (int) une couleur + :return: (int) l'indice du fils, -1 sinon + ''' + i = len(bombe) - 1 + while i >= 0 and couleur_fils(bombe[i]) != couleur: + i -= 1 + return i + +def est_dernier_chiffre_impair(numero): + ''' + Détermine si le dernier chiffre du numéro de série est impair + :param numero: (str) un numéro de série + :return: (bool) True si le dernier chiffre est impair, False sinon + ''' + return int(numero) % 2 == 1 + +def est_bon_fil_a_couper(bombe, indice, numero_serie=None): + ''' + Détermine si le fil à l'indice donné est celui à couper + :param bombe: (list) une bombe de fils + :param indice: (int) l'indice du fils à couper + :return: (bool) True si le fils est le bon, False sinon + ''' + n = len(bombe) + if n == 3: + if compter_fils(bombe, ROUGE) == 0: + return indice == 1 + elif couleur_fils(bombe[n - 1]) == BLANC: + return indice == n - 1 + elif compter_fils(bombe, BLEU) > 1: + return indice == indice_dernier_fils(bombe, BLEU) + else: + return indice == n - 1 + elif n == 4: + if compter_fils(bombe, ROUGE) > 1 and est_dernier_chiffre_impair(numero_serie): + return indice == indice_dernier_fils(bombe, ROUGE) + elif couleur_fils(bombe[n - 1]) == JAUNE and compter_fils(bombe, ROUGE) == 0: + return indice == 0 + elif compter_fils(bombe, BLEU) == 1: + return indice == 0 + elif compter_fils(bombe, JAUNE) > 1: + return indice == n - 1 + else: + return indice == 1 + elif n == 5: + if couleur_fils(bombe[n - 1]) == VERT and est_dernier_chiffre_impair(numero_serie): + return indice == 3 + elif compter_fils(bombe, ROUGE) == 1 and compter_fils(bombe, JAUNE) > 1: + return indice == 0 + elif compter_fils(bombe, VERT) == 0: + return indice == 1 + else: + return indice == 0 + else: + if compter_fils(bombe, JAUNE) == 0 and est_dernier_chiffre_impair(numero_serie): + return indice == 2 + elif compter_fils(bombe, JAUNE) == 1 and compter_fils(bombe, BLANC) > 1: + return indice == 3 + elif compter_fils(bombe, ROUGE) == 0: + return indice == n - 1 + else: + return indice == 3 + +if __name__ == '__main__': + combinaison = 3 + numero_serie = None + if len(sys.argv) > 1: + combinaison = int(sys.argv[1]) + if combinaison > 3: + numero_serie = creer_numero_serie() + + bombe = creer_bombe(creer_combinaison(combinaison)) + + if numero_serie is not None: + print(f"n°{numero_serie}") + + afficher_bombe(bombe) + + indice = input('Indice du fils à couper : ') + + if est_bon_fil_a_couper(bombe, int(indice), numero_serie): + print('Sauvé !!!') + else: + print('Perdu, la bombe a explosé') \ No newline at end of file diff --git a/representation_construits/chapitre_1/td/correction.ipynb b/representation_construits/chapitre_1/td/correction.ipynb new file mode 100644 index 0000000..62d8aff --- /dev/null +++ b/representation_construits/chapitre_1/td/correction.ipynb @@ -0,0 +1,940 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TD : Les Listes\n", + "\n", + "Ce TD va nous permettre de manipuler les listes en Python." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Rappel\n", + "\n", + "Pour créer une liste en python, la syntaxe est la suivante :\n", + "\n", + "```python\n", + ">>> liste = []\n", + "```\n", + "\n", + "Pour ajouter un élément à une liste, on utilise la méthode `append` :\n", + "\n", + "```python\n", + ">>> liste.append('NSI')\n", + ">>> liste.append('ANGLAIS')\n", + ">>> liste\n", + "['NSI', 'ANGLAIS']\n", + "```\n", + "\n", + "Pour accéder à un élément, on utilise son **indice** :\n", + "\n", + "```python\n", + ">>> liste[0]\n", + "'NSI'\n", + ">>> liste[1]\n", + "'ANGLAIS'\n", + "```\n", + "\n", + "Il est également possible de créer une liste avec un ensemble d'éléments :\n", + "\n", + "```python\n", + ">>> liste = ['NSI', 'ANGLAIS', 'PHYSIQUE']\n", + ">>> liste\n", + "['NSI', 'ANGLAIS', 'PHYSIQUE']\n", + "```\n", + "\n", + "Il est possible d'obtenir la taille d'une liste, i.e le nombre d'éléments grâce à la méthode `len` :\n", + "\n", + "```python\n", + ">>> len(liste)\n", + "3\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Exercices" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercice 1 : Création de listes\n", + "\n", + "1. Créer contenant l'ensemble des noms des personnes dans la salle de TP\n", + "2. Créer contenant l'ensemble des entiers pairs entre 0 et 20 inclus,\n", + "3. Afficher uniquement les entiers du liste, construit à la question 2, qui sont multiples de 4.\n", + "4. Créer une fonction `aleatoire` qui renvoie une liste de valeurs aléatoires. Elle prend 3 entiers en paramètre :\n", + " - $n$ : le nombre d'éléments du liste\n", + " - $min$ : la valeur minimale possible\n", + " - $max$ : la valeur maximale possible" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 1\n", + "personnes = ['Albert', 'Bertrand', 'Camille']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 2\n", + "pairs = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 3\n", + "for entier in pairs:\n", + " if entier % 4 == 0:\n", + " print(entier)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 4\n", + "import random\n", + "def aleatoire(n, min, max):\n", + " liste = []\n", + " for i in range(n):\n", + " liste.append(random.randint(min, max))\n", + " return liste" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercice 2 : Parcours et Recherche\n", + "\n", + "```python\n", + ">>> groupe_1 = ['Alan', 'Brice', 'Chloé', 'Damien', 'Eléonore', 'Farid']\n", + ">>> groupe_2 = ['Damien', 'Killian', 'Margot', 'Tom', 'Hugo', 'Killian']\n", + "```\n", + "\n", + "1. Écrire une fonction `indice` qui prend en paramètre une liste de noms et un nom et permet d'obtenir l'indice du nom dans la liste.\n", + "2. Écrire une fonction `est_present` qui prend en paramètre une liste et un nom et renvoie True si le nom est présent dans la liste, False sinon.\n", + "3. Écrire une fonction `indices` qui prend en paramètre une liste de noms et un nom et permet d'obtenir l'ensemble des indices du nom dans la liste.\n", + "4. Écrire une fonction `compte` qui prend en paramètre une liste de noms et un nom et permet d'obtenir le nombre d'occurrences du nom dans la liste." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 1\n", + "def indice(liste, element):\n", + " '''\n", + " Indique l'indice où se situe l'élément dans le liste\n", + " :param liste: (list) une liste\n", + " :param element: (any) un élément\n", + " :return: (int) le premier indice de l'élément dans le liste, None sinon\n", + " :doctest:\n", + " >>> indice([0, 1, 2, 3], 1)\n", + " 1\n", + " >>> indice([], 1) is None\n", + " True\n", + " >>> indice([3, 2, 0, 1], 1)\n", + " 3\n", + " >>> indice([3, 2, 1, 1], 1)\n", + " 2\n", + " '''\n", + " i = 0\n", + " while i < len(liste) and liste[i] != element:\n", + " i += 1\n", + " if i == len(liste):\n", + " return None\n", + " return i" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 2\n", + "def est_present(liste, element):\n", + " '''\n", + " Indique si l'élément est dans la liste\n", + " :param liste: (list) une liste\n", + " :param element: (any) un élément\n", + " :return: (bool) True si l'élément est dans la liste, False sinon\n", + " :doctest;\n", + " >>> est_present([0, 1, 2, 3], 1)\n", + " True\n", + " >>> est_present([], 1)\n", + " False\n", + " >>> est_present(['Belgique', 'Pays-Bas', 'Luxembourg'], 'France')\n", + " False\n", + " >>> est_present([3, 2, 1, 1], 1)\n", + " True\n", + " '''\n", + " return indice(liste, element) is not None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 3\n", + "def indices(liste, element):\n", + " '''\n", + " Indique les indices où se situent l'élément dans le liste\n", + " :param liste: (list) une liste\n", + " :param element: (any) un élément\n", + " :return: (list) les indices de l'élément dans le liste\n", + " :doctest:\n", + " >>> indices([0, 1, 2, 3], 1)\n", + " [1]\n", + " >>> indices([], 1)\n", + " []\n", + " >>> indices([3, 2, 0, 1], 1)\n", + " [3]\n", + " >>> indices([3, 1, 2, 1], 1)\n", + " [1, 3]\n", + " '''\n", + " i = []\n", + " for j in range(len(liste)):\n", + " if liste[j] == element:\n", + " i.append(j)\n", + " return i" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 4\n", + "def compte(liste, element):\n", + " '''\n", + " Compte le nombre d'occurrences de l'élément dans le liste\n", + " :param liste: (list) une liste\n", + " :param element: (any) un élément\n", + " ;return: (int) le nombre d'occurrences de l'élément dans le liste\n", + " :doctest:\n", + " >>> compte([], 1)\n", + " 0\n", + " >>> compte([1], 1)\n", + " 1\n", + " >>> compte([0], 1)\n", + " 0\n", + " >>> compte([1, 0, 1, 0], 1)\n", + " 2\n", + " '''\n", + " occurrences = 0\n", + " for x in liste:\n", + " if x == element:\n", + " occurrences += 1\n", + " return occurrences" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercice 3 : Agrégation\n", + "\n", + "```python\n", + ">>> notes = [14.5, 13, 7, 10.25, 16, 12.5, 9.5]\n", + "```\n", + "\n", + "1. Écrire une fonction `somme` qui prend en paramètre une liste de flottants et renvoie la somme des valeurs du liste.\n", + "2. Écrire une fonction `moyenne` qui prend en paramètre une liste de flottants et renvoie la valeur moyenne du liste.\n", + "3. Écrire une fonction `maximum` qui prend en paramètre une liste de flottants et renvoie la valeur maximale du liste. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 1\n", + "def somme(liste):\n", + " '''\n", + " Calcule la somme des éléments du liste\n", + " :param liste: (list) une liste\n", + " :return: (int) la somme\n", + " :doctest:\n", + " >>> somme([1, 2, 3])\n", + " 6\n", + " >>> somme([1, -2, 3])\n", + " 2\n", + " >>> somme([])\n", + " 0\n", + " '''\n", + " _somme = 0\n", + " for element in liste:\n", + " _somme += element\n", + " return _somme" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 2\n", + "def moyenne(liste):\n", + " '''\n", + " Calcule la moyenne des éléments du liste\n", + " :param liste: (list) une liste\n", + " :return: (float) la moyenne des éléments du liste\n", + " :doctest:\n", + " >>> moyenne([1, 1, 1])\n", + " 1.0\n", + " >>> moyenne([1, 2, 3])\n", + " 2.0\n", + " >>> moyenne([])\n", + " Traceback (most recent call last):\n", + " ...\n", + " ZeroDivisionError: division by zero\n", + " '''\n", + " return somme(liste) / len(liste)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 3\n", + "def maximum(liste):\n", + " '''\n", + " Trouve l'élément avec la valeur maximale du liste\n", + " :param liste: (list) une liste\n", + " :return: (int) l'élément de valeur maximale\n", + " :doctest:\n", + " >>> maximum([1, 2, 3])\n", + " 3\n", + " >>> maximum([-1, -2, -3])\n", + " -1\n", + " >>> maximum([]) is None\n", + " True\n", + " '''\n", + " if len(liste) == 0:\n", + " return None\n", + " max = liste[0]\n", + " for element in liste:\n", + " if element > max:\n", + " max = element\n", + " return max" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercice 4 : Manipulations sur les listes\n", + "\n", + "Pour tester les fonctions de manipulations, nous utiliserons le Code Konami[wikipédia](https://fr.wikipedia.org/wiki/Code_Konami)\n", + "\n", + "```python\n", + ">>> code = [\"↑\", \"↑\", \"↓\",\"↓\", \"←\", \"→\", \"←\", \"→\", \"B\", \"A\"]\n", + "```\n", + "\n", + "1. Écrire une méthode `inverser` qui prend en paramètre une liste et a pour effet de bord d'inverser l'ensemble des valeurs du liste.\n", + "2. Écrire une fonction `copie` qui prend en paramètre une liste et renvoie une copie du liste.\n", + "3. Écrire une méthode `dedoublonner` qui prend en paramètre une liste et a pour effet de bord de supprimer les doublons d'une même valeur. \n", + "4. Écrire une fonction `tranche` qui prend en paramètre une liste et deux entiers $min$ et $max$, et renvoie le sous-liste entre $min$ et $max$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 1\n", + "def inverser(liste):\n", + " '''\n", + " Inverse les éléments du liste\n", + " :param liste: (list) une liste\n", + " :doctest:\n", + " >>> t = [1, 2, 3]\n", + " >>> inverser(t)\n", + " >>> t\n", + " [3, 2, 1]\n", + " >>> t = ['b', 'o', 'n', 'j', 'o', 'u', 'r']\n", + " >>> inverser(t)\n", + " >>> t\n", + " ['r', 'u', 'o', 'j', 'n', 'o', 'b']\n", + " '''\n", + " debut = 0\n", + " fin = len(liste) - 1\n", + " \n", + " while debut < fin:\n", + " liste[debut], liste[fin] = liste[fin], liste[debut]\n", + " debut += 1\n", + " fin -= 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 2\n", + "def copie(liste):\n", + " '''\n", + " Renvoie une copie du liste\n", + " :param liste: (list) une liste\n", + " :return: (list) une copie du liste\n", + " :doctest:\n", + " >>> copie([1, 1, 1, 1])\n", + " [1, 1, 1, 1]\n", + " >>> copie([1, 2, 3, 4])\n", + " [1, 2, 3, 4]\n", + " >>> copie([])\n", + " []\n", + " '''\n", + " resultat = []\n", + " for element in liste:\n", + " resultat.append(element)\n", + " return resultat" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 3\n", + "def dedoublonner(liste):\n", + " '''\n", + " Renvoie une liste sans doublant\n", + " :param liste: (list) une liste\n", + " :return: (list) le liste sans doublon\n", + " :doctest:\n", + " >>> dedoublonner([1, 1, 1, 1])\n", + " [1]\n", + " >>> dedoublonner([1, 2, 3, 4])\n", + " [1, 2, 3, 4]\n", + " >>> dedoublonner([1, 2, 1, 4])\n", + " [1, 2, 4]\n", + " '''\n", + " resultat = []\n", + " for element in liste:\n", + " if not est_present(resultat, element):\n", + " resultat.append(element)\n", + " return resultat" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 4\n", + "def tranche(liste, debut, fin):\n", + " '''\n", + " Obtient une tranche du liste\n", + " :param liste: (list) une liste\n", + " :param debut: (int) l'indice du début de la tranche\n", + " :param fin: (int) l'indice de fin de la tranche\n", + " :return: (list) une liste contenant les éléments entre début et fin non inclus\n", + " :doctest:\n", + " >>> tranche([ i for i in range(10)], 0, 10)\n", + " [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + " >>> tranche([ i for i in range(10)], 0, 5)\n", + " [0, 1, 2, 3, 4]\n", + " >>> tranche([ i for i in range(10)], 5, 10)\n", + " [5, 6, 7, 8, 9]\n", + " '''\n", + " sous_liste = []\n", + " for i in range(debut, fin):\n", + " sous_liste.append(liste[i])\n", + " return sous_liste" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercice 5 : Matrice\n", + "\n", + "1. Écrire une fonction `ligne` qui prend en paramètre une matrice et un indice de ligne en entrées et renvoie une liste avec l'ensemble des valeurs de la ligne.\n", + "2. Écrire une fonction `colonne` qui prend en paramètre une matrice et un indice de colonne en entrées et renvoie une liste avec l'ensemble des valeurs de la colonne.\n", + "3. Écrire une fonction `diagonale_nord_ouest` qui prend en paramètre une matrice et renvoie une liste avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[0] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[len(matrice) - 1].\n", + "4. Écrire une fonction `diagonale_nord_est` qui prend en paramètre une matrice et renvoie une liste avec l'ensemble des valeurs de la diagonale. La première valeur est celle à l'indice \\[0]\\[len(matrice) - 1] et la dernière celle correspondant à l'indice \\[len(matrice) - 1]\\[0]." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 1\n", + "def ligne(matrice, indice):\n", + " '''\n", + " Obtient une liste comportant l'ensemble des valeurs de la ligne indice de la matrice\n", + " :param matrice: (list) une matrice\n", + " :param indice: (int) un entier\n", + " :return: (list) une liste de valeurs de la ligne indice\n", + " :doctest:\n", + " >>> ligne([[1, 2],[3, 4]], 0)\n", + " [1, 2]\n", + " >>> ligne([[1, 2],[3, 4]], 1)\n", + " [3, 4]\n", + " '''\n", + " return matrice[indice]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 2\n", + "def colonne(matrice, indice):\n", + " '''\n", + " Obtient une liste comportant l'ensemble des valeurs de la colonne indice de la matrice\n", + " :param matrice: (list) une matrice\n", + " :param indice: (int) un entier\n", + " :return: (list) une liste de valeurs de la colonne indice\n", + " :doctest:\n", + " >>> colonne([[1, 2],[3, 4]], 0)\n", + " [1, 3]\n", + " >>> colonne([[1, 2],[3, 4]], 1)\n", + " [2, 4]\n", + " '''\n", + " return [ matrice[i][indice] for i in range(len(matrice[0]))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 3\n", + "def diagonale_nord_ouest(matrice):\n", + " '''\n", + " Obtient les valeurs de la diagonale de la matrice, dont l'origine est la valeur correspondant à l'indice [0][0]\n", + " :param matrice: (list) une matrice\n", + " :return: (list) une liste de valeurs de la diagonale\n", + " :doctest:\n", + " >>> diagonale_nord_ouest([[1, 2], [3, 4]])\n", + " [1, 4]\n", + " >>> diagonale_nord_ouest([['A', 'D', 'C'], ['B', 'F', 'E'], ['H', 'I', 'G']])\n", + " ['A', 'F', 'G']\n", + " '''\n", + " return [matrice[i][i] for i in range(0, len(matrice))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 4\n", + "def diagonale_nord_est(matrice):\n", + " '''\n", + " Obtient les valeurs de la diagonale de la matrice, dont l'origine est la valeur correspondant à l'indice [0][len(matrice) - 1]\n", + " :param matrice: (list) une matrice\n", + " :return: (list) une liste de valeurs de la diagonale\n", + " :doctest:\n", + " >>> diagonale_nord_est([[1, 2], [3, 4]])\n", + " [2, 3]\n", + " >>> diagonale_nord_est([['A', 'D', 'C'], ['B', 'F', 'E'], ['H', 'I', 'G']])\n", + " ['C', 'F', 'H']\n", + " '''\n", + " return [matrice[i][len(matrice[0]) - 1 - i] for i in range(0, len(matrice))]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Application - Carré magique\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Fig 1. - Carré d'ordre 4
163213
510118
96712
415141
\n", + "\n", + "\n", + "En mathématiques, un ***carré magique*** d’ordre $n$ est composé de $n^2$ entiers strictement positifs, écrits sous la forme d’une liste carré. Ces nombres sont disposés de sorte que leurs sommes sur chaque rangée, sur chaque colonne et sur chaque diagonale principale soient égales. On nomme alors ***constante magique*** la valeur de ces sommes.\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Fig 1.1 - Carré magique avec sa constante égale à 34
163213→34
510118→34
96712→34
415141→34
↙ 34↓ 34↓ 34↓ 34↓ 34↘ 34
\n", + "\n", + "\n", + "> Écrire un prédicat `est_magique` qui prend une matrice d'entiers en paramètre et indique si le carré est magique ou non." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def est_magique(matrice):\n", + " '''\n", + " Indique si le carré est magique ou non\n", + " :param matrice: (list) un carré d'entiers\n", + " :return: (bool) True si les sommes de chaque ligne, colonne et diagonale sont égales.\n", + " :doctest:\n", + " >>> est_magique([[2, 7, 6], [9, 5, 1], [4, 3, 8]])\n", + " True\n", + " >>> est_magique([[2, 7, 6], [9, 1, 5], [4, 3, 8]])\n", + " False\n", + " >>> est_magique([[16, 3, 2, 13], [5, 10, 11, 8], [9, 6, 7, 12], [4, 15, 14, 1]])\n", + " True\n", + " '''\n", + " constante = somme(matrice[0])\n", + " return (\n", + " all([somme(ligne(matrice, i)) == constante for i in range(1, len(matrice))]) and\n", + " all([somme(colonne(matrice, i)) == constante for i in range(0, len(matrice[0]))]) and\n", + " somme(diagonale_nord_ouest(matrice)) == constante and\n", + " somme(diagonale_nord_est(matrice)) == constante\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Carré magique de lettres\n", + "\n", + "Un ***carré magique de lettres***, également appelé « ***mots carrés*** », est une forme de mots croisés disposé en carré, ne comportant pas de case noire et constitué de mots valides dans une langue définie. Ils peuvent, par définition, être lus horizontalement et verticalement et présentent dans ces deux sens les mêmes mots.\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "
Fig.2.1 - Carré magique de lettres d'ordre 3
TEL
ETE
LES
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Fig.2.2 - Carré magique de lettres d'ordre 5
CULTE
UNIES
LIONS
TENTA
ESSAI
\n", + "\n", + "> Écrire un prédicat `est_magique_lettres` qui prend une matrice de caractères en paramètre et indique si le carré est magique de lettres ou non." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def est_magique_lettres(matrice):\n", + " '''\n", + " Indique si une matrice de caractères est un carré magique ou non\n", + " :param matrice: (list) une matrice de caractères\n", + " :return: (bool) True si la matrice est un carré magique de lettres, False sinon\n", + " :doctest:\n", + " >>> est_magique_lettres([['T', 'E', 'L'], ['E', 'T', 'E'], ['L', 'E', 'S']])\n", + " True\n", + " >>> est_magique_lettres([['T', 'E', 'L'], ['E', 'R', 'E'], ['L', 'A', 'S']])\n", + " False\n", + " >>> est_magique_lettres([['S', 'A', 'T', 'O', 'R'], ['A', 'R', 'E', 'P', 'O'], ['T', 'E', 'N', 'E', 'T'], ['O', 'P', 'E', 'R', 'A'], ['R', 'O', 'T', 'A', 'S']])\n", + " True\n", + " '''\n", + " return all([ ligne(matrice, i) == colonne(matrice, i) for i in range(len(matrice))])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Application - Pour aller plus loin\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Fig.3 - Dessin d'une maison
⚪⚪⚪⚫⚪⚪
⚪⚪⚫⚪⚫⚪
⚪⚫⚪⚪⚪⚫
⚫⚫⚫⚫⚫⚫
⚫⚪⚫⚪⚪⚫
⚫⚫⚫⚫⚫⚫
\n", + "\n", + "Déclaration de la matrice correspondante à la Fig.1 :\n", + "```python\n", + "matrice = [\n", + " ['⚪', '⚪', '⚪', '⚫', '⚪', '⚪'],\n", + " ['⚪', '⚪', '⚫', '⚪', '⚫', '⚪'],\n", + " ['⚪', '⚫', '⚪', '⚪', '⚪', '⚫'],\n", + " ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n", + " ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫'],\n", + " ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫']\n", + "]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Écrire une méthode `miroir_vertical` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir vertical sur les valeurs de la matrice.\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Fig.3.1 - Effet miroir vertical de la Fig.4
⚪⚪⚫⚪⚪⚪
⚪⚫⚪⚫⚪⚪
⚫⚪⚪⚪⚫⚪
⚫⚫⚫⚫⚫⚫
⚫⚪⚪⚫⚪⚫
⚫⚫⚫⚫⚫⚫
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 1\n", + "def miroir_vertical(matrice):\n", + " '''\n", + " Applique l'effet miroir par rapport à l'axe vertical sur une matrice\n", + " :param matrice: (list) une matrice\n", + " :doctest:\n", + " >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", + " >>> miroir_vertical(matrice)\n", + " >>> matrice\n", + " [[3, 2, 1], [6, 5, 4], [9, 8, 7]]\n", + " >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n", + " >>> miroir_vertical(matrice)\n", + " >>> matrice\n", + " [['⚫', '⚪', '⚫'], ['⚫', '⚪', '⚪'], ['⚪', '⚫', '⚪']]\n", + " '''\n", + " for liste in matrice:\n", + " inverser(liste)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Écrire une méthode `miroir_horizontal` qui prend en paramètre une matrice et a pour effet de bord de réaliser l'effet miroir horizontal sur les valeurs de la matrice.\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Fig.3.2 - Effet miroir horizontal de la Fig.4
⚫⚫⚫⚫⚫⚫
⚫⚪⚫⚪⚪⚫
⚫⚫⚫⚫⚫⚫
⚪⚫⚪⚪⚪⚫
⚪⚪⚫⚪⚫⚪
⚪⚪⚪⚫⚪⚪
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 2\n", + "def miroir_horizontal(matrice):\n", + " '''\n", + " Applique l'effet miroir par rapport à l'axe horizontal sur une matrice\n", + " :param matrice: (list) une matrice\n", + " :doctest:\n", + " >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", + " >>> miroir_horizontal(matrice)\n", + " >>> matrice\n", + " [[7, 8, 9], [4, 5, 6], [1, 2, 3]]\n", + " >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n", + " >>> miroir_horizontal(matrice)\n", + " >>> matrice\n", + " [['⚪', '⚫', '⚪'], ['⚪', '⚪', '⚫'], ['⚫', '⚪', '⚫']]\n", + " '''\n", + " inverser(matrice)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Écrire une fonction `rotation_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens horaire des valeurs de la matrice.\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Fig.3.3 - Roration horaire de la Fig.4
⚫⚫⚫⚪⚪⚪
⚫⚪⚫⚫⚪⚪
⚫⚫⚫⚪⚫⚪
⚫⚪⚫⚪⚪⚫
⚫⚪⚫⚪⚫⚪
⚫⚫⚫⚫⚪⚪
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 3\n", + "def rotation_horaire(matrice):\n", + " '''\n", + " :param matrice: (list) une matrice\n", + " :doctest:\n", + " >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", + " >>> rotation_horaire(matrice)\n", + " [[7, 4, 1], [8, 5, 2], [9, 6, 3]]\n", + " >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n", + " >>> rotation_horaire(matrice)\n", + " [['⚪', '⚪', '⚫'], ['⚫', '⚪', '⚪'], ['⚪', '⚫', '⚫']]\n", + " '''\n", + " resultat = []\n", + " for i in range(len(matrice[0])):\n", + " resultat.append(colonne(matrice, i))\n", + " miroir_vertical(resultat)\n", + " return resultat" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Écrire une fonction `rotation_anti_horaire` qui prend en paramètre une matrice et renvoie une matrice dont les valeurs correspondent à la rotation dans le sens anti-horaire des valeurs de la matrice.\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Fig.3.4 - Roration anti-horaire de la Fig.4
⚪⚪⚫⚫⚫⚫
⚪⚫⚪⚫⚪⚫
⚫⚪⚪⚫⚪⚫
⚪⚫⚪⚫⚫⚫
⚪⚪⚫⚫⚪⚫
⚪⚪⚪⚫⚫⚫
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Question 4\n", + "def rotation_anti_horaire(matrice):\n", + " '''\n", + " :param matrice: (list) une matrice\n", + " :doctest:\n", + " >>> matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n", + " >>> rotation_anti_horaire(matrice)\n", + " [[3, 6, 9], [2, 5, 8], [1, 4, 7]]\n", + " >>> matrice = [['⚫', '⚪', '⚫'], ['⚪', '⚪', '⚫'], ['⚪', '⚫', '⚪']]\n", + " >>> rotation_anti_horaire(matrice)\n", + " [['⚫', '⚫', '⚪'], ['⚪', '⚪', '⚫'], ['⚫', '⚪', '⚪']]\n", + " '''\n", + " resultat = []\n", + " for i in range(len(matrice[0]) - 1, -1, -1):\n", + " resultat.append(colonne(matrice, i))\n", + " return resultat" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pour valider vos fonctions, vous pouvez réaliser sur papier les opérations miroir et de rotation sur la Fig.4 et vérifier que les résultats obtenus sont conformes.\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Fig.4 - Dessin d'un bateau avec une mouette
⚪⚪⚫⚪⚪⚪⚪
⚪⚫⚫⚪⚫⚪⚫
⚫⚪⚫⚪⚪⚫⚪
⚪⚫⚫⚪⚪⚪⚪
⚪⚪⚫⚪⚪⚪⚪
⚫⚫⚫⚫⚫⚫⚫
⚫⚪⚪⚪⚪⚪⚫
⚪⚫⚫⚫⚫⚫⚪
\n", + "\n", + "Déclaration de la matrice correspondante à la Fig.4 :\n", + "```python\n", + "matrice = [\n", + " ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n", + " ['⚪', '⚫', '⚫', '⚪', '⚫', '⚪', '⚫'],\n", + " ['⚫', '⚪', '⚫', '⚪', '⚪', '⚫', '⚪'],\n", + " ['⚪', '⚫', '⚫', '⚪', '⚪', '⚪', '⚪'],\n", + " ['⚪', '⚪', '⚫', '⚪', '⚪', '⚪', '⚪'],\n", + " ['⚫', '⚫', '⚫', '⚫', '⚫', '⚫', '⚫'],\n", + " ['⚫', '⚪', '⚪', '⚪', '⚪', '⚪', '⚫'],\n", + " ['⚪', '⚫', '⚫', '⚫', '⚫', '⚫', '⚪']\n", + "]\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/representation_construits/chapitre_1/tp/CORRECTION.md b/representation_construits/chapitre_1/tp/CORRECTION.md new file mode 100644 index 0000000..b3024e1 --- /dev/null +++ b/representation_construits/chapitre_1/tp/CORRECTION.md @@ -0,0 +1,75 @@ +```python +def mastermind(combinaison,proposition): + """ + Compare la proposition du joueur avec la combinaison secrète et renvoie les indices correspondants. + + :param combinaison : liste contenant la combinaison secrète + :param proposition : liste contenant la proposition du joueur + :return indices : liste contenant les indices pour la proposition du joueur + + """ + indices = [] + combinaison_temp = combinaison_secrete.copy() + + # Vérification des couleurs bien placées + for i in range(len(proposition)): + if proposition[i] == combinaison_secrete[i]: + indices.append('X') + combinaison_temp[i] = None # Marquer la couleur comme déjà utilisée dans la combinaison secrète + + # Vérification des couleurs présentes mais mal placées + for i in range(len(proposition)): + if proposition[i] in combinaison_temp: + indices.append('O') + combinaison_temp[combinaison_temp.index(proposition[i])] = None # Marquer la couleur comme déjà utilisée + + return indices + +``` + + + + + + + +```python +def mastermind(combinaison, proposition): + """ + Compare la proposition du joueur avec la combinaison secrète et renvoie les indices correspondants. + + :param combinaison : liste contenant la combinaison secrète + :param proposition : liste contenant la proposition du joueur + :return indices : liste contenant les indices pour la proposition du joueur + """ + indices = [] + combinaison_copie = combinaison.copy() # Pour garder la combinaison originale intacte + + # Étape 1: Vérifier les correspondances exactes + for couleur_proposee in proposition: + if couleur_proposee in combinaison_copie: + if couleur_proposee == combinaison_copie[0]: # Compare avec le premier élément + indices.append('N') # Bonne couleur, bonne position + combinaison_copie[0] = None # Marquer comme traité + else: + indices.append('B') # Bonne couleur, mauvaise position + combinaison_copie.remove(couleur_proposee) # Retirer l'élément traité + + return indices + +# Générer une combinaison secrète aléatoire +import random +couleurs = ['Rouge', 'Vert', 'Bleu', 'Jaune', 'Orange', 'Violet'] +combinaison_secrete = random.sample(couleurs, 4) + +# Boucle de jeu +while True: + proposition_joueur = input("Entrez votre proposition (séparée par des espaces) : ").split() + indices = mastermind(combinaison_secrete, proposition_joueur) + print("Indices :", indices) + if indices == ['N', 'N', 'N', 'N']: + print("Félicitations, vous avez trouvé la combinaison secrète !") + break + +``` +