Florian/1ereNSI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Typo Babbage, suppression fichier virtual box et ajout corrections types construits

Browse Source
This commit is contained in:
Florian Mathieu
2024-01-29 15:17:29 +01:00
parent f8032c0048
commit 300e2c7435
6 changed files with 1338 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
architecture/historique/README.md
View File

@@ -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.

82
architecture/os/nsi.vbox
View File

@@ -1,82 +0,0 @@
<?xml version="1.0"?>
<!--
** DO NOT EDIT THIS FILE.
** If you make changes to this file while any VirtualBox related application
** is running, your changes will be overwritten later, without taking effect.
** Use VBoxManage or the VirtualBox Manager GUI to make changes.
-->
<VirtualBox xmlns="http://www.virtualbox.org/" version="1.19-windows">
<Machine uuid="{e864232c-a28a-4b8f-989f-38951543afc8}" name="nsi" OSType="Ubuntu_64" snapshotFolder="Snapshots" lastStateChange="2024-01-28T14:25:59Z">
<MediaRegistry>
<HardDisks>
<HardDisk uuid="{29ff7d95-052b-4ce6-8f3a-36f848e319e9}" location="nsi.vdi" format="VDI" type="Normal"/>
</HardDisks>
<DVDImages>
<Image uuid="{0268a626-0fed-4fc3-9744-c8342b1c2c67}" location="Unattended-e864232c-a28a-4b8f-989f-38951543afc8-aux-iso.viso" format="VBoxIsoMaker">
<Property name="UnattendedInstall" value="1"/>
</Image>
</DVDImages>
</MediaRegistry>
<ExtraData>
<ExtraDataItem name="GUI/LastCloseAction" value="PowerOff"/>
<ExtraDataItem name="GUI/LastGuestSizeHint" value="1680,939"/>
<ExtraDataItem name="GUI/LastNormalWindowPosition" value="1920,49,1680,979,max"/>
</ExtraData>
<Hardware>
<CPU>
<PAE enabled="false"/>
<LongMode enabled="true"/>
<X2APIC enabled="true"/>
<HardwareVirtExLargePages enabled="true"/>
</CPU>
<Memory RAMSize="2048"/>
<HID Pointing="USBTablet"/>
<Boot>
<Order position="1" device="HardDisk"/>
<Order position="2" device="DVD"/>
<Order position="3" device="Floppy"/>
<Order position="4" device="None"/>
</Boot>
<Display controller="VMSVGA" VRAMSize="16"/>
<BIOS>
<IOAPIC enabled="true"/>
<SmbiosUuidLittleEndian enabled="true"/>
</BIOS>
<USB>
<Controllers>
<Controller name="OHCI" type="OHCI"/>
<Controller name="EHCI" type="EHCI"/>
</Controllers>
</USB>
<Network>
<Adapter slot="0" enabled="true" MACAddress="08002703E897" type="82540EM">
<NAT localhost-reachable="true"/>
</Adapter>
</Network>
<AudioAdapter codec="AD1980" useDefault="true" driver="WAS" enabled="true" enabledOut="true"/>
<RTC localOrUTC="UTC"/>
<Clipboard/>
<GuestProperties>
<GuestProperty name="/VirtualBox/GuestAdd/HostVerLastChecked" value="7.0.14" timestamp="1706450144790167500" flags=""/>
<GuestProperty name="/VirtualBox/GuestAdd/Revision" value="161095" timestamp="1706450108644158105" flags=""/>
<GuestProperty name="/VirtualBox/GuestAdd/Version" value="7.0.14" timestamp="1706450108644158103" flags=""/>
<GuestProperty name="/VirtualBox/GuestAdd/VersionExt" value="7.0.14" timestamp="1706450108644158104" flags=""/>
<GuestProperty name="/VirtualBox/GuestInfo/OS/Product" value="Linux" timestamp="1706450108643642500" flags=""/>
<GuestProperty name="/VirtualBox/GuestInfo/OS/Release" value="6.5.0-14-generic" timestamp="1706450108644158100" flags=""/>
<GuestProperty name="/VirtualBox/GuestInfo/OS/ServicePack" value="" timestamp="1706450108644158102" flags=""/>
<GuestProperty name="/VirtualBox/GuestInfo/OS/Version" value="#14~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Mon Nov 20 18:15:30 UTC 2" timestamp="1706450108644158101" flags=""/>
<GuestProperty name="/VirtualBox/HostInfo/GUI/LanguageID" value="fr_FR" timestamp="1706451959511882900" flags="RDONLYGUEST"/>
</GuestProperties>
<StorageControllers>
<StorageController name="IDE" type="PIIX4" PortCount="2" useHostIOCache="true" Bootable="true">
<AttachedDevice passthrough="false" type="DVD" hotpluggable="false" port="1" device="0"/>
</StorageController>
<StorageController name="SATA" type="AHCI" PortCount="1" useHostIOCache="false" Bootable="true" IDE0MasterEmulationPort="0" IDE0SlaveEmulationPort="1" IDE1MasterEmulationPort="2" IDE1SlaveEmulationPort="3">
<AttachedDevice type="HardDisk" hotpluggable="false" port="0" device="0">
<Image uuid="{29ff7d95-052b-4ce6-8f3a-36f848e319e9}"/>
</AttachedDevice>
</StorageController>
</StorageControllers>
</Hardware>
</Machine>
</VirtualBox>

161
representation_construits/chapitre_1/projet/correction 2.py Normal file
View File

@@ -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é')

161
representation_construits/chapitre_1/projet/correction.py Normal file
View File

@@ -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é')

940
representation_construits/chapitre_1/td/correction.ipynb Normal file
View File

@@ -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<sup>[wikipédia](https://fr.wikipedia.org/wiki/Code_Konami)</sup>\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",
"<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
"<caption style=\"caption-side:bottom;\">Fig 1. - Carré d'ordre 4</caption>\n",
"<tr style=\"border:none;\"><td>16</td><td>3</td><td>2</td><td>13</td></tr>\n",
"<tr style=\"border:none;\"><td>5</td><td>10</td><td>11</td><td>8</td></tr>\n",
"<tr style=\"border:none;\"><td>9</td><td>6</td><td>7</td><td>12</td></tr>\n",
"<tr style=\"border:none;\"><td>4</td><td>15</td><td>14</td><td>1</td></tr>\n",
"</table>\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",
"<table style=\"margin : 0 auto 0 auto; width:100px;text-align:center;\">\n",
" <caption style=\"caption-side:bottom;\">Fig 1.1 - Carré magique avec sa constante égale à 34</caption>\n",
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>16</td><td>3</td><td>2</td><td>13</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>5</td><td>10</td><td>11</td><td>8</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>9</td><td>6</td><td>7</td><td>12</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
"<tr style=\"border:none;\"><th style=\"border : none;\"></th><td>4</td><td>15</td><td>14</td><td>1</td><th style=\"border : none;padding-left:.5em;\">&rightarrow;34</th></tr>\n",
"<tr style=\"border:none;\"><th style=\"border : none;\">&swarr; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&downarrow; 34</th><th style=\"border:none;\">&searr; 34</th></tr>\n",
"</table>\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",
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
" <caption style=\"caption-side:bottom;\">Fig.2.1 - Carré magique de lettres d'ordre 3</caption>\n",
"<tr><td>T</td><td>E</td><td>L</td></tr>\n",
"<tr><td>E</td><td>T</td><td>E</td></tr>\n",
"<tr><td>L</td><td>E</td><td>S</td></tr>\n",
"</table>\n",
"\n",
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
" <caption style=\"caption-side:bottom;\">Fig.2.2 - Carré magique de lettres d'ordre 5</caption>\n",
"<tr><td>C</td><td>U</td><td>L</td><td>T</td><td>E</td></tr>\n",
"<tr><td>U</td><td>N</td><td>I</td><td>E</td><td>S</td></tr>\n",
"<tr><td>L</td><td>I</td><td>O</td><td>N</td><td>S</td></tr>\n",
"<tr><td>T</td><td>E</td><td>N</td><td>T</td><td>A</td></tr>\n",
"<tr><td>E</td><td>S</td><td>S</td><td>A</td><td>I</td></tr>\n",
"</table>\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",
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
" <caption style=\"caption-side:bottom;\">Fig.3 - Dessin d'une maison</caption>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"</table>\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",
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
" <caption style=\"caption-side:bottom;\">Fig.3.1 - Effet miroir vertical de la Fig.4</caption>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"</table>"
]
},
{
"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",
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
" <caption style=\"caption-side:bottom;\">Fig.3.2 - Effet miroir horizontal de la Fig.4</caption>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"</table>"
]
},
{
"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",
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
" <caption style=\"caption-side:bottom;\">Fig.3.3 - Roration horaire de la Fig.4</caption>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"</table>"
]
},
{
"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",
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
" <caption style=\"caption-side:bottom;\">Fig.3.4 - Roration anti-horaire de la Fig.4</caption>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"</table>"
]
},
{
"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",
"<table style=\"margin : 0 auto 0 auto; width : 100px;text-align:center;\">\n",
" <caption style=\"caption-side:bottom;\">Fig.4 - Dessin d'un bateau avec une mouette</caption>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9899;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9898;</td><td>&#9899;</td></tr>\n",
"<tr><td>&#9898;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9899;</td><td>&#9898;</td></tr>\n",
"</table>\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
}

75
representation_construits/chapitre_1/tp/CORRECTION.md Normal file
View File

@@ -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
```