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

typo de part et d'autres

Browse Source
This commit is contained in:
Florian Mathieu
2026-01-15 00:29:08 +01:00
parent 50270bd2d6
commit e5dd54c9d2
10 changed files with 459 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
algorithmes/CREPIER.md
View File

@@ -10,7 +10,7 @@ Il faut aider Jean-Michel à remettre les crêpes dans le bon ordre !
Pour cela, il va nous falloir :
- Télécharger le fichier [java](crepe-applet1-jnlp.jnlp) et l'exécuter. Si cela ne fonctionne pas, appeller le professeur.
- Télécharger le fichier [java](crepe-applet1-jnlp.jnlp) et l'exécuter. Si cela ne fonctionne pas, appeler le professeur.
- Prendre son temps et comprendre comment cela fonctionne.
- Mettre en place nos idées.
- Retourner les crêpes !
@@ -59,7 +59,7 @@ En commençant avec six (6) crêpes, je peux donc facilement m'en sortir, voilà
<img src="assets/étape_2.png" alt="étape_2" style="zoom:50%;" />
- On retourne le tout en cliquant sur la crêpe du bas pour inverser la position entre la crepe la plus large qui est en haut, et la crêpe qui se retrouve en bas.
- On retourne le tout en cliquant sur la crêpe du bas pour inverser la position entre la crêpe la plus large qui est en haut, et la crêpe qui se retrouve en bas.
<img src="assets/étape_3.png" alt="étape_3" style="zoom:50%;" />

48
algorithmes/DICHOTOMIQUE.md
View File

@@ -24,9 +24,9 @@ Supposons un tableau tab :
tab = [1,2,6,9,12,14,18,21,42]
```
Si on souhaite chercher un élèment, par exemple 7, en utilisant le [parcours séquentiel](PARCOURS.md) on fonctionne par balayage (avec une boucle for...) et donc parcourir la liste du début à la fin en colparant chaque valeur à l'élèment recherché.
Si on souhaite chercher un élèment, par exemple 7, en utilisant le [parcours séquentiel](PARCOURS.md) on fonctionne par balayage (avec une boucle for...) et donc parcourir la liste du début à la fin en comparant chaque valeur à l'élèment recherché.
Ici par exemple, on effectuerait 9 comparaison pour finir par dire que non, 7 n'est pas présent.
Ici par exemple, on effectuerait 9 comparaisons pour finir par dire que non, 7 n'est pas présent.
Dans le cas d'une liste **déjà triée**, la recherche dichotomique permet d'améliorer les performances.
@@ -60,13 +60,13 @@ Montrer le nombre d'étapes nécessaires à la réussite de cette recherche.
| Recherche Dichotomique | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | log<sub>2</sub>N |
- Quel est le pire des cas ici ? Que l'élèment recherché ne soit pas dans le tableau.
- Le nombre de tours de boucle de la recherche dichotomique est de l'ordrede log<sub>2</sub>(n) où *n* est la taille de la liste.
- Le nombre de tours de boucle de la recherche dichotomique est de l'ordre de log<sub>2</sub>(n) où *n* est la taille de la liste.
*Explications*
Qu'est ce que le ***Logarithme***:
pour faire simple, le logarithme en base n - écrit log<sub>n</sub> correspond au nombre de division par n successive pour arriver au nombre 0.
pour faire simple, le logarithme en base n - écrit log<sub>n</sub> correspond au nombre de divisions par n successives pour arriver au nombre 1.
***Exemple :***
@@ -110,27 +110,25 @@ La recherche dichotomique est donc de complexité ***logarithmique***.
Pour vérifier que la recherche dichotomique se termine bien, regardons ensemble son code python - on suppose que le tableau en entrée est déjà trié.
````python
def dichotomique (tab, x):
"""
:param tab: tableau contenant différents élèments déjà triés
:param x: élèment recherché
"""
a = 0 # on initialise la borne inférieure
b = len(tab) - 1 # borne supérieure
while a <= b: # tant que la borne inférieure est plus petite ou égale à la borne supérieure
m = (a + b) // 2 # on se place au milieu du tableau
if tab[m] == x: # si l'élément central est l'élément recherché
return True # alors on a terminé
elif tab[m] < x: # si l'élément central est plus petit que l'élément recherché
a = m + 1 # on déplace la borne minimum vers la sous-partie droite du tableau
else: #si l'élement central n'est ni plus petit ni égal à l'élément recherché, donc s'il est >...
b = m - 1 #on déplace la borne supérieure vers la sous-partie gauche
#si après tout ça on ne trouve pas l'élément...
return False
````
```python
def dichotomique(tab, x):
"""
:param tab: tableau contenant différents élèments déjà triés
:param x: élèment recherché
"""
a = 0 # on initialise la borne inférieure
b = len(tab) - 1 # borne supérieure
while a <= b: # tant que la borne inférieure est plus petite ou égale à la borne supérieure
m = (a + b) // 2 # on se place au milieu du tableau
if tab[m] == x: # si l'élément central est l'élément recherché
return True # alors on a terminé
elif tab[m] < x: # si l'élément central est plus petit que l'élément recherché
a = m + 1 # on déplace la borne minimum vers la sous-partie droite du tableau
else: # si l'élément central est plus grand que l'élément recherché
b = m - 1 # on déplace la borne supérieure vers la sous-partie gauche
# si après tout ça on ne trouve pas l'élément...
return False
```
-----------

8
algorithmes/PARCOURS.md
View File

@@ -16,7 +16,7 @@ On supposera que tous les tableaux traités ici contiennent des nombres.
### Exemples
#### Recherche d'occurence
#### Recherche d'occurrence
Si on souhaite savoir si un élément nommé *e* en particulier se trouve dans un tableau *tab* :
@@ -56,7 +56,7 @@ def recherche_max(tab):
*Complexité linéaire*
Car on parcours toute la liste et donc pour n élèments, on effectuera n comparaisons.
Car on parcourt toute la liste et donc pour n élèments, on effectuera n comparaisons.
--------
@@ -73,13 +73,13 @@ def moyenne(tab):
*Complexité linéaire*
Car on parcours toute la liste et donc pour n élèments, on effectuera n comparaisons.
Car on parcourt toute la liste et donc pour n élèments, on effectuera n comparaisons.
-----------
#### Autres exemples simples :
- Vérifier si une un tableau est rangé par ordre croissant ou décroissant
- Vérifier si un tableau est rangé par ordre croissant ou décroissant
- Chercher un mot de plus de n lettres dans une liste de mots...
--------

4
algorithmes/PROPRIETES.md
View File

@@ -41,8 +41,8 @@ $$
- La **complexité d'un algorithme** est une mesure du temps requis par l'algorithme pour accomplir sa tâche, en fonction de la taille des données à traiter.
- On dira d'un problème qu'il est aussi complexe que le meilleur algorithme connu pour le résoudre.
- Si la **complexité** est **constante**, alors le temps d'execution sera sensiblement toujours le même, peu importe la taille du tableau traité.
- Si elle est **logarithmique**, alors le temps d'execution augmente très faiblement quand le paramètre croit.
- Si la **complexité** est **constante**, alors le temps d'exécution sera sensiblement toujours le même, peu importe la taille du tableau traité.
- Si elle est **logarithmique**, alors le temps d'exécution augmente très faiblement quand le paramètre croît.
- **Complexité** **linéaire** : le nombre d'étapes à effectuer va varier en proportion directe de la taille de l'échantillon à traiter : si l'échantillon croît par un facteur de 10000, la complexité sera accrue elle aussi par un facteur de 10000.
- **Complexité Quadratique** : Dans le cadre du tri par insertion, par exemple, quand on double la taille du tableau, le nombre de comparaisons sera lui multiplié par...4.

2
algorithmes/README.md
View File

@@ -8,7 +8,7 @@ Un algorithme est une séquence finie d’instructions faite pour être exécut
- Logique parce que la personne (ou la machine) qui exécute les instructions sera capable de facilement comprendre et exécuter sans erreur ni ambigüité chacune des instructions.
- Non intelligente parce que la personne qui exécute l’algorithme n'aura qu'à suivre toutes les instructions, dans l'ordre pour arriver au résultat sans avoir a comprendre la méthode de solution.
- Non intelligente parce que la personne qui exécute l’algorithme n'aura qu'à suivre toutes les instructions, dans l'ordre pour arriver au résultat sans avoir à comprendre la méthode de solution.

12
algorithmes/TRIS.md
View File

@@ -101,7 +101,7 @@ Le tri par insertion est *naturel* dans l'esprit : on parcourt le tableau de la
Une preuve de correction de l'algorithme est la propriété *p(i)* : "le tableau est trié jusqu'à la case n°i" : cette propriété est vraie **avant** et **après** chaque tour de boucle : c'est ce qu'on appelle ***Invariant de boucle***
À l'inverse, le **variant** de boucle est une expression dans la valeur varie à chaque tour de boucle et qui doit justement permettre de mettre fin à la-dite boucle : le variant d'un algorithme de tri sera alors la taile de la liste restante à trier.
À l'inverse, le **variant** de boucle est une expression dans la valeur varie à chaque tour de boucle et qui doit justement permettre de mettre fin à la-dite boucle : le variant d'un algorithme de tri sera alors la taille de la liste restante à trier.
### Complexité
@@ -119,9 +119,9 @@ Merci @https://x.com/Limplementeur pour l'illustration
-----------------
## Tri par selection
## Tri par sélection
> Contrairement au tri par insertion, le tri par selection a pour avantage de déplacer moins de valeurs.
> Contrairement au tri par insertion, le tri par sélection a pour avantage de déplacer moins de valeurs.
![selection](assets/selection.gif)
@@ -130,7 +130,7 @@ Principe:
- On recherche le plus petit élément et on le met à sa place (indice 0 donc)
- Puis on recherche le deuxième plus petit et on le met à l'indice 1
- Et on continue comme cela avec tous les éléments
- Il n'est pas necessaire de faire une copie de la liste
- Il n'est pas nécessaire de faire une copie de la liste
- Deux éléments égaux ne resteront pas forcément à la même place
Supposons le tableau suivant :
@@ -186,7 +186,7 @@ Il faut montrer l'invariant : à la fin du tour i de la boucle for, les cases ta
#### Exercices
- Ecrire les fonctions
- Écrire les fonctions
```python
tri_selection (tab)
@@ -198,7 +198,7 @@ et
tri_insertion(tab)
```
qui permettent de trier différement les tableaux donnés en entrée.
qui permettent de trier différemment les tableaux donnés en entrée.
Expliquer pourquoi ces algorithmes sont en O(n<sup>2</sup> ) avec vos propres mots.

2
programmation/GENERALITES.md
View File

@@ -51,7 +51,7 @@ flowchart LR
> Un __langage de programmation__ est un langage proche du langage naturel, utilisable par un humain, et exécutable, après traduction par une machine.
___Sans langage de programmation, un humain devrait connaitre et commander la machine en maitrisant son langage, donc écrire des 0 et des 1.___
___Sans langage de programmation, un humain devrait connaître et commander la machine en maîtrisant son langage, donc écrire des 0 et des 1.___
```mermaid
flowchart LR

411
programmation/chapitre_1/TD.ipynb
View File

File diff suppressed because one or more lines are too long

33
programmation/chapitre_2/TD.ipynb
View File

@@ -146,36 +146,7 @@
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5. Cas : Si...Alors...Sinon Si\n",
"\n",
"Dans cette structure on teste plusieurs conditions\n",
"\n",
"```\n",
" if condition1:\n",
" instruction1\n",
" elif condition2:\n",
" instruction2\n",
" instruction3\n",
" elif condition3:\n",
" instruction4\n",
" else:\n",
" instruction5\n",
"```\n",
"\n",
"Exemple :\n",
"\n",
"Imaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :\n",
"\n",
"```python\n",
"if feu == 'VERT':\n",
"\tprint('Piéton, vous pouvez passer')\n",
"elif voitures = 0 : # le feu est rouge\n",
" print('Piéton, vous pouvez passer mais attention')\n",
"else: # le feu est rouge et il y a des voitures\n",
"\tprint('Piéton, vous ne pouvez passer')\n",
"```"
]
"source": "## 5. Cas : Si...Alors...Sinon Si\n\nDans cette structure on teste plusieurs conditions\n\n```\n if condition1:\n instruction1\n elif condition2:\n instruction2\n instruction3\n elif condition3:\n instruction4\n else:\n instruction5\n```\n\nExemple :\n\nImaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :\n\n```python\nif feu == 'VERT':\n\tprint('Piéton, vous pouvez passer')\nelif voitures == 0 : # le feu est rouge\n print('Piéton, vous pouvez passer mais attention')\nelse: # le feu est rouge et il y a des voitures\n\tprint('Piéton, vous ne pouvez passer')\n```"
},
{
"cell_type": "markdown",
@@ -516,4 +487,4 @@
},
"nbformat": 4,
"nbformat_minor": 2
}
}

102
programmation/chapitre_4/TD.ipynb
View File

@@ -108,53 +108,7 @@
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Déclaration d'une fonction\n",
"\n",
"Dans un langage de programmation, on utilise ce qu'on appelle des __fonctions__. Une __fonction__ est un ensemble d'instructions qui peut recevoir des __arguments__ et qui peut renvoyer un __résultat__ qui est souvent le contenu d'une ou plusieurs variables.\n",
"\n",
"En Python, on définit une fonction en utilisant l'instruction `def` (de l'anglais define, qui veut dire \"définir\") :\n",
"\n",
"```python\n",
"def nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n",
" corps_de_la_fonction\n",
"```\n",
"\n",
"- l'instruction `def` est suivie du nom de la fonction ;\n",
"- les __paramètres__ de la fonction sont ensuite écrits entre parenthèses et séparés par des virgules ;\n",
"- il existe des fonctions sans paramètre, les parenthèses sont néanmoins obligatoires et restent vides ;\n",
"- il ne faut pas oublier les __deux points__ après les parenthèses de la première ligne ;\n",
"- le corps de la fonction est un bloc d'instructions qui contient toutes les lignes qui doivent être exécutées lorsque la fonction est appelée. Le corps de la fonction doit nécessairement être __indenté__, c'est-à-dire qu'il doit être décalé d'une tabulation par rapport à l'instruction `def`.\n",
"\n",
"Très souvent, le corps de la fonction se terminera par l'instruction `return` suivie de la ou des valeurs que la fonction doit renvoyer. Si la fonction doit renvoyer plusieurs valeurs, celles-ci sont à séparer par des virgules.\n",
"\n",
"Ainsi, le schéma général d'une fonction Python est :\n",
"\n",
"```python\n",
"def nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n",
" instructions # sur plusieurs lignes éventuellement\n",
" return valeur1, valeur2, valeur3, etc. # souvent une fonction ne renvoie qu'une valeur\n",
"````\n",
"\n",
"Exemple : Voici la fonction inverse implantée en Python\n",
"\n",
"```python\n",
"def inverse(x):\n",
" y = 1 / x\n",
" return y\n",
"```\n",
"\n",
"que l'on peut aussi écrire plus simplement :\n",
"\n",
"```python\n",
"def inverse(x):\n",
" return 1 / y\n",
"```\n",
"\n",
"Identifiez dans ces deux fonctions écrites différemment : leur nom, leur(s) paramètre(s), leur corps, leur(s) valeur(s) renvoyée(s).\n",
"\n",
"Remarque : il existe des fonctions qui ne renvoient aucune valeur, l'instruction return n'est donc pas utilisée dans le corps de ces fonctions."
]
"source": "## 2. Déclaration d'une fonction\n\nDans un langage de programmation, on utilise ce qu'on appelle des __fonctions__. Une __fonction__ est un ensemble d'instructions qui peut recevoir des __arguments__ et qui peut renvoyer un __résultat__ qui est souvent le contenu d'une ou plusieurs variables.\n\nEn Python, on définit une fonction en utilisant l'instruction `def` (de l'anglais define, qui veut dire \"définir\") :\n\n```python\ndef nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n corps_de_la_fonction\n```\n\n- l'instruction `def` est suivie du nom de la fonction ;\n- les __paramètres__ de la fonction sont ensuite écrits entre parenthèses et séparés par des virgules ;\n- il existe des fonctions sans paramètre, les parenthèses sont néanmoins obligatoires et restent vides ;\n- il ne faut pas oublier les __deux points__ après les parenthèses de la première ligne ;\n- le corps de la fonction est un bloc d'instructions qui contient toutes les lignes qui doivent être exécutées lorsque la fonction est appelée. Le corps de la fonction doit nécessairement être __indenté__, c'est-à-dire qu'il doit être décalé d'une tabulation par rapport à l'instruction `def`.\n\nTrès souvent, le corps de la fonction se terminera par l'instruction `return` suivie de la ou des valeurs que la fonction doit renvoyer. Si la fonction doit renvoyer plusieurs valeurs, celles-ci sont à séparer par des virgules.\n\nAinsi, le schéma général d'une fonction Python est :\n\n```python\ndef nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n instructions # sur plusieurs lignes éventuellement\n return valeur1, valeur2, valeur3, etc. # souvent une fonction ne renvoie qu'une valeur\n````\n\nExemple : Voici la fonction inverse implantée en Python\n\n```python\ndef inverse(x):\n y = 1 / x\n return y\n```\n\nque l'on peut aussi écrire plus simplement :\n\n```python\ndef inverse(x):\n return 1 / x\n```\n\nIdentifiez dans ces deux fonctions écrites différemment : leur nom, leur(s) paramètre(s), leur corps, leur(s) valeur(s) renvoyée(s).\n\nRemarque : il existe des fonctions qui ne renvoient aucune valeur, l'instruction return n'est donc pas utilisée dans le corps de ces fonctions."
},
{
"cell_type": "markdown",
@@ -361,9 +315,7 @@
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 6. Valeur de paramètre par défaut"
]
"source": "## 6. Valeur de paramètre par défaut\n\nIl est possible de définir des valeurs par défaut pour les paramètres d'une fonction. Cela permet d'appeler la fonction sans fournir tous les arguments.\n\n```python\ndef saluer(prenom, message=\"Bonjour\"):\n return message + \" \" + prenom + \" !\"\n```\n\nExemples d'appels :\n\n```python\n>>> saluer(\"Alice\")\n'Bonjour Alice !'\n>>> saluer(\"Bob\", \"Salut\")\n'Salut Bob !'\n```\n\n**Remarques** :\n- Les paramètres avec valeur par défaut doivent être placés **après** les paramètres sans valeur par défaut\n- Cela permet de rendre certains paramètres optionnels"
},
{
"cell_type": "markdown",
@@ -496,65 +448,27 @@
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercices\n",
"\n",
"- calcule le min de 2 valeurs passées en paramètre\n",
"- calcule le nombre de voyelles d'une chaine\n",
"- calcule le pgcd de 2 entiers\n",
"- remplace les voyelles par des nombres\n",
"\n",
"- Convertir de Farenheit à Celsius et inversement\n",
"- calculer le discriminant\n",
"- vérification du format d'une plaque d'immatriculation\n",
"- tortue qui trace des formes géomatriques\n",
"\n",
"- différence print / return"
]
"source": "## Exercices\n\n### Exercice 1\n\nÉcrire une fonction `minimum` qui calcule le minimum de 2 valeurs passées en paramètre.\n\n### Exercice 2\n\nÉcrire une fonction `compter_voyelles` qui calcule le nombre de voyelles d'une chaîne de caractères.\n\n### Exercice 3\n\nÉcrire une fonction `pgcd` qui calcule le PGCD de 2 entiers (algorithme d'Euclide).\n\n### Exercice 4\n\nÉcrire une fonction `remplacer_voyelles` qui remplace les voyelles par des nombres (a→4, e→3, i→1, o→0, u→µ)."
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercice X\n",
"\n",
"L'énergie cinétique d'un objet de masse $m$ se déplaçant à la vitesse $v$ est:\n",
"\n",
"$$Ec = \\frac{1}{2} m v^{2}$$\n",
"\n",
"Créer une fonction `energie_cinetique` qui calcule sa valeur à partir des paramètres `masse` et `vitesse`."
]
"source": "### Exercice 5\n\nL'énergie cinétique d'un objet de masse $m$ se déplaçant à la vitesse $v$ est:\n\n$$Ec = \\frac{1}{2} m v^{2}$$\n\nCréer une fonction `energie_cinetique` qui calcule sa valeur à partir des paramètres `masse` et `vitesse`."
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercice X\n",
"\n",
"Construire une fonction, utilisant le module `random`, qui tire au sort un nombre entier entre deux bornes données en arguments."
]
"source": "### Exercice 6\n\nConstruire une fonction `tirage_aleatoire`, utilisant le module `random`, qui tire au sort un nombre entier entre deux bornes données en arguments."
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercice X\n",
"\n",
"Écrire une fonction pour calculer la `factorielle` d'un nombre (un entier non négatif). La fonction accepte le nombre en tant qu'argument. \n",
"\n",
"Exemple: factorielle de 5: 5! = 5x4x3x2x1 = 120"
]
"source": "### Exercice 7\n\nÉcrire une fonction `factorielle` pour calculer la factorielle d'un nombre (un entier non négatif). La fonction accepte le nombre en tant qu'argument. \n\nExemple: factorielle de 5: 5! = 5x4x3x2x1 = 120"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercice X\n",
"\n",
"Écrire une fonction Python qui prend un nombre en paramètre et vérifiez si le nombre est premier ou non. \n",
"\n",
"Remarque: Un nombre premier est un nombre naturel supérieur à 1 et qui n'a pas de diviseur positif autre que 1 et lui-même."
]
"source": "### Exercice 8\n\nÉcrire une fonction `est_premier` qui prend un nombre en paramètre et vérifie si le nombre est premier ou non. \n\nRemarque: Un nombre premier est un nombre naturel supérieur à 1 et qui n'a pas de diviseur positif autre que 1 et lui-même."
},
{
"cell_type": "code",
@@ -585,4 +499,4 @@
},
"nbformat": 4,
"nbformat_minor": 2
}
}