{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Université d’Orléans -- Licence 1 semestre 1 -- 2025-26
Programmation et Algorithmique 1 \n",
"TP 01
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercice 1 - Premier et dernier chiffres d'un nombre entier\n",
"\n",
"Écrire un programme qui demande de saisir un nombre entier positif puis affiche le premier et le dernier chiffres de ce nombre.\n",
"Il est interdit de convertir le nombre en string.
\n",
"Par exemple, le premier chiffre de 3765 est 3 et son dernier chiffre est 5."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"entrez un entier n : 84521\n",
"le premier chiffre de 84521 est 8 et son dernier chiffre est 1\n"
]
}
],
"source": [
"n = int(input(\"entrez un entier n : \"))\n",
"# écrivez votre code ici "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercice 2 - Fizz-Buzz\n",
"\n",
"Écrire un programme qui affiche en ligne les n premiers entiers non nuls (n saisi par l'utilisateur), en remplaçant : \n",
"\n",
"- les multiples de 3 mais pas de 5 par \"fizz\",\n",
"- les multiples de 5 mais pas de 3 par \"buzz\",\n",
"- les multiples communs par \"fizzbuzz\".\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"entrez un entier n : 17\n",
"1;2;fizz;4;buzz;fizz;7;8;fizz;buzz;11;fizz;13;14;fizzbuzz;16;17;"
]
}
],
"source": [
"n = int(input(\"entrez un entier n : \"))\n",
"# entrez votre code ici"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercice 3 - Séparation des nombres impairs et pairs\n",
"\n",
"Écrire un programme qui, à partir d'une liste d'entiers, crée et affiche 2 listes, l'une contenant les éléments pairs et l'autre les éléments impairs de la liste initiale.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"pairs : [32, 12, 8, 2]\n",
"impairs : [5, 3, 75, 15]\n"
]
}
],
"source": [
"# Séparation des nombres pairs et impairs\n",
"# Liste l fournie au départ \n",
"l = [32, 5, 12, 8, 3, 75, 2, 15]\n",
"# écrivez votre code ici"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercice 4 - Triplets de Pythagore\n",
"\n",
"Un triplet d'entiers a, b, c est \"de Pythagore\" s'il existe un triangle rectangle dont les côtés ont pour dimensions a, b et c.\n",
"\n",
"1. Écrivez une fonction *pyth(a, b, c)* qui retourne un booléen disant si oui ou non, le triangle de dimensions a, b et c est rectangle. On supposera que les arguments sont donnés de telle sorte que a soit le plus petit des 3 nombres, et C le plus grand.\n",
"\n",
"2. Écrivez un programme qui demande à l'utilisateur un entier N puis qui liste, sans doublons, les triplets de Pythagore composés de 3 entiers a, b, c inférieurs ou égaux à N. Ce programme utilisera la fonction *pyth*.\n",
"\n",
"Attention aux doublons : (a = 3, b = 4, c = 5) et (a = 3, b = 5, c = 4) seront considérés comme des doublons, car en fait ils représentent le même triangle. Il faudra donc s'assurer, dans votre programme, de n'avoir aucun doublon."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"entrez N : 15\n",
"(3, 4, 5) est un triplet de Pyhtagore\n",
"(5, 12, 13) est un triplet de Pyhtagore\n",
"(6, 8, 10) est un triplet de Pyhtagore\n",
"(9, 12, 15) est un triplet de Pyhtagore\n"
]
}
],
"source": [
"def pyth(a, b, c) :\n",
" pass\n",
"\n",
"N = int(input(\"entrez N : \"))\n",
"# écrivez votre code ici"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercice 5 - Palindrome 1\n",
"\n",
"Un palindrome est un mot qui se lit identiquement de gauche à droite et de droite à gauche comme « radar » et « ressasser ».\n",
"1. Écrivez une fonction *inverse(chaine)* qui prend en argument une chaîne de caractères et qui retourne la chaîne de caractères inversée. Par exemple inverse(\"abcde\") retournera \"edcba\". Pour cette fonction vous utiliserez une boucle qui lit la chaîne \"à l'envers\" et construit au fur et à mesure de la lecture la chaîne inverse.\n",
"\n",
"3. Écrivez une fonction *estUnPalindrome(chaine)* qui utilise la fonction précédente et qui retourne True si *chaine* est un palindrome, et False sinon.\n",
"\n",
"2. Écrivez un programme qui demande à l'utilisateur un mot et qui dit si oui ou non le mot entré est un palindrome, en utilisant la fonction précédente. Par exemple, il affichera :\n",
"\n",
"« radar » est un palindrome\n",
"\n",
"« python » n’est pas un palindrome."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"entrez votre mot : kayak\n",
"kayak est un palindrome\n"
]
}
],
"source": [
"# Détermine si une chaîne de caractères est un palindrome\n",
"def inverse(chaine) :\n",
" pass\n",
"\n",
"def estUnPalindrome(chaine) :\n",
" pass\n",
"\n",
"mot = input(\"entrez votre mot : \")\n",
"# écrivez votre code ici\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercice 6 - Palindrome 2\n",
"\n",
"Un phrase est un palindrome si, débarassée de tout caractère non alphabétique, elle forme un mot palindrome. \n",
"\n",
"Par exemple, \"elu par cette crapule !\" est une phrase palindrome car \"eluparcettecrapule\" est un mot palindrome.\n",
"\n",
"1. Écrivez une fonction *reduire* qui prend en argument une phrase et qui construit et retourne la phrase débarassée de tout caractère non alphabétique, et mise en minuscule. Par exemple, reduire(\"Abc02 DE fg !\") retournera \"abcdefg\".\n",
"\n",
"2. Écrivez un programme qui demande une phrase à l'utilisateur et qui dit si oui ou non cette phrase est une phrase palindrôme. Il faudra donc réduire la phrase pour avoir un mot qu'on testera au moyen de la fonction de l'exercice précédent (dont on peut se resservir). "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"entrez votre phrase : toto est gentil !\n",
"toto est gentil ! n'est pas une phrase palindrome\n"
]
}
],
"source": [
"# Détermine si une phrase est un palindrome\n",
"def reduire(phrase) :\n",
" pass\n",
"\n",
"phrase = input(\"entrez votre phrase : \")\n",
"phrase_red = reduire(phrase)\n",
"# écrivez votre code ici\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercice 7 - Tri d'une liste d'entiers\n",
"\n",
"On part d'une liste contenant des entiers naturels. la liste l_triee, initialement vide et à compléter, reprendra les mêmes éléments que l, mais dans l'ordre croissant. Dans cet exercice, vous n'avez **pas le droit** d'utiliser la méthode *sort* qui sait trier les listes, par contre vous pouvez utiliser la fonction native *min* qui permet de retourner la valeur minimum d'une liste, ainsi que la méthode *remove* des listes.\n",
"\n",
"L'idée est la suivante : au fur et à mesure, et tant que l n'est pas vide, on trouve le minimum de l, on l'ajoute à l_triée, puis on le supprime de l.\n",
"\n",
"1. Écrivez une fonction *demanderListe(n)* qui construit une liste de n entiers positifs **demandés à l'utilisateur**. Attention, la fonction sera capable de reprendre l'utilisateur s'il entre un entier négatif : dans ce cas, la demande sera renouvelée autant que nécessaire. A la fin, la fonction retourne la liste construite.\n",
"\n",
"2. Écrivez une fonction *trier(l)* qui prend en argument une liste, puis qui retourne une nouvelle liste reprenant les éléments de l, mais dans l'ordre croissant (comme c'est décrit dans l'énoncé).\n",
"\n",
"3. Écrivez un programme qui teste le fonctionnement de ces fonctions. On pourra soit demander n à l'utilisateur, soit l'imposer avec une valeur particulière.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"entrez un nombre entier naturel : 4\n",
"entrez un nombre entier naturel : 3\n",
"entrez un nombre entier naturel : -7\n",
"entrez un nombre entier naturel : 8\n",
"entrez un nombre entier naturel : 1\n",
"entrez un nombre entier naturel : 9\n",
"[4, 3, 8, 1, 9]\n",
"[1, 3, 4, 8, 9]\n"
]
}
],
"source": [
"def demanderListe(n) :\n",
" pass\n",
"\n",
"def trier(l) :\n",
" pass\n",
"\n",
"l = demanderListe(5)\n",
"print(l)\n",
"# écrivez votre code ici\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercice 8 - Hebdomadaires sportifs\n",
"\n",
"Trois hebdomadaires sportifs, Le sport, L'équipe et France Foot se partagent le marché de la presse papier du football. Un lecteur du panel étudié achète un unique hebdomadaire chaque semaine, mais son choix peut varier au cours du temps, ce qui fait que les parts de marché évoluent chaque semaine. Ainsi, d'une semaine à l'autre :\n",
"\n",
"- Le sport garde 70% de ses lecteurs. Un tiers de ceux qui partent achètent l'équipe, et les\n",
"autres achètent France Foot.\n",
"- L'équipe perd 40% de ses lecteurs, dont les trois quarts achètent Le sport et les autres\n",
"France Foot.\n",
"- France Foot perd 20% de ses lecteurs, qui se répartissent équitablement entre L'équipe\n",
"et Le sport.\n",
"\n",
"Au début de l'étude (semaine 0), on a constaté la répartition suivante :\n",
"- Le sport : 30%\n",
"- L'équipe : 35%\n",
"- France Foot : 35%\n",
"\n",
"On souhaite savoir comment évolue la répartition.\n",
"\n",
"Vous répondrez à cette question en faisant évoluer une liste [s, e, f] de trois valeurs représentant les parts de marché de chacun des 3 hebdomadaires.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"combien de semaines après la semaine 0 ? 4\n",
"en semaine 0 la répartition est : [30, 35, 35]\n",
"en semaine 1 la répartition est : [35.0, 27.5, 37.5]\n",
"en semaine 2 la répartition est : [36.5, 23.75, 39.75]\n",
"en semaine 3 la répartition est : [36.65, 21.875, 41.475]\n",
"en semaine 4 la répartition est : [36.365, 20.9375, 42.6975]\n"
]
}
],
"source": [
"def semaineSuivante(l) :\n",
" pass\n",
"\n",
"n = int(input(\"combien de semaines après la semaine 0 ? \"))\n",
"repartition = [30, 35, 35]\n",
"# écrivez votre code ici"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercice 9 - Composition d'un nombre\n",
"\n",
"Écrire un programme qui saisit un nombre entier (sans zéro inutile devant), puis affiche la composition du nombre saisi, selon le modèle décrit dans l'exemple suivant.\n",
"\n",
"Par exemple, si le nombre saisi est 127412377, le programme affichera :\n",
"composition du nombre 127412377 :\n",
"\n",
"- 1 est présent 2 fois \n",
"- 2 est présent 2 fois\n",
"- 3 est présent 1 fois\n",
"- 4 est présent 1 fois\n",
"- 7 est présent 3 fois\n",
"- chiffres absents : 0, 5, 6, 8, 9,\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"entrez un nombre entier : 141568200\n",
"- 0 est présent 2 fois\n",
"- 1 est présent 2 fois\n",
"- 2 est présent 1 fois\n",
"- 4 est présent 1 fois\n",
"- 5 est présent 1 fois\n",
"- 6 est présent 1 fois\n",
"- 8 est présent 1 fois\n",
"chiffres absents : 3, 7, 9, \n"
]
}
],
"source": [
"n = int(input(\"entrez un nombre entier : \"))\n",
"# écrivez votre code ici\n",
" "
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.12.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}