ALGORITHMIQUE AU LYCEE - Créer un blog gratuitement sur...

LE BASTARD YANNICKEnseignant au LEGTA Frédéric Bazille (34)

ALGORITHMIQUE AU LYCEEversion 1.0

Avant propos

Les présentes notes sont inspirées d'une expérience de trois ans en lycée et sur deux niveaux différents : Licence de Biologie au LEGTA de Venours (86) : de 2008 à 2010, ainsi qu'en classe de seconde générale et technologique à l'issu de la réforme des programmes (été 2009) durant deux années : 2009-2010 au LEGTA de Venours et 2010-2011 au LEGTA Frédéric Bazille (34). Mes sources sont diverses : réflexions personnelles, conversations avec des collègues (je remercie notamment Jacques Texier pour son importante contribution), lectures sur le web, ainsi que l'excellent livre de Gérard Swinnen : Apprendre à programmer avec Python. J'ai eu la chance de pouvoir enseigner pendant deux années complètes à des effectifs réduits, ce qui a permis une utilisation efficace des salles informatiques de l'établissement, mais surtout une régularité dans l'apprentissage des concepts pour les élèves et les étudiants, à raison de 2h/semaine pour la classe de licence et d'une heure par quinzaine en moyenne pour la classe de seconde. Ces conditions, il est vrai, exceptionnelles ont permis la réalisation de quelques projets de classe, par groupe de trois élèves en seconde et de deux pour les étudiants. La réforme de la filière S prévoit la continuité de l'apprentissage de l'algorithmique et de sa mise en œuvre sur calculette ou ordinateur jusqu'en terminale. Ces notes tiennent compte de cette évolution, et proposent un suivi à différent niveaux : depuis l'apprentissage qui peut être réalisé dès la classe de seconde jusqu'à l'écriture de scripts mathématiquement plus consistants en lien avec le programme de la terminale S. Les sujets abordés ne sont en rien originaux, mais la démarche peut-être en proposant une progression dans l'apprentissage des concepts, avec une analyse des difficultés rencontrées, s'appuyant sur l'expérience effective sur le terrain. Un outil sera utilisé : le langage de programmation Python. Des séances d'initiation sont proposées par ordre chronologique pour acquérir les bases puis sous forme de TP réalisables en classe. On utilisera parfois d'autres logiciels : tableur Open Office, grapheur, logiciel de calcul formel pour certains sujets.Ces notes ne sont pas du tout exhaustives sur le sujet à traiter et je serai infiniment reconnaissant au lecteur de toutes les suggestions ou critiques qu'il voudra bien me formuler.

Utilisation de ces notes

Dans le cadre d'une utilisation tout au long des trois années de lycée : seconde générale et technologique, première et terminale scientifique, ces notes ont été découpées en plusieurs chapitres avec des buts bien précis. Ils sont adaptés à chacun des niveaux. On considère ici essentiellement la classe de seconde GT, le reste des chapitres est en construction... et en test ! Même si quelques prolongements seront donnés dans les deux derniers chapitres.

Classe de seconde Chapitres 2 et 3 : On met en place les notions fondamentales de boucle et d'instruction conditionnelle et leur mise en œuvre sur Python.

Le Chapitre 4 regroupe des idées de projets faisables à ce niveau par groupes d'élèves. Tous sont entièrement décortiqués et corrigés.

Chapitre 5 : correction des exercices et des TP du chapitres 3.

Classes de première et de terminale SChapitre 6 : quelques TP et leurs corrigés.

Thèmes d'étudeChapitre 7 : ils sont utilisables dans toutes les sections du lycée, voire en L1. Leur but est d'offrir des activités de prolongement du cours et d'ouverture en collaboration avec les autres TICE.

TABLE DES MATIERES

Chapitre 1 : Motivations...................................................................................................................5

Chapitre 2 : Notions d'algorithmique..............................................................................................8Fiche élève n°1...........................................................................................................10Fiche professeur n°1...................................................................................................16Fiche élève n°2...........................................................................................................23Fiche professeur n°2...................................................................................................26

Chapitre 3 : Python..........................................................................................................................30Langage Python..........................................................................................................32Séance Python n°1......................................................................................................33Séance Python n°2......................................................................................................39Séance Python n°3......................................................................................................43Séance Python n°4......................................................................................................45Séance Python n°5......................................................................................................47Séance Python n°6......................................................................................................51Fiches de complément Python....................................................................................55Fiches de TP en seconde GT.......................................................................................63

Chapitre 4 : Projets en seconde GT.................................................................................................74Énoncé des projets......................................................................................................76Corrigé des projets......................................................................................................85

Chapitre 5 : Corrigé des exercices du chapitre 3...........................................................................97

Chapitre 6 : TP en filière S.............................................................................................................115Énoncé des TP...........................................................................................................117Corrigé des TP...........................................................................................................125

Chapitre 7 : Thèmes d'étude..........................................................................................................142Statistiques et probabilités........................................................................................144Géométrie..................................................................................................................170Analyse.....................................................................................................................178Arithmétique.............................................................................................................187

Bibliographie...................................................................................................................................196

CHAPITRE 1 : MOTIVATIONS

Conformément au BO n°30 du 23 Juillet 2009, l'algorithmique a été introduite dans le cadre du nouveau programme de seconde générale et technologique dont voici un extrait.

Algorithmique (objectifs pour le lycée)La démarche algorithmique est, depuis les origines, une composante essentielle de l’activité mathématique. Au collège, les élèves ont rencontré des algorithmes (algorithmes opératoires, algorithme des différences, algorithme d’Euclide, algorithmes de construction en géométrie). Ce qui est proposé dans le programme est une formalisation en langage naturel propre à donner lieu à traduction sur une calculatrice ou à l’aide d’un logiciel. Il s’agit de familiariser les élèves avec les grands principes d’organisation d’un algorithme : gestion des entrées-sorties, affectation d’une valeur et mise en forme d’un calcul.Dans le cadre de cette activité algorithmique, les élèves sont entraînés :• à décrire certains algorithmes en langage naturel ou dans un langage symbolique ;• à en réaliser quelques uns à l’aide d’un tableur ou d’un petit programme réalisé sur une

calculatrice ou avec un logiciel adapté ; • à interpréter des algorithmes plus complexes.

Aucun langage, aucun logiciel n’est imposé.L’algorithmique a une place naturelle dans tous les champs des mathématiques et les problèmes posés doivent être en relation avec les autres parties du programme (fonctions, géométrie, statistiques et probabilité, logique) mais aussi avec les autres disciplines ou la vie courante.À l’occasion de l’écriture d’algorithmes et de petits programmes, il convient de donner aux élèves de bonnes habitudes de rigueur et de les entraîner aux pratiques systématiques de vérification et de contrôle.

Instructions élémentaires (affectation, calcul, entrée, sortie).Les élèves, dans le cadre d’une résolution de problèmes, doivent être capables :• d’écrire une formule permettant un calcul ;• d’écrire un programme calculant et donnant la valeur d’une fonction ;

ainsi que les instructions d’entrées et sorties nécessaires au traitement.Boucle et itérateur, instruction conditionnelleLes élèves, dans le cadre d’une résolution de problèmes, doivent être capables :• de programmer un calcul itératif, le nombre d’itérations étant donné ;• de programmer une instruction conditionnelle, un calcul itératif, avec une fin de boucle

conditionnelle.

S'appuyant sur cette ligne, les présentes notes ont pour but de : 1. Faire l'analyse détaillée d'un problème (géométrique, numérique, de la vie courante).2. De proposer un algorithme, éventuellement plusieurs, apportant une solution.3. De le mettre en œuvre à l'aide de l'outil informatique.

La démarche adoptée a été la suivante :• Définir les tenants et les aboutissants de l'algorithmique.• Écrire des algorithmes en pseudo-langage et les « faire tourner à la main ». Y ont été

notamment définies les notions d'affectation, de boucle et d'instruction conditionnelle.• Passer à la programmation en « langage machine » à l'aide du langage Python

AVERTISSEMENT : Il ne s'agit en aucun cas de réaliser un apprentissage poussé de ce langage : des ouvrages ou des sites web didactiques conçus dans ce but existent déjà ; l'idée est de s'en servir comme miroir de la réflexion de l'élève en soulevant les difficultés rencontrées dans la pratique par le professeur.

Quels sont donc les intérêts d' utiliser un ordinateur ou une calculatrice ?

1. Le face à face élève-machine est différent de celui, plus traditionnel, élève-professeur. Les élèves, habitués pour la très grande majorité à l'ordinateur sont familiers avec cet instrument, du moins pour certaines utilisations. Cette familiarité, cette habitude du visuel de l'écran est un point positif pour l'apprentissage. Très peu sont réfractaires à son utilisation.

2. Autre intérêt de ce face à face élève-machine : Lorsque la machine dit « non », il n'y a pas de contestation possible comme devant un être humain. La machine ne pardonne aucune erreur de syntaxe : voilà un excellent apprentissage de la rigueur. Il faut recommencer à la moindre faute de frappe. Même chose en cas de mauvaise conception du programme.

3. Enfin, la possibilité de voir très rapidement le résultat de son travail devant ses yeux. Dans une génération habituée à zapper, c'est un plus. Le fait de ne pas aboutir sur une machine au résultat escompté pousse le plus souvent à la ténacité : « ce n'est quand même pas un ordi qui va me résister !! »

CHAPITRE 2 : NOTIONS D'ALGORITHMIQUE

Objectifs et mise en œuvre

Le présent chapitre se compose de deux fiches élèves et autant de fiches professeur, contenant les corrigés des exercices proposés, ainsi que des commentaires pédagogiques liés aux séances. Les objectifs au cours de ces séances formelles, mais néanmoins instructives, pour ne pas dire indispensables pour la suite sont :

• Définir ce qu'est un algorithme et la démarche algorithmique à travers quelques exemples géométriques et calculatoires.

• Introduire les notions de variables, de boucle et d'instruction conditionnelle.• Savoir interpréter quelques algorithmes simples.• Créer des algorithmes en langage naturel, prêts à être interprétés en langage machine.

Une fiche de synthèse clôt ce chapitre.

Les séquences sont supposées durer entre deux et trois heures chacune.

Fiche élève n°1

Prolégomènes

Avant de définir précisément ce qu'est l'algorithmique et quels en sont les buts, intéressons-nous de suite à un premier exemple graphique : la construction d'un objet fractal appelé flocon de Von Koch.

On donne ici les deux premières étapes. A vous d'en déterminer la troisième ainsi que le processus général qui permet de passer de l'étape n à l'étape n + 1.

Flocon à l'étape 0 Flocon à l'étape 1 Flocon à l'étape 2

Récapitulons ce processus ; il comprend deux instructions à effectuer qui sont :

•

•

Définitions : On peut définir un algorithme comme une suite d'instructions précises, à appliquer dans un ordre précis, pour arriver en un nombre fini d'étapes à un certain résultat. L'algorithmique est la science des algorithmes (création, amélioration...)

Premiers exercicesDans les deux exercices qui suivent, vous pouvez utiliser les instructions suivantes :

1. Avancer (d'une longueur donnée)2. Tourner à gauche ou à droite (d'un angle donné en degré)

On suppose que le « crayon » se déplace par défaut horizontalement et vers la droite au départ.

Exercice 1 : Écrire un programme permettant de construire un carré de côté 50 tout en revenant à la position de départ.

Exercice 2 : Écrire un programme permettant de construire un triangle équilatéral de côté 100 tout en revenant à la position de départ.

Remarque : Dans l'exercice 1 comme dans le suivant, un même bloc d'instructions a été répété plusieurs fois. Repérer lequel dans chacun des deux cas.

Cette répétition des mêmes instructions un certain nombre de fois peut être « résumée » en introduisant une notion très importante en programmation, et très économique au niveau du nombre de lignes à écrire.

Les instructions répétitives : notion de boucle

Il existe essentiellement deux méthodes pour écrire une boucle, c'est-à-dire un procédé qui permet la répétition un certain nombre de fois d'un même processus (addition, multiplication, etc...).

Afin de les mettre en pratique, nous allons résoudre l'exercice 1 de cette manière.

METHODE 1

Analysons le programme en langage naturel suivant :

i ← 0Tant que i<4 (ou i<=3) faire avancer de 50 tourner à gauche de 90° i ← i + 1

Fin Tant que

J' affecte à i la valeur 0Tant que la condition annoncée est vraie, on effectue les deux instructions qui suivent

On réaffecte à i sa valeur précédente augmentée de 1

Quel est le résultat obtenu ?

On peut alors résumer la structure de boucle décrite ici de la manière suivante :

Remarques : Si la condition n'est pas vérifiée au début, alors le bloc d'instructions ne sera pas exécuté du tout.ATTENTION ! Pour que l'algorithme soit correct, il est nécessaire que la condition cesse d'être vérifiée au bout d'un nombre fini de répétitions. Sinon, le programme « boucle indéfiniment ».

Tant que condition vérifiée faire

Bloc d'instructions

Fin Tant que

Exercice 3 : Que fait le programme suivant ?

S ← 80Tant que S>20 faire

S ← S + 10Fin Tant que

METHODE 2

Une autre manière courante d'écrire une boucle est :

Pour i variant de 0 à 3 (ou de 1 à 4) faire avancer de 50 tourner à gauche de 90°Fin Pour

La variable i évolue comme indiqué, par défaut de 1 en 1.Les deux instructions suivantes sont alors effectuées

Le résultat obtenu est exactement le même : le dessin d'un carré de côté 50.

On peut alors résumer la structure de boucle décrite ici de la manière suivante :

Exercice 4 : Écrire deux programmes utilisant chaque type de boucle pour résoudre l'exercice 2.

Problème type : on veut calculer la somme S = 123…99100 .

Analyse : Bien évidemment, on ne va pas saisir à la machine cette longue opération ! Il nous faut donc trouver un moyen pour que cette dernière l'exécute, mais en écrivant le moins de lignes possible. On commence par remarquer que l'opération qui est sans cesse utilisée est l'addition. D'où l'idée d'utiliser une boucle : on répète plusieurs fois le même procédé : ici additionner. Additionner oui, mais quoi ? 1 d'abord, puis 2, puis 3, … , jusqu'à 100. Autrement dit on additionne une suite de nombres qui « varient », dans le cas présent de 1 en 1.

L'idée essentielle est de calculer S petit à petit, comme on le ferait à la main en ajoutant peu à peu tous les termes contenus dans l'addition. Comme S va évoluer et les termes qui la composent aussi, on a l'idée d'introduire deux variables : S elle-même et un « compteur » i, qui devra prendre successivement les valeurs 1, 2, 3, …, 100.

Nous allons résoudre ce problème en créant un algorithme efficace, utilisant (mais ce n'est pas une obligation), le premier type de boucle.

Pour i variant de 0 à N (ou de 1 à N) faire

Bloc d'instructionsFin Pour

Mise en œuvre : Instructions Signification

S ← 0i ← 1Tant que i ≤ 100 faire S ← S + i i ← i + 1Fin Tant que

Afficher S

On affecte à S la valeur 0 (valeur initiale)On affecte à i la valeur 1 (valeur initiale)La condition est posée: i varie jusqu'à 100

On réaffecte à S sa valeur précédente plus la valeur actuelle de i On réaffecte à i sa valeur augmentée de 1

Une fois sorti de la boucle, on affiche S

Vous allez à présent « faire tourner l'algorithme à la main », c'est-à-dire regarder, étape par étape l'évolution des variables i et S, et enfin le résultat final. Pour cela, compléter le tableau suivant. Vous ne donnerez pas le résultat du calcul de S à chaque étape, mais seulement l'écriture de S sous la forme d'une somme.

Après l'itération i S0 1 0123...99100

Quelle est la dernière valeur prise par la variable S ? Quel est le résultat affiché par le programme ?

Exercice 5 : Écrire un programme utilisant une boucle Tant que calculant et affichant le résultat de :

1. S = 369…2012. P = 2×4×6×8×…×40

3. S = 1 12 1

3... 1

10

Exercice 6 : Construire la figure suivante en utilisant l'instruction Tant que (longueur d'un côté du quadrillage 50).On partira du point A.

Exercices supplémentaires : Ces exercices sont destinés à vous entraîner à utiliser la notion de boucle. Ils sont classés par ordre progressif de difficulté. Reportez-vous à ceux déjà faits lors de cette séance. Travaillez en profondeur votre compréhension du cours. Il suffit de quelques modifications pour trouver la solution.

Exercice 7 : Vous pouvez utiliser les instructions suivantes :• Avancer (d'une longueur donnée)• Tourner à gauche ou à droite (d'un angle donné en degré)

1. Construire la figure suivante en utilisant une boucle (longueur du côté du quadrillage égale à 30). On partira du point central.

2. En utilisant toujours une boucle, construire la figure suivante (longueur du côté du quadrillage égale à 30). Le repère n'a aucune importance.

Exercice 8 : En utilisant une boucle Tant que, écrivez un programme permettant de calculer puis d'afficher le résultat de la somme suivante :

T = 112 1

2×3 1

2×3×4… 1

2×3×4×…×10Indication : bien analyser de combien de variables vous avez besoin.

Exercice 9 : En utilisant l'instruction Tant que, soit une fois soit deux fois dans le même programme, obtenir le dessin suivant :

Carré de côté 10 et intervalle entre les carrés 10.

Vous disposez en plus de deux instructions :lever le crayon (permet d'avancer sans que ceci dessine quoi que ce soit)baisser le crayon (permet de redessiner à nouveau)

Fiche professeur n°1

Construction du flocon

On donne ici les deux premières étapes. A vous d'en déterminer la troisième ainsi que le processus général qui permet de passer de l'étape n à l'étape n + 1.


Récapitulons ce processus ; il comprend deux instructions à effectuer qui sont :

• On partage chacun des segments en trois segments de longueurs égales.

• On construit extérieurement un triangle équilatéral de base le segment du milieu.

Corrigé des exercices

Corrigé de l'exercice 1 :Avec les instructions dont on dispose, on peut construire un carré de côté 50 de la manière suivante :

Avancer de 50Tourner à gauche de 90°Avancer de 50Tourner à gauche de 90°Avancer de 50Tourner à gauche de 90°Avancer de 50Tourner à gauche de 90°

Remarque : on aurait tout aussi bien pu écrire : Tourner à droite de 90° à chaque fois.

Le bloc d'instructions qui se répète est :

Commentaire pédagogique : Beaucoup d'élèves disent : pourquoi ne pas multiplier ça par 4 ? L'idée de boucle est déjà sous-jacente.

Corrigé de l'exercice 2 :Avancer de 100Tourner à gauche de 120°Avancer de 100Tourner à gauche de 120°Avancer de 100Tourner à gauche de 120°

Le bloc d'instructions qui se répète est :

Commentaire pédagogique : Le « piège » est de penser immédiatement : Tourner de 60°. Le professeur démontre rapidement par un petit dessin au tableau que c'est erroné et laisse trouver aux élèves la bonne mesure d'angle.

Corrigé de l'exercice 3 : La variable S est initialisée à 80. Par conséquent la condition S>20 est vérifiée. Or le bloc d'instructions de la boucle est composée d'une seule ligne : réaffecter à S sa valeur augmentée de 10. Il s'ensuit que la variable S va prendre des valeurs de plus en plus grandes et la condition de la boucle sera toujours vérifiée. Le programme boucle indéfiniment !

Commentaire pédagogique : Cet exercice permet de mettre en garde les élèves sur la condition choisie. On veut arriver à un certain résultat en un nombre fini d'étapes.

Corrigé de l'exercice 4 :

Avec une boucle Tant que Avec une boucle Pouri ← 0Tant que i<3 faire avancer de 100 tourner à gauche de 120° i ← i + 1Fin Tant que

Pour i variant de 0 à 2 (ou de 1 à 3) faire avancer de 100 tourner à gauche de 120°Fin Pour

Commentaire pédagogique : La boucle Tant que, universelle quel que soit le langage de programmation choisie me semble préférable à celle de Pour, dont la syntaxe est très variable. Par ailleurs, on y voit mieux l'évolution du « compteur » i.

Avancer de 100Tourner à gauche de 120°

Avancer de 50Tourner à gauche de 90°

Analyse du problème résolu : Ceci permet de compléter pas à pas le tableau donné aux élèves.

Situation initiale

Comme i est égal à 1 et que 1100 , la condition de la boucle est bien vérifiée, donc cette dernière exécute la suite d'instructions précédente :

• S est remplacé par sa valeur précédente : 0 à laquelle on rajoute la valeur actuelle de i : 1. Ainsi, S = 0 + 1 soit S = 1.

• i est remplacé par sa valeur actuelle : 1 à laquelle on rajoute 1. Ainsi i = 1 + 1 soit i = 2.

Situation après une itération


• S est remplacé par sa valeur précédente : 1 à laquelle on rajoute la valeur actuelle de i : 2. Ainsi, S = 1 + 2

• i est remplacé par sa valeur actuelle : 2 à laquelle on rajoute 1. Ainsi i = 2 + 1 soit i = 3.

Situation après deux itérations

Et ainsi de suite... Tant que la condition de la boucle est valide, le bloc d'instruction est exécuté.

Situation après 99 itérations


• S est remplacé par sa valeur précédente : 1+2+...+99 à laquelle on rajoute la valeur actuelle de i : 100. Ainsi, S = 1 + 2 + … + 100

• i est remplacé par sa valeur actuelle : 100 à laquelle on rajoute 1. Ainsi i = 101

Situation après 100 itérations

Cette fois-ci, i est égal à 101, donc la condition de la boucle n'est plus valide. La boucle s'arrête. Le programme effectue alors la dernière instruction (qui n'était pas dans la boucle) : afficher la valeur de S, c'est-à-dire le résultat de 1 + 2 + … + 100.

i S1 0

i S2 1

i S3 1+2

i S100 1+2+...+99

i S101 1+2+...+100

On remarque, puisque S évolue en premier dans le bloc d'instructions, qu'il y aura toujours 1 d'écart entre i et la dernière valeur apparaissant dans la somme constituant S. Ceci permet de compléter le tableau après 99 itérations.

Après l'itération i S0 1 01 2 12 3 1 + 23 4 1 + 2 + 3...99 100 1 + 2 + 3 + … + 99100 101 1 + 2 + … + 99 + 100

Corrigé de l'exercice 5 :

Question 1 : Il s'agit de sommer tous les multiples de 3 compris entre 3 et 201. L'idée est la même que dans le problème résolu : utiliser une boucle (car on répète l'opération « addition ») et utiliser deux variables : i, variable qui va énumérer touts les termes à additionner et S (la somme recherchée qui va évoluer à chaque itération de i). Un algorithme possible est :

Question 2 : Cette fois-ci, on multiplie tous les entiers pairs de 2 à 40.

On initialise le produit P à 1 (préciser pourquoi pas à 0)On initialise i à 2

On remplace P par sa valeur précédente multipliée par la valeur actuelle de ii est incrémenté de 2 à chaque itération

S ← 0i ← 3Tant que i ≤ 201 faire

S ← S + ii ← i + 3

Fin Tant que

Afficher S

P ← 1i ← 2Tant que i ≤ 40 faire

P ← P*i i ← i + 2

Fin Tant que

Afficher P

Question 3 : Remarquons que l'on peut réécrire la somme cherchée sous la forme

S = 111

21

31

4… 1

10 .

L'idée est la même que dans le problème résolu : utiliser une boucle (car on répète l'opération « addition »). Cette fois encore, on aura besoin de deux variables : i qui prendra successivement les valeurs des dénominateurs successifs 1, 2, 3, … jusqu'à 10, et S qui évoluera à chaque itération de i.

Corrigé de l'exercice 6 :Il s'agit de tracer un hexagone régulier.

Il y a 6 côtés...de longueur 150

Corrigé des exercices supplémentaires :

Question 1 : Dessin d'une spirale dont la mesure des segments varie. L'idée est d'utiliser une boucle car on répète plusieurs fois le même processus : avancer, puis tourner à gauche de 90°. La différence par rapport à la question précédente est qu'à chaque itération, on avance de 30 unités supplémentaires. D'où l'idée d'utiliser deux variables : i qui va compter le nombre de segments de la spirale et l la longueur du premier segment, qui va s'accroître de 30 à chaque itération.

Il y a neuf segments.On avance de l

l est incrémenté de 30

Commentaire pédagogique : on peut très bien n'utiliser qu'une seule variable, ce qu'un certain nombre d'élèves font.

S ← 0i ← 1Tant que i ≤ 10 faire

S ← S + 1/ii ← i + 1

Fin Tant que

Afficher S

i← 0

Tant que i<6 faire avancer de150tourner à gauche de 60°i ← i + 1

Fin Tant que

i ← 0l ← 30Tant que i<9 faire

avancer de ltourner à gauche de 90°l ← l + 30i ← i + 1

Fin Tant que

Question 2 : Dessin d'une spirale dont la mesure des segments varie mais pas consécutivement. L'idée est d'utiliser une boucle car on répète plusieurs fois le même processus : avancer, puis tourner à gauche de 90°. La différence par rapport à la question précédente est que deux segments consécutifs ont la même longueur. D'où l'idée d'utiliser deux variables : i qui va compter le nombre de segments de la spirale et l la longueur du premier segment, qui va s'accroître de 30 à chaque itération. Le bloc d'instructions « avancer, tourner » sera répété deux fois par rapport à la question 1.

Corrigé de l'exercice 8 : Remarquons que l'on peut réécrire la somme cherchée sous la forme

T = 11 1

1×2 1

1×2×3 1

1×2×3×4… 1

1×2×3×4×…×10 .

Cette fois-ci, on aura besoin de trois variables : i qui prendra successivement les valeurs 1, 2, 3, … jusqu'à 10, P qui prendra successivement les valeurs 1, 1×2 , 1×2×3 , …, jusqu'à

1×2×…×10 et T qui évoluera en même temps que les deux autres variables.

Tableau des 2 premières itérations en partant des conditions initiales.

i ← 0l ← 30Tant que i<6 faire

avancer de ltourner à gauche de 90°avancer de ltourner à gauche de 90°l ← l + 30i ← i + 1

Fin Tant que

i ← 1

P ← 1

T ← 0

Tant que i ≤ 10 faire

P ← P*i

T ← T + 1/P

i ← i+1

Fin Tant que

Afficher T

i P T

1 1 0

2 1 1

3 2 1 + 1 / 2

valeurs initialesAprès

itération 1Après

itération 2

Corrigé de l'exercice 9 : Cet exercice va nécessiter deux boucles, donc deux compteurs i et j par exemple ; l'un servira pour dessiner un carré, l'autre servira pour le nombre de carrés à dessiner. Attention de ne pas oublier les espaces entre les carrés !

j est le compteur qui sert à dessiner les 10 carrés

i est le compteur qui sert à dessiner les 4 côtés d'un carréBien analyser pourquoi il est placé ici !

on avance de 10+10 = 20 comme demandé dans l'énoncé

Remarque : Les blocs d'instructions sont indentés. On verra plus loin que cette écriture est essentielle lorsque l'on écrit un programme en langage Python.

Commentaire pédagogique : Il est intéressant de faire apparaître bien précisément les blocs d'instructions en précisant à quelle boucle ils sont rattachés.

j ← 0Tant que j<10 faire

i ← 0Tant que i<4 faire

avancer de 10tourner à gauche de 90°i ← i + 1

Fin Tant que lever le crayonavancer de 20baisser le crayonj ← j+1

Fin Tant que

Fiche élève n°2

Instructions conditionnelles

Nous avons vu à la séance précédente la notion de boucle, utilisée dans le cas où une même suite d'opérations est répétée un certain nombre de fois. Nous allons nous intéresser ici au cas d'instructions conditionnelles. Cette notion permet à un algorithme d'effectuer certaines instructions seulement si une certaine condition est remplie. Ceci prend la forme suivante en pseudo-langage :

Dans le cas où la condition de départ n'est pas vérifiée, il est également possible d'indiquer à l'algorithme une alternative qu'il doit effectuer. On obtient alors la structure suivante :

Exercice 1 Écrire dans la zone de texte adjacente le résultat affiché à l'écran par l'ordinateur pour chacun des programmes suivants :

Question 1N ← 4a ← 7Si N<a faire

écrire « Eh »Sinon

écrire « Oh »

Question 2i ← 1Tant que i<5 faire

Si i est divisible par 2 faireécrire 3*i

Sinonécrire i

i ← i + 1Fin Si

Fin Tant que

Si (condition vérifiée) faire

Bloc d'instructions

Fin Si


Bloc d'instructions n°1

Sinon faire

Bloc d'instruction n°2

Fin Si

Exercice 2Écrire un programme qui demande à l'utilisateur d'écrire son sexe à l'écran : M pour masculin ; F pour féminin.

a) Si l'utilisateur saisit M, l'ordinateur affichera : Bonjour monsieur !b) Si l'utilisateur saisit F, l'ordinateur affichera : Bonjour mademoiselle !

Le symbole de comparaison égalité se note =Vous avez le droit aux instructions suivantes :• Si … Sinon• écrire (un texte apparaissant à l'écran)• lire (un texte sur l'écran de l'ordinateur)

Notons le cas où la condition de départ peut être constituée de plusieurs autres conditions qui doivent être vérifiées simultanément. Nous obtenons alors une suite d'instructions conditionnelles imbriquées. Il y a essentiellement deux structures pour décrire ceci.

Méthode n°1 Méthode n°2Si (condition 1 vérifiée) faire Si (condition 2 vérifiée) faire Si (condition 3 vérifiée) faire … Si (condition k vérifiée) faire Bloc d'instructions

Si (condition 1 vérifiée ET condition 2 vérifiée ET… ET condition k vérifiée) faire

Bloc d'instructions

Fin Si

Exercice 3 Un automobiliste veut louer une grosse cylindrée dans une agence. Ceci n'est possible que s'il a 25 ans ou plus et au minimum 5 ans de permis. Écrire un programme qui demande à l'utilisateur son âge, puis le nombre d'années qu'il possède son permis et renvoie le résultat « Location acceptée » ou « Location refusée » selon les réponses saisies.

Analyse : L'utilisateur doit vérifier deux conditions pour que sa location soit acceptée : « Avoir un âge au moins égal à 25 ans » ET « posséder le permis depuis au moins 5 ans ».

Vous avez le droit aux instructions suivantes :• Si … Sinon• écrire (un texte apparaissant à l'écran)• lire (une valeur sur l'écran de l'ordinateur)

On dispose aussi de l'opérateur logique OU au sens mathématique du terme (ce n'est pas un OU exclusif).

Exercice 4 : Déterminer si une année (dont le millésime est introduit par l'utilisateur) est bissextile ou non. (Une année A est bissextile si A est divisible par 4. Elle ne l'est cependant pas si A est un multiple de 100, à moins que A ne soit multiple de 400).

Vous disposez des mêmes instructions qu'à l'exercice précédent ainsi que de l'instruction : est divisible par et de son contraire.

Dans certains cas, il se peut que plusieurs alternatives soient possibles si la condition initiale n'est pas vérifiée. On obtient alors la structure suivante :

Remarque : L'écriture « Sinon si » signifie que les conditions 1, 2,..., N-1 ne sont jamais vérifiées simultanément deux à deux. On a une partition des cas possibles.

Exemple : le fait que la condition 3 soit vérifiée implique nécessairement que les conditions 1 et 2 ne l'aient pas été.

Exercice 5 : Convertir une note scolaire N quelconque (sur 20), entrée par l'utilisateur sous forme de points (par exemple 12,75), en une note standardisée suivant le code suivant :

Note AppréciationN >= 16 A16 > N >=12 B12 > N >= 10 C10 > N >= 8 DN < 8 E

Vous avez le droit aux instructions suivantes :• Si … Sinon si … Sinon• écrire (un texte apparaissant à l'écran)• lire (une valeur sur l'écran de l'ordinateur)

Si (condition 1 vérifiée) faire


Sinon si (condition 2 vérifiée) faire


…etc...

Sinon si (condition N-1 vérifiée) faire

Bloc d'instructions n° N-1

Sinon faire

Bloc d'instruction n° N

Fin Si

Fiche professeur n°2

Corrigé des exercices

Corrigé de l'exercice 1 Question 1 : Il va s'afficher Eh

Question 2 : Il va s'afficher la suite de nombres : 16312

Commentaire pédagogique : La dernière question de cet exercice fait travailler simultanément les notions de boucle et d'instruction conditionnelle, ce qui présente une difficulté. Certains élèves peuvent confondre l'instruction écrire 3*i avec réaffecter à i la valeur 3*i.

Corrigé de l'exercice 2 écrire "Quel est votre sexe ? M ou F ?"lire texteSi texte="M" faire

écrire "Bonjour Monsieur !"Sinon faire

écrire "Bonjour Mademoiselle !"Fin Si

Corrigé de l'exercice 3écrire "Quel est votre âge ? "lire ageécrire "Depuis combien de temps avez-vous le permis ? "lire NSi (age>=25) ET (N>=5) faire

écrire "Location acceptée"Sinon faire

écrire "Location refusée"Fin Si

Corrigé de l'exercice 4

Analyse : Le texte ne semble pas si évident a priori. On peut néanmoins le modéliser à l'aide d'un diagramme de Venn ("patatoïde") qui va donner tout le squelette de l'algorithme. Remarquons que :Tout multiple de 400 est un multiple de 100 (Réciproque fausse)Tout multiple de 100 est un multiple de 4 (Réciproque fausse)

écrire "Entrez une année "lire ASi (A est divisible par 4 ET A n'est pas divisible par 100) OU (A est divisible par 400) faire

écrire "Cette année est bissextile"Sinon faire

écrire "Cette année n'est pas bissextile"Fin Si

Corrigé de l'exercice 5 Analyse : Les différentes conditions sont liées à la valeur de la note N. On peut les résumer dans le programme en pseudo-langage suivant.

Algorithme CommentairesSi N>=16 faire

écrire "A"

Sinon si N>=12 faire

écrire "B"

Sinon si N>=10 faire

écrire "C"

Sinon si N>=8 faire

écrire "D"

Sinon faire

écrire "E"

Fin Si

La première condition est N>=16

Pas besoin d'écrire 16>N>=12 . En effet si la première condition n'est pas vérifiée, on a nécessairement N<16. La seconde condition ne porte plus que sur la comparaison de N à 12.

Pas besoin d'écrire Sinon si N<8 . En effet, lorsque toutes les conditions précédentes ne sont pas vérifiées, il n'y a plus qu'une alternative.

A divisible par 4

A divisible par 100

A divisible par 400

Commentaire pédagogique : Ces exercices sont difficiles de premier abord. Il convient d'avoir travaillé auparavant en classe les notions de logique standard. Bien que ne figurant pas explicitement au programme, les tables de vérité sont un bon outil pour manipuler ET, OU. On peut les travailler à partir d'exemples mathématiques ou non...

Un exemple pour comprendre... Une table de vérité. A, B sont des propositions, C'est-à-dire des « phrases logiques » qui ne peuvent avoir que deux valeurs de vérité : VRAI ou FAUX. Un des principes fondamentaux est celui du « tiers-exclus », à savoir qu'une proposition ne peut pas être vraie et fausse à la fois, alors que toute proposition est vraie ou bien fausse. On peut résumer ceci dans un tableau illustrant les « connecteurs » logiques ET – OU.

A B A et B A ou BF FF VV FV V

Ainsi, pour N entier, la proposition « N est pair » et « N est impair » sera toujours fausse, tandis que la proposition « N est pair » ou « N est impair » est toujours vraie : on parle de tautologie.

Ces opérateurs logiques ET ; OU peuvent être aisément combinés avec les instructions conditionnelles : SI...alors ; Tant que (condition) faire... pour créer des algorithmes plus complexes.

Exercice possible : Vous avez droit aux instructions suivantes :

a) Les opérateurs logiques ET ; OUb) L'instruction conditionnelle SIc) L'instruction « être divisible par » (un entier)d) lire (un entier)e) écrire (une phrase)

Écrire un programme en pseudo-langage demandant à l'utilisateur d'entrer deux entiers. Si ces deux entiers sont divisibles par 3 et par 5, écrire N est divisible par 15, sinon écrire N n'est pas divisible par 15.

Fiche de synthèse

Les notions du cours

Définitions1. Dans un programme, une variable correspond à un emplacement de la mémoire de la

calculatrice ou de l'ordinateur. Elle est repérée par un nom et contient une valeur. 2. La notion d'affectation (ou d'assignation) désigne l'opération par laquelle on établit un lien

entre le nom de la variable et sa valeur (son contenu). On l'a noté ici avec le symbole ←3. L'entrée des données (ou lecture des données) est l'opération qui consiste à saisir des

valeurs pour qu'elles soient utilisées par le programme. On la note « Saisir valeur » ou « lire valeur ». Remarque : une valeur peut être un nombre entier, un nombre réel, une chaîne de caractères...

4. La sortie des résultats (ou écriture des résultats) permet d'afficher les valeurs des variables après traitement. On note cette instruction « Afficher valeur » ou « écrire valeur »

La notion de boucleElle est utilisée lorsqu'une même suite d'instructions doit être répétée un certain nombre de fois. On en rencontre essentiellement deux dans la pratique :

Initialisation des variablesTant que condition faire

Bloc d'instructionsFin Tant que

Pour i variant de 0 à N (ou de 1 à N) faire

Bloc d'instructionsFin Pour

Les instructions conditionnellesSelon qu'une condition est vérifiée ou non, on effectuera un bloc d'instruction ou bien un autre. Par exemple, un nombre entier est pair s'il est divisible par 2 et impair dans le cas contraire.

Dans le cas où l'on dispose de plusieurs alternatives incompatibles les unes avec les autres, la structure précédente est légèrement plus complexe. Par exemple :



Sinon faire


Fin Si

Si (condition 1 vérifiée) faireBloc d'instructions 1

Sinon si (condition 2 vérifiée) faireBlocs d'instructions 2

Sinon faireBlocs d'instructions 3

Fin Si

CHAPITRE 3 : LE LANGAGE PYTHON


Jusqu'à présent, nous avons conçu des algorithmes, c'est-à-dire une suite d'instructions bien précises pour résoudre un problème posé. Cependant un algorithme n'est pas un programme. Ce-dernier doit être écrit dans un langage de programmation que l'ordinateur interprétera.

Je cite : La programmation d'un ordinateur consiste à « expliquer » en détail à une machine ce qu'elle doit faire. Un programme est une suite d'instructions, encodées en respectant de manière très stricte un ensemble de conventions fixées à l'avance, qu'on appelle un langage informatique . La machine est pourvue d'un mécanisme qui décode ces instructions en associant à chaque « mot » du langage une instruction précise. Autrement dit, elle traduit les instructions que vous lui fournissez à l'écran en « langage machine » : une longue suite de 0 et de 1, que l'on appelle le langage binaire. Le système de traduction s'appelle interpréteur ou compilateur. Le langage de programmation est un ensemble de mots clés, associé à un ensemble de règles très précises indiquant comment on peut assembler ces « mots » pour former des « phrases » que l'interpréteur ou le compilateur puisse traduire en langage machine. (Gérard Swinnen : apprendre à programmer avec Python)

A l'issu des deux séances précédentes d'introduction à l'algorithmique, il est indispensable que les élèves se confrontent à un langage de programmation ou du moins un avatar. Les notions vues précédemment vont y trouver des applications innombrables, et la rigueur sera obligatoire, leur créativité mise à l'épreuve. Il faudra en effet :• Repérer les données nécessaires à la résolution du problème (variables, données saisies au

clavier par l'utilisateur...)• Créer un algorithme utilisant ces données pour apporter une solution au problème,• Le transcrire en langage informatique.

Dans ces notes, un logiciel (libre) va être étudié : le langage Python. Comme d'autres logiciels, il a ses particularités, ses forces et ses faiblesses pour l'enseignement du second degré. Sa puissance tient à ses nombreuses possibilités, alliée à une simplicité de syntaxe remarquable.

1. Prise en main du logiciel (séance 1)2. Travail sur la notion de boucle (séances 2 et 3)3. Travail sur la notion d'instruction conditionnelle (séance 4)4. Travail avec des données du type chaîne de caractères et listes (séance 5)5. Travail sur la notion de fonction (informatique)6. Compléments utiles en pratique : les annexes.7. Fiches de TP en lien avec les chapitres du programme de seconde

Certaines séances demandent du temps (2 à 3h ou plus). Des énoncés de TP sont également proposés.

LE LANGAGE PYTHON(version 3.1)

INITIATION AU LANGAGE PYTHONséance n°1

L'environnement de travail

Python présente la particularité de pouvoir être utilisé de plusieurs manières différentes.Vous allez d'abord l'utiliser en mode interactif, c'est-à-dire d'une manière telle que vous pourrez dialoguer avec lui directement depuis le clavier. Cela vous permettra de découvrir très vite un grand nombre de fonctionnalités du langage.

Dans un second temps, vous apprendrez comment créer vos premiers programmes (scripts) et les sauvegarder sur disque dur ou sur clef USB. Si vous utilisez une interface graphique telle que Windows, Gnome, WindowMaker ou KDE, vous préférerez vraisemblablement travailler dans une « fenêtre de terminal », ou encore dans un environnement de travail spécialisé tel que IDLE. Voici par exemple ce qui apparaît dans une fenêtre de Windows :

Les trois caractères « supérieur à » constituent le signal d'invite, ou prompt principal, lequel vous indique que Python est prêt à exécuter une commande.

Calculer avec Python

Vous pouvez utiliser l'interpréteur comme une simple calculatrice de bureau. Testez par exemple les commandes suivantes dans l'environnement IDLE :

>>> 15+3

>>> 2 - 17 # les espaces sont facultatifs

>>> 8 + 3 * 4 # la hiérarchie des opérations mathématiques

# est-elle respectée ?

>>> (8+3)*4

>>> 20 / 3

Comme vous pouvez le constater, les opérateurs arithmétiques pour l'addition, la soustraction, la multiplication et la division sont respectivement +, -, * et /. Les parenthèses sont fonctionnelles.

Affectation-réaffectation

Nous avons vu en cours l'opération d'affectation, qui consiste à donner à une variable une valeur (nombre entier, réel, chaîne de caractères, etc...).

En pseudo-langage, l'opération d'affectation a été symbolisée par le sigle "←"Exemple : a←5 # J'affecte à la variable a la valeur 5

En langage Python l'opération d'affectation s'écrit « = ».

Testez par exemple les commandes suivantes :

>>> a=3>>>a

>>>a+10

>>>a/2

Ne croyez pas que cette affectation soit définitive. On peut réaffecter à la variable « a » une nouvelle valeur en réutilisant le symbole « = ».

>>>a #Quelle est la valeur actuelle de a ?

>>>a=a+5 #On réaffecte à a sa valeur précédente augmentée de 5>>>a

#Que vaut a maintenant ?

Remarque : le signe « = » utilisé ici n'a absolument aucun rapport avec l'égalité au sens mathématique du terme.

Python a une convention :si ce que l'on écrit est vrai, il renverra true en réponse ; si c'est faux, il renverra false.

Par exemple, testez les commandes suivantes (en vous souvenant bien de la dernière valeur affectée à la variable a).

>>> a<1

>>>a>2

>>>a==8 #le sigle « == » est l'égalité classique, au sens mathématique usuel.

>>>a!=4 #le sigle « != » signifie « différent ».

Que va renvoyer l'instruction a>=4 ?

Synthèse partielle : Quelle différence fondamentale faîtes-vous entre l'écriture a=10 et a==10 ?

Typage des variables

La variable a que nous avons rencontrée jusqu'ici appartient à une seule catégorie : celle des entiers. En anglais, cela se dit « Integer ».

Testez les commandes suivantes :

>>>a

>>>type(a) #Quel est le résultat affiché ? Signification ?

>>>b=2.3 #Le séparateur décimal est le point, pas la virgule.

>>>type(b) #Quel est le résultat affiché ? Signification ?

>>>c="Salut"

>>>type(c)

>>>d=[20,35,87,12]

>>>type(d)

>>>e=[5, "coucou",32.5,"Hugh"] #Mélange de types dans un autre ?

>>>type(e)

Ces variables appartiennent à des types très différents. Nous verrons dans quelle mesure les utiliser séparément, puis ensemble. Rappeler ces types :

Opérations sur les variables

Commençons par réaffecter à chacune des valeurs a,b c et d d'autres valeurs. Testez les commandes suivantes:

>>>a=2>>>b=5.5>>>c="Hello " #avec l'espace entre Hello et le guillemet de fin.>>>d="vous !"

>>>a+b

>>>c+d

>>>print(c+d)

#Quelle différence remarquez-vous entre les deux commandes précédentes ?>>>a+c #On ne mélange pas les genres!

>>> a*2

>>>a**2

>>>a**3

>>>a**4

>>>a**5

Que signifie l'opération « ** » entre un nombre et un entier ?

>>>c*2

>>>c*3

Même question entre une chaîne de caractères et un entier non nul pour « * ».

Exercices :1. Signalons au passage la disponibilité de l'opérateur modulo, représenté par le symbole %.

Cet opérateur fournit le reste de la division entière d'un nombre par un autre. Essayez par exemple :>>> 10 % 3 (et notez ce qui se passe !)>>> 10 % 5

Cet opérateur vous sera très utile plus loin, notamment pour tester si un nombre a est divisible par un nombre b. Il suffira en effet de vérifier que a % b donne un résultat égal à zéro.

Vérifier à l'aide de la commande modulo si le nombre 33294 est divisible par 3 puis par 17.

2. Écrire un programme qui permet d'échanger la valeur de 2 nombres a et b indépendamment des valeurs affectées à a et à b au départ.

RécapitulatifA faire sur feuille, sans ordinateur

I) Affectation

Définition : La notion d'affectation (ou d'assignation) désigne l'opération par laquelle on établit un lien entre le nom de la variable et sa valeur (son contenu). On l'a noté en langage usuel avec le symbole ←

Question 1 : Comment se note-t-elle en Python ?

Question 2 : Comment fait-on pour affecter à une variable a la valeur 3 ?

Question 3 : Cette affectation est-elle définitive ? Comment fait-on pour lui ré-affecter une autre valeur ?

Question 4 : Quelle est la signification du symbole « == » en Python ?

Question 5 : On écrit les lignes de commande suivantes. Quel résultat va renvoyer l'ordinateur ?>>>a=5

>>>a

>>>a==3

>>>a==5

>>>a=18

>>>a<20

>>>a>10

>>>a=a+6

>>>a

>>>b=30

>>>b>a

>>>a+b

Question 6 : On écrit les lignes de commande suivantes. Quel résultat va renvoyer l'ordinateur ?>>>a=10>>>b="salut">>>a+b

Même question avec :>>>a=10>>>b= 5.2>>>a+b

II) Typage des variables

Question 7 : Rappeler les différents types de variables rencontrés.

Question 8 : a) Comment assigne-t-on à une variable a le type string ? (chaîne de caractères)

b) Que signifie l'opération concaténer deux chaînes de caractères ?

c) Que va renvoyer les commandes suivantes ?>>>a="Bonjour ">>>b="vous !">>>a+b

>>>print(a+b)

Question 9 : Que va renvoyer la commande suivante ?>>> a="Oui ">>>a*3

Question 10 : On admet que le premier élément d'une liste LIST se note LIST[0], le second LIST[1], etc... On se donne une liste par la commande suivante :>>>LIST=[5,48,-57,"ABC",451.9,"soleil",-789]Que va renvoyer les commandes suivantes ?>>>LIST[0]

>>>LIST[2]

>>>LIST[5]

Pour un complément sur la notion d'affectation avec Python, se référer à la fiche : Plus sur l'affectation.


Objectifs : savoir écrire un script en Python et l'enregistrer pour une utilisation ultérieure. Travailler la notion de boucle.

Consignes : La dernière fois, nous avons utilisé Python en mode interactif grâce à l'interface IDLE (Python Gui). De cette manière, nous avons été en mesure d'apprécier « en direct » quelques outils néanmoins fondamentaux : affectation d'une valeur à une variable, les différents types de variables : int, float, string, list... Mais dès lors que nous fermons la fenêtre dans laquelle nous avons travaillé, toutes les données sont irrémédiablement perdues. Au cours de cette séance, vous allez apprendre comment écrire un script et l'enregistrer pour une éventuelle ré-utilisation dans le futur.

Exercice 1 : votre premier programmeRemarque : Tout ce qui suit le signe dièse : # est considéré par Python comme un commentaire. Cela n'apparaîtra pas dans le script final et n'est destiné qu'à votre intention ou à celle des lecteurs du programme. Il sera ESSENTIEL que vous commentiez vos programmes. D'une cela facilite leur compréhension, et de deux cela vous aidera à les reprendre plus tard si vous ne les avez pas terminé.

1. Rechercher le logiciel Python dans menu démarrer>programmes>Python 3.1>IDLE(Python GUI)

2. Ouvrir une nouvelle fenêtre à l'aide de l'onglet file puis New window. Il apparaît une fenêtre vierge attendant vos instructions.

3. Saisir alors exactement le texte ci-dessous. La mise en forme se fait automatiquement. En particulier l'indentation du bloc d'instructions suivant while est ESSENTIELLE. Elle se fera automatiquement sous IDLE.

4. TRES IMPORTANT : enregistrez ce fichier sur votre clef USB dans le dossier TP Python en lui donnant le nom suivant : TP2_exercice1.py (l'extension .py est capitale)

5. Vous allez compiler le programme en appuyant simultanément sur les touches Ctrl et F5.6. Alors, que se passe-t-il ?

Exercice 2En créant une nouvelle feuille vierge grâce à l'instruction file New Window, répondez au problème suivant. Vous l'enregistrerez sous le nom : TP2_exercice2.pyConstruire la figure suivante en utilisant l'instruction while (longueur d'un côté du quadrillage 50).Quel nom porte cette figure ?

Quelques instructions pour obtenir les figures demandées.

from turtle import *

reset()goto(x,y)forward(x)backward(x)up()

down()

left(x)right(x)

sqrt(x)

Permet d'importer les commandes pour les tracés.On efface tout et on recommenceAller à l'endroit(x,y)Avancer de la distance xReculer de la distance xRelever le crayon (pour pouvoir avancer sans dessiner).Abaisser le crayon pour recommencer à dessiner.Tourner à gauche d'un angle en degrés égal à x.Tourner à droite d'un angle en degrés égal à x.

racine carré de x ( x )

Instructions en Python Commentaireswhile condition: Bloc d'instructions

while signifie « tant que »Les « : » sont indispensables pour dire « faire »L'indentation après while est obligatoire.

Exercice 3 De même, après avoir écrit votre programme dans une nouvelle feuille vierge, enregistrez-le sur votre clef USB sous le nom : TP2_exercice3.py.

En utilisant toujours l'instruction while, soit une fois soit deux fois, obtenir la figure suivante (longueur d'un côté d'un petit carré : 50.

Cette figure devra être construite en une seule fois. On construira d'abord les côtés de l'hexagone puis les trois diagonales.

Exercice 4 Écrire un programme dans une nouvelle feuille vierge calculant et affichant le résultat de

S = 591317...101105 .Vous l'enregistrerez sur votre clef USB sous le nom : TP2_exercice4.py

La commande pour afficher une variable S est : print(S)

Récapitulatif

Écrire une boucle « Tant que » avec Python

Syntaxe en langage usuel Syntaxe en PythonTant que condition vérifiée faire

bloc d'instructionsFin Tant que

while condition vérifiée :

bloc d'instructions

Remarques : • Les : sont obligatoires après la condition associée à while.• l'indentation du bloc d'instructions associé à while est obligatoire.

Utilisation du module turtle

Toute utilisation des outils graphique du module turtle nécessite qu'on l'ait « appelé » par la commande : from turtle import * avant toute chose. On redonne les commandes usuelles pour tracer des figures :

reset()

goto(x,y)

forward(x)

backward(x)

up()

down()

left(x)right(x)

On efface tout et on recommence

Aller à l'endroit(x,y)

Avancer de la distance x

Reculer de la distance x

Relever le crayon (pour pouvoir avancer sans dessiner).Abaisser le crayon pour recommencer à dessiner.Tourner à gauche d'un angle en degrés égal à x.Tourner à droite d'un angle en degrés égal à x.


Objectifs : Travailler la notion de boucle sur des exemples plus poussés.

Consignes : on veillera dans cette séance à enregistrer soigneusement ses programmes pour une utilisation ultérieure dans certains scripts.

Exercice 11. Rappeler dans l’encart de texte ci-dessous un script écrit en Python qui permet de dessiner

un carré de côté 10. Vous utiliserez une boucle while.

2. En modifiant ce script, en écrire un autre qui trace une série de dix carrés de côté 10. L’espace entre les carrés est de 10. Vous enregistrerez votre programme sous le nom : TP3_exercice1.py

3. En modifiant le script précédent, en écrire un autre qui trace une série de quatre carrés dont les côtés augmentent de 15 en 15. Le premier carré a un côté de 10 et l’espace entre chaque carré est de 10. Vous l’enregistrerez sous le nom : TP3_exercice1bis.py

Exercice 2Écrire un script en Python qui trace une série alternée de carrés et d’hexagones espacés de 30. Les carrés comme les hexagones ont leurs côtés égaux à 20. Vous l'enregistrerez sous le nom TP3_exercice2.py.

Exercice 3Considérons une liste de nombres entiers ou flottants :a=[20,3.5,44, 37, 151, 28,15.5]

Le premier élément de la liste se note a[0], le second a[1],etc... Il existe une fonction prédéfinie en Python qui renvoie le nombre d'éléments d'une liste : c'est la fonction len. Dans le cas présent, si l'on tape len(a), l'ordinateur affichera 7.

Écrire un script qui : • part d'une liste de nombres entiers ou flottants, par exemple on prendra la liste précédente. • En parcourant la liste, renvoie au final la somme des éléments qui la constitue. Vous

utiliserez une boucle while et la fonction len.

Vous enregistrerez votre programme sous le nom TP3_exercice3.py

Pour un complément sur la notion de saisie de données avec Python, se référer à la fiche : Plus sur la saisie de données.


Objectifs : Travailler la notion d'instruction conditionnelle.

Consignes : on enregistrera également tous les programmes réalisés au cours de la séance.

Écrire une instruction conditionnelle « Si...alors » avec Python

Syntaxe en langage usuel Syntaxe en PythonSi condition vérifiée faire

bloc d'instructionsFin Si

if condition vérifiée:

bloc d'instructions

Remarques : • Les : sont obligatoires après la condition associée à if.• l'indentation du bloc d'instructions associé à if est obligatoire.

Exercice 1Écrivez un programme qui affiche les 20 premiers termes de la table de multiplication par 7, en signalant au passage (à l'aide d'une astérisque) ceux qui sont des multiples de 3.Exemple : 0 7 14 21* 28 35 42* 49 (penser à utiliser la commande modulo %)Enregistrez votre programme sous le nom TP4_exercice1.py

Exercice 2Écrivez un programme qui :• demande à l'utilisateur de saisir une chaîne de caractères• compte le nombre d'occurrences du caractère « g » dans cette chaîne.

Enregistrez votre programme sous le nom TP4_exercice2.py

Écrire une instruction conditionnelle « Si...alors...sinon » avec Python

Syntaxe en langage usuel Syntaxe en PythonSi condition vérifiée faire

bloc d'instructions 1

Sinon faire

bloc d'instructions 2Fin Si

if condition vérifiée:


else:


Remarques : • Les : sont obligatoires après la condition associée à if ainsi qu'après else.• l'indentation du bloc d'instructions associé à if est obligatoire ; même chose pour celui

associé à else.• if et else sont indentés identiquement

Exercice 3Écrire un programme qui demande à l'utilisateur de saisir un entier naturel N.Si N est un multiple de 5, il sera affiché « multiple de 5 », sinon ce sera « pas multiple de 5 »Enregistrez votre programme sous le nom TP4_exercice3.py

Exercice 4Écrire un programme qui demande à l'utilisateur de saisir un entier naturel N.Si N est pair, le programme dessinera un carré de côté 50, sinon il dessinera un triangle équilatéral de côté 70.Enregistrez votre programme sous le nom TP4_exercice4.py

Écrire une instruction conditionnelle « Si...Sinon si...sinon » avec Python

Syntaxe en langage usuel Syntaxe en PythonSi (condition 1 vérifiée) faire

bloc d'instructions n°1

Sinon si (condition 2 vérifiée) faire


…etc...

Sinon si (condition N-1 vérifiée) faire

bloc d'instructions n° N-1

Sinon faire

bloc d'instruction n° N

Fin Si

if (condition 1 vérifiée):


elif (condition 2 vérifiée):


...etc...

elif (condition N-1 vérifiée):

bloc d'instructions n° N-1else: bloc d'instruction n°N

Remarques : • elif signifie sinon si• Les : sont obligatoires après la condition associée à if ainsi qu'après celles associées aux

elif et à else.• l'indentation du bloc d'instructions associé à if est obligatoire ; même chose pour celui

associés aux elif et à else.• if, elif et else sont indentés identiquement• Toutes les conditions énoncées sont par construction incompatibles deux à deux .

Exercice 5Lors d'un sondage, une personne interrogée a le choix entre trois réponses :• satisfait• moyennement satisfait• pas satisfait

Écrire un programme qui demande à l'utilisateur son avis parmi ces trois propositions dans l'ordre précité. Si la première réponse est donnée, il affichera "Merci ! Very Good" ; si c'est la seconde il affichera "Ok ok" sinon il affichera "Snif ! "


Objectifs : Travailler la notion de chaîne de caractères et de liste.

Consignes : on enregistrera également tous les programmes réalisés au cours de la séance.

Les chaînes de caractères (type string)

Sous Python, une donnée de type string est une suite quelconque de caractères (texte ou même nombres) délimitée soit par des apostrophes (simple quotes), soit par des guillemets (double quotes).

Exemples : >>> phrase1='Voilà un écrit '>>> phrase2='bien intéressant'>>> print(phrase1,phrase2)Voilà un écrit bien intéressant

A l'intérieur d'une chaîne de caractères, l'antislash « \ » permet d'insérer un certain nombre de codes spéciaux (sauts à la ligne, apostrophes, guillemets, etc.). On ne donne que l'exemple des apostrophes.>>> phrase3='Comment s\'appelle-t-il ?' # L'antislash est placé avant l'apostrophe>>> print(phrase3)Comment s'appelle-t-il ?

Python considère les chaînes de caractères comme une collection ordonnée d'éléments. Pour accéder à un élément de la chaîne, on saisit le nom de la variable et on lui accole entre crochets le numéro de l'élément considéré. Attention, la numérotation commence à zéro ! Exemples : >>> mot='erg4ju6op'>>> print(mot[0])e>>> print(mot[3])4

Opérations sur les chaînes de caractères

1. La concaténation

Cette opération consiste à mettre bout à bout les éléments constitutifs de plusieurs chaînes de caractères. Elle se symbolise à l'aide de l'opération +

Exemple : >>> mot1='Mais c\'est '>>> mot2='merveilleux !'>>> print(mot1+mot2) # on concatène mot1 et mot2Mais c'est merveilleux !>>> print(mot2+mot1)merveilleux !Mais c'est # L'ordre est important.

2. Déterminer la longueur d'une chaîne

Cette opération s'effectue grâce à la fonction len(). Exemple :>>> mot="adseghbm55f">>> len(mot)11

3. Convertir une chaîne de caractères en nombre

Exemple : >>> nb1='54'>>> nb1+5Traceback (most recent call last): File "<pyshell#27>", line 1, in <module> nb+5TypeError: Can't convert 'int' object to str implicitly>>> int(nb1)+5 # on convertit la chaîne nb1 en entier grâce à la fonction int()59>>> nb2='20.36'>>> float(nb2)+4 # on convertit la chaîne nb2 en flottant grâce à la fonction float()24.36

Remarque : La chaîne qui ne contient aucun élément se note "" (rien entre les guillemets)

Exercice 1 Écrire un programme qui :• demande à l'utilisateur de saisir une chaîne de caractères• compte le nombre d'occurrences du caractère « a » dans cette chaîne.• Si « a » n'apparaît pas, le programme le rajoute à la fin de la chaîne.

Enregistrez votre programme sous le nom TP5_exercice1.py

Exercice 2Écrire un programme qui recopie une chaîne (dans une nouvelle variable) en l'inversant.Ainsi par exemple, « bouchon » deviendra « nohcuob ».Enregistrez votre programme sous le nom TP5_exercice2.py

Les listes d'éléments (type list)

Sous Python, on peut définir une liste comme une collection d'éléments (éventuellement de types divers) séparés par des virgules, l'ensemble étant encadré par des crochets.

Exemple :>>> maliste=['abc','hello',20,3.14,'coucou']>>> print(maliste)['abc', 'hello', 20, 3.14, 'coucou']

Remarque : Comme les chaînes de caractères, les éléments d'une liste sont numérotés en commençant à zéro.

Exemple :>>> maliste=['abc','hello',20,3.14,'coucou']>>> maliste[0]'abc'>>> maliste[2]20

A retenir : l'indice d'une liste de n éléments commence à 0 et se termine à n-1

Opérations sur les listes

1. Concaténation et duplication

Comme pour les chaînes de caractères, l'opérateur + sert pour concaténer des listes et * pour les dupliquer. Exemple : >>> liste1=[325,'bonjour',65,69]>>> liste2=['ha','gros',564]>>> liste1+liste2[325, 'bonjour', 65, 69, 'ha', 'gros', 564]>>> liste2*3['ha', 'gros', 564, 'ha', 'gros', 564, 'ha', 'gros', 564]

2. Ajouter ou supprimer un élément dans une liste

Python est un langage « orienté objet ». On dispose de méthodes spécifiques permettant d'effectuer certaines actions sur des objets. Nous considérerons ici qu'une liste est un objet.

• Ajouter un élément à la fin d'une listeExemple : >>> maliste=[201,45.8,12]>>> maliste.append(35)>>> maliste[201, 45.8, 12, 35]

On a appliqué la méthode append() à l'objet maliste avec l'argument 35. La syntaxe est :liste.append(objet)

• Ajouter un élément à l'intérieur d'une listeExemple : >>> maliste=[201,45.8,12,35,89]>>> maliste.insert(3,100)>>> maliste[201, 45.8, 12, 100, 35, 89]

La commande liste.insert(indice,objet) insère l'objet dans la liste avant l'indice précisé.

• Supprimer un élément dans une liste

Cette opération s'effectue grâce à la commande del liste[indice]

Exemple : >>> maliste=[55,201,89,33]>>> del maliste[1]>>> maliste[55, 89, 33]

Remarque : la liste vide se note []. La méthode append() est particulièrement adaptée pour construire une liste à partie d'une boucle.

La fonction len() renvoie également le nombre d'éléments d'une liste.

Exemple : >>> maliste=[55,120,40,-8]>>> len(maliste)4

Exercice 3Écrire un programme qui :• demande à l'utilisateur de saisir une liste de nombres, par exemple [20,35,11,56,41,10].• détermine le plus grand élément de cette liste,• affiche cet élément.

Par exemple si l'utilisateur saisit [20,35,11,56,41,10] il s'affichera : le plus grand élément de cette liste est 56Enregistrez votre programme sous le nom TP5_exercice3.py

Exercice 4Écrire un programme qui :• demande à l'utilisateur de saisir deux listes,• alterne les éléments de la première liste avec ceux de la seconde.

Par exemple si l'utilisateur saisit ['coucou','bonjour','ça va ?'] et ['Charles','Edouard','Au poil !'], il s'affichera : ['coucou','Charles','bonjour','Edouard','ça va ?','Au poil !']Enregistrez votre programme sous le nom TP5_exercice4.py


Objectifs : Initiation à la notion de fonction.

Motivation : De même qu'un organisme vivant (donc une structure biologiquement complexe) est constitué d'un assemblage de nombreuses cellules, un programme « compliqué » se structure en un assemblage de plus petits sous-programmes, chacun ayant un rôle bien défini. Nous allons découvrir au cours de cette séance, comment créer ces petits sous-programmes et les utiliser pour en construire un autre plus compliqué. L'utilité de ces sous-programmes, que l'on appellera fonctions est primordiale lorsque l'on veut réaliser plusieurs fois la même opération au sein d'un même programme.

La syntaxe Python pour définir une fonction est la suivante :

• Vous pouvez choisir n'importe quel nom pour la fonction que vous créez, à l'exception des mots réservés du langage, et à la condition de n'utiliser aucun caractère spécial ou accentué (le caractère souligné « _ » est permis).

• Comme les instructions if et while que vous connaissez déjà, l'instruction def est une instruction composée. La ligne contenant cette instruction se termine obligatoirement par un double point, lequel introduit un bloc d'instructions que vous ne devez pas oublier d'indenter .

• La liste de paramètres spécifie quelles informations il faudra fournir en guise d'arguments lorsque l'on voudra utiliser cette fonction (Les parenthèses peuvent parfaitement rester vides si la fonction ne nécessite pas d'arguments). (Gérard Swinnen. Programmer avec Python)

Tout en suivant les instructions, vous répondrez sur cette feuille aux questions posées au cours des exercices.

Exercice 1Pour le moment nous allons utiliser Python en mode interactif. Ouvrez un fichier vierge via : menu démarrer>tous les programmes>Python 3.1>IDLE (Python GUI). Recopiez ensuite le script ci-dessous et tapez deux fois entrée. Le prompt de commande >>> apparaît. Écrire alors table5()

>>> def table5(): # Pas de paramètres en argument icii=0 # Remarquez l'indentation du bloc d'instructions de defwhile i<11:

print("5 *",i," = ",5*i) # Remarquez l'indentation du bloc d'instructions de whilei=i+1

>>> table5()# Que s'affiche-t-il à l'écran ?

def nom_de_la_fonction(liste de paramètres):

Blocs d'instructions

Analyse : • L'intérieur des parenthèses est vide. Dans cette fonction, nous n'avons utilisé aucun

paramètre, c'est-à-dire que l'utilisateur ne se donne pas le choix de faire varier par exemple le choix de la table : 5 est fixé.

• Bien remarquer l'indentation après l'instruction def suivie de deux points. Elle est obligatoire.

Exercice 2 On aimerait pouvoir écrire n'importe quelle table d'entiers. Encore faut-il le choisir ! Pour cela, on mettra celui-ci en paramètre. A la suite de ce que vous avez saisi précédemment, écrire le script ci-dessous : >>> def table_d_entiers(n):

i=0while i<11:

print(n," * ",i," = ",n*i)i=i+1

Appuyez deux fois sur la touche Entrée. Le prompt de commande >>> réapparait. Saisir :>>>table_d_entiers(4)

# Que s'affiche-t-il à l'écran ?Saisir :>>>table_d_entiers(8)

# Que s'affiche-t-il à l'écran ?

Analyse : • Le fait d'avoir mis un entier n en paramètre (à l'intérieur des parenthèses) permet d'afficher

la table de multiplication de l'entier n. Il suffit de remplacer n par la valeur choisie en appelant la fonction.

• On aimerait néanmoins demander à l'utilisateur de saisir n à l'écran pour qu'ensuite la fonction soit appelée et affiche la table de multiplication de n. On séparera donc en deux la construction de la fonction et le programme principal.

Exercice 3A partir de la fenêtre présentement ouverte, ouvrir une fenêtre vierge via file>New Window. Saisir ensuite le script qui suit :

def table_d_entiers(n): # Construction de la fonctioni=0while i<11:

print(n," * ",i," = ",n*i)i=i+1

# programme principal

n=int(input("Saisissez un entier "))table_d_entiers(n)

1. Enregistrez ce programme sous le nom : TP6_exercice3.py2. Appuyez sur Ctrl + F5 simultanément pour le faire fonctionner. Vous choisirez n'importe

quelle valeur de n pour le tester.

Remarque : Tout programme en Python un peu complexe prendra nécessairement la forme suivante :

Exercice 4Ouvrir une autre fenêtre vierge via file>New Window

1. Écrire une fonction carre(taille) permettant de dessiner un carré de côté taille.2. Écrire le programme principal à la suite. Celui-ci :

a) demandera à l'utilisateur de saisir la taille du côté d'un carréb) dessinera 5 carrés de la taille choisie, l'espace entre les carrés étant de 10.

3. Enregistrez le programme sous le nom TP6_exercice4.py4. Le tester en appuyant sur Ctrl+F5 simultanément.

Exercice 5Ouvrir une autre fenêtre vierge via file>New Window

1. Copier le script de la fonction carré précédente. 2. Écrire le programme principal à la suite. Celui-ci :

a) demandera à l'utilisateur de saisir la taille du côté du carré initial. b) construira une suite de 4 carrés dont les côtés s'accroissent de 15 à chaque fois.c) sera tel que l'espace entre les carrés est de 10.

3. Vous enregistrez ce programme sous le nom TP6_exercice5.py et le testerez.

Liste de fonctions

# il peut n'y en avoir qu'une

Programme principal

# on utilise les fonctions précédentes

Exercice 6Écrire un programme utilisant deux fonctions carre(taille) et hexagone(taille) permettant de dessiner le motif suivant. Les carrés comme les hexagones ont leur côtés égaux à 20 et l'espace entre chaque figure est de 30. Vous l'enregistrerez sous le nom TP6_exercice6.py et le testerez.

Exercice 7En créant deux fonctions pentagone et triangle, écrire un programme qui dessine une alternance pentagone (de côté 15, de couleur bleue) et triangle équilatéral (sommet vers le bas, de côté 25, de couleur rouge) 5 fois de suite. L'espacement entre la base d'un pentagone et d'un triangle est de 20. On partira du point de coordonnées (-100,0). Vous l'enregistrerez sous le nom TP6_exercice7.py et le testerez.

Liste de couleurs : 'blue','red','green','yellow','pink',etc...Pour affecter une couleur à une ligne la commande est : color(couleur)

Remarque : Les exercices 4, 5 et 6 ont déjà été traités avant. Quelle différence notez-vous ?

Pour un complément sur la notion de fonction avec Python, se référer à la fiche : Plus sur la notion de fonction

Fiches de complément Python

PLUS SUR LA NOTION D'AFFECTATION

L'affectationDans le langage de programmation Python, on dispose de l'opération d'affectation symbolisée par le signe « égale » : =Par exemple, analysez les séquences d'instructions suivantes :

1. L'affectation simple

>>> a = 3 # J'affecte à la variable a la valeur 3>>> b = 4 # J'affecte à la variable b la valeur 4

2. L'affectation parallèle

>>> a,b = 3,4 # J'affecte simultanément à a la valeur 3 et à b la valeur 4

Ici, la ligne de code ci-dessus parvient exactement au même résultat que les 2 lignes de codes précédentes.

♦♦♦ ATTENTION ! Il convient cependant de bien comprendre comment fonctionne l'affectation parallèle par rapport à l'affectation simple.

Exercice résolu : on souhaite échanger les valeurs de 2 variables a et b.

• Résolution avec l'affectation simple >>> a = 3>>> b = 4

# Fausse bonne idée : échanger directement les valeurs de a et b>>> a = b # a prend la valeur 4>>> b = a # La valeur 4 étant à présent affectée à la variable a, b la prend aussi !

# Au final, a et b valent 4# On va avoir besoin d'une variable supplémentaire pour stocker la valeur initiale de a. Corrigeons-donc notre script...

>>> a = 3>>> b = 4>>> c= a # J'affecte à c la valeur initiale de a, ç'est-à-dire 3>>> a = b # a prend la valeur de b, ç'est-à-dire 4>>> b = c # b prend la valeur de c, ç'est-à-dire la valeur initiale de a : 3

• Résolution avec l'affectation parallèle >>> a,b= 3,4 # J'affecte simultanément à a la valeur 3 et à b la valeur 4>>> a,b = b,a #ET LA, GROSSE DIFFERENCE : les expressions de la partie

droite sont d'abord toutes évaluées avant qu'aucune affectation ne se fasse. Comme b vaut 3 et a vaut 4, le tour est joué !

ExerciceQuelles valeurs vont être affectées à a et à b au final après les lignes de codes suivantes ? >>> a,b = 6,10 >>> a,b= 6,10>>> a = b OU >>> a,b = b, a - b>>> b = a – bOn a aussi la notion d'affectation multiple. Exemple a=b=5 On affecte à a et b la valeur 5

PLUS SUR LA SAISIE DE DONNEES

La commande input()Dans le langage de programmation Python, on dispose de la fonction prédéfinie input() qui permet à l'utilisateur de saisir des données à l'écran.

Par exemple testez :>>> a=input() # l'ordinateur attend la saisie de l'utilisateur. 3>>> a'3' # Attention même si c'est un entier qui est saisi, a est du type « string »>>> type(a)<class 'str'> # Comment le convertir en entier ?>>> a=int(input())3>>> a3>>> type(a)<class 'int'>

La commande input() permet aussi d'afficher du texte. Il suffit d'écrire entre guillemets ou simple quotes le message à l'intérieur des parenthèses. Exemple : >>> a=input("Saisissez un nombre décimal ")Saisissez un nombre décimal # l'ordinateur attend la saisie de l'utilisateur

# Si l'on veut que a soit du type float, on doit composer deux instructions.# On modifie la ligne précédente par :>>> a=float(input("Saisissez un nombre décimal "))Saisissez un nombre décimal 20.6 # je saisis 20.6 par exemple>>> type(a)<class 'float'> # La variable a a été convertie en flottant

On retiendra : la commande a=input() permet d'affecter à la variable a ce qui est saisi par l'utilisateur à l'écran. ATTENTION ! On gardera à l'esprit que a est du type string. Si l'on souhaite travailler avec des nombres ou des listes, il faudra convertir a en composant une instruction adéquate avec la commande input().

PLUS SUR LA NOTION DE BOUCLE

La fonction range() Dans le langage de programmation Python, on dispose de la fonction prédéfinie range() qui permet à l'utilisateur d'obtenir une suite d'entiers en progression arithmétique. Par défaut le pas est de 1.

>>> range(10)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # On commence à 0 >>> range(-3,5)[-3, -2, -1, 0, 1, 2, 3, 4] # On part de -3>>> range(-5, 20, 3) # La raison de la suite est 3 ici[-5, -2, 1, 4, 7, 10, 13, 16, 19]

La boucle Pour

En langage naturel En PythonPour i variant dans ensemble faire traitement des donnéesFin Pour

for i in collection: traitement des données

Remarque 1 : Les « : » sont indispensables.L'indentation du bloc d'instructions est indispensable.

Remarque 2 : on combine avantageusement les fonctions for et range pour des problèmes nécessitant la répétition d'un même bloc d'instructions.

Exemple 1 : Que fait le programme suivant ?>>> a=['Salut', 'Mars', 'Brrr', 'Bye']>>> for i in range(len(a)):. . . print i, a[i]. . .Exemple 2 :a) Écrire un programme en Python utilisant une boucle for qui calcule et affiche le résultat de

S = 123...100 .b) Même question pour S = 246…150

Solution : a) En langage naturel En Python

S ← 0Pour i variant de 1 à 100 faire S ← S + iFin Pour Afficher S

S=0for i in range(1,101): S = S+i

print(S)b) En langage naturel En Python

S ← 0Pour i variant de 2 à 150 (de 2 en 2) faire S ← S + iFin Pour Afficher S

S=0for i in range(2,151,2): S=S+i

print(S)

PLUS SUR LA NOTION DE FONCTION

Comment retourner une valeur ?Lorsqu'une fonction est destinée à renvoyer une valeur, on utilise l'instruction return(argument)

Exercice 1 Dans une fenêtre vierge, recopier le script suivant :

def puissance3(x)return(x**3)

Puis testez ce programme en l'enregistrant sous le nom : TP_fonctions_calcul1.py . Appuyez ensuite sur Ctrl+F5. Testez:

1. puissance3(2)2. puissance3(10)

Exercice 2 On souhaite dans cet exercice calculer le volume d'un parallélépipède rectangle. Écrire une fonction volume dépendant de trois paramètres qui renvoie le volume d'un tel parallélépipède. Testez-la ensuite sur quelques exemples. Vous enregistrerez ce programme sous le nom : TP_fonctions_calcul2.py

Variables locales et globalesLorsque l'on définit une fonction, il est nécessaire de connaître la portée des variables. Exemple : Définissons une fonction en mode interactif sous IDLE. >>> def fonction1():

x=3print("Dans cette fonction x est égal à ",x)

>>> fonction1()Dans cette fonction x est égal à 3>>> x # message d'erreurTraceback (most recent call last): File "<pyshell#14>", line 1, in <module> xNameError: name 'x' is not defined

Remarque : la variable x n'existe pas en dehors de la fonction où elle a été définie. On dit que x est une une variable locale.

Par contre, une valeur déclarée à la racine du module principal est visible partout. Exemple : >>> def fonction2():

print(x)

>>> x=4

>>> fonction2()4>>> x=5>>> fonction2()5

On dit que x est une variable globale. Cette variable est visible dans tout le module.

††† ATTENTION aux types modifiables comme les listes †††

>>> liste=[1,2,3] # liste est une variable globale>>> def change_liste():

liste[1]=-15

>>> change_liste()>>> liste[1, -15, 3] # liste a été modifiée par la fonction change_liste()

De la même manière, en passant une liste en arguments, elle est tout autant modifiable !

>>> liste=[1,2,3]>>> def change_liste2(x): # x est passé en argument

x[1]=-20

>>> change_liste2(liste)>>> liste[1, -20, 3] # liste a été modifiée par la fonction change_liste2()

La règle LGINous avons vu au paragraphe précédent les notions de variables locales ou globales. Il existe aussi un troisième type de variables : les variables internes. Exemple : la fonction len() qui renvoie la taille d'une liste ou d'une chaîne de caractères et qui existe dès qu'on lance Python.

Python traite les variables par ordre de priorité :1. D'abord, il regarde si la variable considérée est une variable locale,2. Ensuite, si elle n'existe pas localement, il regarde si c'est une variable globale,3. Enfin, il regarde si c'est une variable interne.

Exemple : >>> def fonction():

x=10 # x est une variable locale print('Dans la fonction x vaut ',x)

>>> x=20 # x est une variable globale>>> fonction()Dans la fonction x vaut 10>>>print('Dans le module principal x vaut ',x)Dans le module principal x vaut 20

Remarque : Notez bien ce qui s'est passé. x a pris en priorité la valeur qui lui était définie localement par rapport à celle qui lui était définie globalement.

Il est possible de forcer une variable à prendre sa valeur globale dans une fonction avec le mot clé : global

Exemple : >>> def double():

global xx=x*2

>>> x=3>>> double()>>> x6

Remarque : cette notion a son importance lorsque dans une fonction qui renvoie une ou plusieurs valeurs, on souhaite que ces dernières servent dans le programme principal. On doit donc les déclarer en tant que variables globales.

Exemple : On souhaite subdiviser un intervalle [a ; b] en n sous-intervalles égaux. On accepte le chevauchement aux points de subdivision.

def subdivision(a,b,n): global subdi # la variable subdi est déclarée comme globale subdi=[] # on initialise subdi par la liste vide i,c=0,0 while i<=n: c=a+i*(b-a)/n # on construit les points de la subdivision subdi.append(c) i=i+1

return subdi

# programme principala=float(input("Entrer la borne inférieure de l\'intervalle "))b=float(input("Entrer la borne supérieure de l\'intervalle "))n=int(input(" Entrer le nombre d\'intervalles n de la subdivision "))subdivision(a,b,n)print (subdi)

# on compile le programme avec Ctrl+F5Entrer la borne inférieure de l'intervalle 2Entrer la borne supérieure de l'intervalle 10Entrer le nombre d'intervalles n de la subdivision 20[2.0, 2.4, 2.8, 3.2, 3.6, 4.0, 4.4, 4.8, 5.2, 5.6, 6.0, 6.4, 6.8, 7.2, 7.6, 8.0, 8.4, 8.8, 9.2, 9.6, 10.0]

LA RECURSIVITE

Définition : Un algorithme est dit récursif s'il s'appelle lui-même.

Reprenons l'exemple de la factorielle vu en classe. On rappelle que : • n doit être un entier naturel. 1. Si n=0, on a n! = 1 ie 0! = 12. Si n est supérieur ou égal à 1, on a n!=1×2×3×...×n .

n! se lit « factorielle n »

Écrire une fonction factorielle(n) qui renvoie la factorielle d'un entier naturel n choisi par l'utilisateur.

Quel lien existe-t-il entre n ! et n−1 ! ?

n ! = nn−1!

Ce lien nous suggère l'algorithme récursif suivant, où la fonction factorielle va s'appeler elle-même.

def factorielle(n): if n = = 0: return 1 else: return n * factorielle(n-1) # la fonction factorielle est appelée à l'intérieur d'elle

même.

Essayez de comprendre ce qui se passe. Schématisez-le pour n=2.

Exercice : on pose u0 = 2 et pour tout entier naturel n non nul, un = 3un−18 . Créer une fonction suite(n) en utilisant un algorithme récursif capable de calculer n'importe quelle valeur

un .

def factorielle(n):

global fact

if n==0:

fact=1

else:

i,fact=1,1

while i<=n:

fact=fact*i

i=i+1

return fact

Test avec un tableur :Calcul des 20 premiers termes

Utilisation du logiciel Python :

def suite(n): if n==0: return 2 else: return 3*suite(n-1)+8

# programme principal a=0while a<=20: print suite(a) a=a+1

On compile ensuite ce code.

Formule dans B3 :

=3*B2+8A B

1 n u_n2 0 23 1 144 2 505 3 1586 4 4827 5 14548 6 43709 7 1311810 8 3936211 9 11809412 10 35429013 11 106287814 12 318864215 13 956593416 14 2869781017 15 8609343818 16 25828032219 17 77484097420 18 232452293021 19 697356879822 20 20920706402

Résultat à l'écran>>>

2145015848214544370131183936211809435429010628783188642956593428697810860934382582803227748409742324522930697356879820920706402>>>

Fiches de TP en seconde GT

TP GEOMETRIE N°1DISTANCE ET COORDONNEES

Question 1 : Écrire un programme qui étant donné les coordonnées x A et y A d'un point A, puis x B et yB d'un point B, renvoie les coordonnées du point I, milieu du segment [AB].

Sous Python vous créerez une fonction milieu(x_A,x_B,y_A,y_B)

Question 2 : Écrire un programme qui étant donné les coordonnées x A et y A d'un point A, puis x B et yB d'un point B, renvoie la distance AB.

Sous Python la fonction racine carrée se note sqrt() : sqrt(x) est la racine carrée d'un réel positif x. Vous créerez une fonction distance(x_A,x_B,y_A,y_B).

Question 3 : Soit C le cercle de diamètre [AB]. Dans un repère orthonormé on se donne A(-2 ;2) et B(3 ; -5). On cherche à savoir si un point M(x ; y) appartient ou non au cercle C.

1. Écrire un programme utilisant les deux fonctions précédentes qui réponde à la question.

2. Le tester avec M( 1; 14) puis M 2 ; −3652

Rappels mathématiques :

1. Si A xA ; y A et B xB ; y B alors I milieu de [AB] a pour coordonnées

I xAxB

2;

yA yB

2 .

2. Dans un repère orthonormé O ;i ;j , si A xA ; y A et B xB ; y B , alors AB = xB−x A

2 y B− y A2

PS : Vous pouvez répondre à toutes les questions sans utiliser la notion de fonction. La question 3 sera alors plus longue à programmer.

TP GEOMETRIE N°2VECTEURS ET PARALLELOGRAMME

Question 1 : On considère un repère O ;i ;j . On se donne deux points A, B repérés par leurs coordonnées. Écrire un programme qui étant donné les coordonnées x A et y A d'un point A, puis x B et

yB d'un point B, renvoie celles du vecteur AB sous la forme d'une liste.

Sous Python vous pouvez créer une fonction vecteur(x_A,x_B,y_A,y_B)

Question 2 : On se donne quatre points distincts du plan A, B, C et D repérés par leurs coordonnées. 1. Écrire un programme qui étant donné les coordonnées des points A,B,C et D affiche si le

quadrilatère ABCD est un parallélogramme.2. Écrire un programme qui étant donné les coordonnées des points A,B,C et D affiche si le

quadrilatère ABCD est un trapèze.

Vous pourrez vous servir de la fonction créée à la question 1.Les tester avec A(-1 ; 2), B (3 ; 4), C(1 ; 5) et D(9 ; 7)

Question 3 : On se donne trois points du plan A,B et C repérés par leurs coordonnées. Écrire un programme qui étant donné les coordonnées des points A,B,C détermine les coordonnées xD ; yD du point D tel que ABCD soit un parallélogramme.

Rappels mathématiques :

1. Si A xA ; y A et B xB ; y B alors AB xB−x A ; yB− yA . 2. ABCD est un parallélogramme si et seulement si AB = DC3. ABCD est un trapèze si et seulement si les vecteurs AB et DC sont colinéaires.

TP FONCTION TRACE D'UNE COURBE

Comment créer un graphique avec Python ?

Il faut d'abord importer les modules matplotlib et numpy associés à votre distribution de Python et à votre système d'exploitation. Vous pouvez les trouver à l'adresse suivante : http://www.python.org

Exemple : on souhaite tracer la fonction f définie sur [-4 ; 5] par f x = 16

x3− x21 .

Le module matplotlib a tous les outils graphiques utiles pour les tracés de fonctions.Le module numpy possède quant à lui plein de fonctions prédéfinies.

Ouvrez une fenêtre via démarrer>tous les programmes>python 3.1>IDLE (Python Gui)Testez ensuite les commandes suivantes :>>> import matplotlib.pyplot as plt>>> import numpy as np>>> x=np.linspace(-4,5,100) # la courbe est tracée à partir de 100 points>>> plt.plot(x,x**3/6-x**2+1)[<matplotlib.lines.Line2D object at 0x03AD2D10>]>>> plt.show()

Remarque : le curseur de la souris indique les coordonnées du point. Après avoir importé les modules matplotlib et numpy comme dans l'exemple précédent :

http://www.python.org/

Commandes significationnp.linspace(a,b,N)

plt.plot(x,f(x))plt.show()plt.clf()plt.axis([xmin,xmax,ymin,ymax])plt.savefig()plt.grid(True ou False)

On crée une matrice ligne de N valeurs régulièrement espacées entre a et b.

Tracer la fonction f de variable xAfficher le graphiqueEfface la fenêtre graphique Spécifie un rectangle de représentationSauvegarde le graphique en format PNGAffiche une grille en pointillés

Exercice : 1. Tracer dans une fenêtre graphique la courbe représentative C de la fonction f définie sur

[−4 ;8] par f x = x2−3x−10 . On affichera une grille. 2. Résoudre graphiquement l'équation f x = 0 .3. Sur le même graphique, tracer la droite d'équation y = 12 .4. a) Trouver les antécédents de 12 par f.

b) Résoudre graphiquement l'inéquation f x 12 . 5. a) Tracer la droite d'équation y = −10

b) Trouver les coordonnées du sommet S de C.

PS : tracer d'abord tous les graphiques : C et les deux droites avant d'utiliser l'instruction plt.show()Remarquer aussi que x0 = 1 pour le tracé des droites horizontales.

TP PROBAS-STATS N°1

Question 1 : Écrire un programme qui demande à un utilisateur de saisir N notes entre 0 et 20 (N choisi par l'utilisateur) sous la forme d'une liste et N nombres entre 1 et 3 (les coefficients de ces notes), puis qui renvoie la moyenne pondérée de ces N notes.

Question 2 : On considère un dé à 6 faces parfait et 3 urnes numérotées de 1 à 3. L'urne 1 contient 3 boules blanches, 4 boules noires et 3 boules vertes.L'urne 2 contient 2 boules blanches, 2 boules noires et 6 boules vertes.L'urne 3 contient 4 boules blanches, 4 boules noires et 2 boules vertes. Toutes ces boules sont indiscernables au toucher.On considère l'expérience aléatoire qui consiste à lancer d'abord le dé puis :• Si le numéro est 1 ou 2, on tire une boule dans l'urne n°1• Si le numéro est 3, 4 ou 5 on tire une boule dans l'urne n°2• Sinon, on tire une boule dans l'urne n°3.

1. Modéliser cette situation à l'aide d'un arbre de probabilité. On pourra prendre comme événements : « U_1 » : obtenir 1 ou 2 ; « U_2 » : obtenir 3, 4 ou 5 ; « U_3 » : obtenir 6, puis « B » : tirer une boule blanche ; « N » : tirer une boule noire et « V » : tirer une boule verte.

2. Écrire un algorithme modélisant le lancer du dé, suivi du tirage d'une boule dans l'une des 3 urnes et le programmer sous Python.

3. Faire tourner le programme n fois (n choisi par l'utilisateur) et relever la fréquence d'apparition d'une boule blanche, d'une boule noire et d'une boule verte. On testera avec n=50, 100 et 1000.

4. Compléter le tableau donné en annexe avec n=500005. Calculer p(B), p(N) et p(V) et comparer avec les résultats trouvés à la question précédente.

Remarque : Pour simuler le tirage au sort d'un entier aléatoire entre 1 et N, on importe la fonction randint de la bibliothèque random via la commande from random import randint ; randint(a,b) renvoie un entier aléatoire entre a et b. L'instruction break sert à sortir d'une boucle.

Indication : On pourra numéroter les boules de chaque urne pour modéliser le tirage dans les urnes ; par exemple dans l'urne 1 on notera : 1,2,3 pour les boules blanches ; 4, 5, 6, 7 pour les boules noires et 8, 9, 10 pour les boules vertes.

Fréquence Expérience n°

f B f N f V

12345

Moyenne des fréquences

f B est la fréquence d'apparition d'une boule blanche, etc...


Question 1 : Une étude sur 90 arbres d'une plantation a permis de relever les diamètres de ces derniers (exprimé en cm). On a obtenu les résultats suivants :

Diamètre des arbres [0 ; 10[ [10 ; 20[ [20 ; 30[ [30 ; 40[ [40 ; 50[ [50 ; 60[ [60 ; 70[

Effectif 5 11 18 25 16 11 4

3. Tracer un histogramme représentant cette série statistique.4. Tracer le courbe des effectifs cumulés croissants.5. En déduire la valeur du premier quartile, de la médiane.

Question 2 : Générer une liste aléatoire de 10000 entiers compris entre 0 et 2 via les commandes : from random import *liste=[ 1 for n in range(3000)] + [2 for n in range(1500)] + [0 for n in range(5500)]shuffle(liste)

On prélève ensuite un échantillon de 100 entiers via la commande :echantillon=sample(liste,100)

On évalue la proportion de '1' dans cet échantillon.Écrire un script qui prélève un échantillon de 100 entiers compris entre 0 et 2 dans les proportions indiquées au début et renvoie la fréquence de '1' dans l'échantillon.

On recommence 50 fois les deux opérations précédentesModifier le script précédent pour construire une matrice ligne de 50 éléments, chacun d'entre eux correspondant à la proportion de '1' dans les échantillons prélevés. On pourra la noter prop_de_1.

Création d'une boite à moustachesimport matplotlib.pyplot as pltplt.boxplot(prop_de_1,notch=0,sym='+',vert=1,whis=1.5,positions=None,widths=None,patch_artist=False)

Une multitude de boites à moustachesModifier le script précédent pour obtenir une série de 20 boites à moustaches comme créées précédemment.

TP EQUATIONS DE DROITE

Rappels mathématiques : Une équation de droite s'écrit sous la forme x=c (droite verticale) ou sous la forme y=m x p (équation réduite d'une droite non verticale). Le réel s'appelle m est appelé coefficient directeur et p ordonnée à l'origine. Deux droites parallèles (et non verticales) ont le même coefficient directeur. Réciproquement, si deux droites ont le même coefficient directeur, elles sont parallèles (au sens large).

Question 1 : Écrire une fonction estverticale(x_A,y_A,x_B,y_B) qui étant donné deux points A xA ; y A et B xB ; y B détermine si la droite (AB) est verticale ou pas. La valeur

renvoyée par cette fonction sera un booléen : True pour vertical et False dans le cas contraire.

Question 2 : Dans le cas où la droite (AB) ne soit pas verticale, écrire une fonction equation(x_A,y_A,x_B,y_B) qui :• calcule le coefficient directeur m• calcule l'ordonnée à l'origine p• affiche le résultat sous la forme : "La droite (AB) a pour équation y = ",m,"x+",p

On stockera le couple (m,p) dans une liste.

Question 3 : Écrire un programme qui détermine si les droites (AB) et (CD) sont parallèles ou pas. Le cas où ces deux droites sont verticales sera considéré.

Seconde B 2009-2010 le 10/12/2009

Devoir de programmation

Exercice 1 ( ATTENTION, à faire sans l'ordinateur !)Écrire dans la zone de texte adjacente le résultat affiché à l'écran par l'ordinateur pour chacun des programmes suivants :

N°1i,S=1,0while i<6:

S = S + ii = i + 1

N°2from turtle import *forward(50)left(90)forward(30)goto(0,0)

N°3i = 1while i<5:if i%2 = = 0:

print 3*ielse:

print i

N°4N = 4a = 7if N<a:

print « Eh »else:

print « Oh »

N°5a,b=3,4a = bb = aprint a,b

Exercice 2Ecrire un script utilisant la fonction while permettant de calculer S = 1222...102

Exercice 3A l'aide du mode turtle, écrire un script permettant d'obtenir la figure ci-dessous. Cette figure devra être construite en une seule fois. On construira d'abord les côtés de l'hexagone (de longueur 50) puis les trois diagonales. Indication : la fonction while sera utilisée 2 fois.

CHAPITRE 4 : PROJETS EN SECONDE GT


La liste de projets qui suit a été effectivement proposée en classe de seconde générale pendant l'année 2009-2010.

Des groupes de trois élèves ont été constitués à cet effet et la durée de recherche a été de l'ordre d'un mois et demi environ. Ils disposaient de Python chez eux et l'accès à une salle informatique en semaine pour les internes (la grande majorité). Les sujets ont été distribués mi mars 2010 et résolus sous la forme d'un rapport écrit suivi d'une soutenance orale et sur machine en mai de la même année.

L'expérience fut enrichissante, tant pour les élèves que pour le professeur, de par les interrogations qui n'ont pas manqué de se poser, la relative liberté de création jusqu'à l'apprentissage du travail collectif. Une heure par semaine était consacrée en classe à la recherche des activités proposées. Certains projets étaient ardus et ont nécessité beaucoup de travail de fond, ce qui m'a permis également d'éclaircir certains points. Bien entendu, les élèves qui en ont hérité ont reçu une aide plus poussée.

PROJET n°1

Le but de ce projet est de construire une suite d'étoiles à 5 branches de tailles variées. Le choix de la taille de chaque branche et de l'espacement entre chaque étoile est de votre choix.

Vous commencerez d'abord par créer une fonction étoile avec pour variable la taille, que vous utiliserez dans votre script principal.

Indication : pour construire l'étoile à 5 branches, imaginez-là inscrite dans un pentagone régulier. Vous pourrez calculer l'angle ABC .

PROJET n°2

Le but de ce projet est de trouver un nombre mystère choisi par l'ordinateur en un nombre limité d'essais.

Comme pour l'utilisation du mode Turtle pour effectuer des dessins, il faudra demander à l'ordinateur d'appeler une bibliothèque gérant tout ce qui concerne la simulation du hasard. On écrira donc :

from random import *On aura également besoin de la fonction prédéfinie randint(a,b). Cette fonction permet à l'ordinateur de choisir un entier aléatoire (donc non connu de vous a priori) entre les entiers a et b.

Vous écrirez un programme qui demande à l'ordinateur de choisir un entier aléatoire N entre 1 et 100 et proposant à l'utilisateur de le deviner. L'utilisateur aura alors cinq essais maximum pour réussir.

Si au cours de ces essais le nombre saisi par l'utilisateur est plus petit que N, il apparaîtra à l'écran : « plus grand » ; s'il est plus grand, il apparaîtra à l'écran : « plus petit ». Si l'utilisateur le trouve avant les 5 essais, il apparaîtra : « gagné en (nombre d'essais utilisés) ». Si l'utilisateur ne l'a pas trouvé avant les 5 essais réglementaires, il apparaîtra : « perdu ». On affichera alors le nombre mystère qu'il fallait trouver.

PS : Ce n'est pas nécessaire pour ce programme, mais cela peut être utilisé : la fonction prédéfinie break permet de sortir d'une boucle.

PROJET n°3

Le but de ce projet est de construire une « spirale » de 8 triangles équilatéraux de tailles toutes différentes choisies par vous. L'espacement entre les bases des triangles sera de 20 au départ et ira en s'accroissant de 50 en 50 ; de même la taille des côtés des triangles ira en augmentant de 10 en 10. Et important, tous les côtés des triangles seront respectivement parallèles deux à deux.

Vous créerez d'abord une fonction triangle(taille). Pour le script principal, vous utiliserez une boucle while permettant de placer les triangles aux bons emplacements. Le dessin obtenu devra ressembler à ceci : j'ai pris 15 pour côté du premier triangle et je suis parti du point de coordonnées (80,-60).

Indication : on pourra créer les variables abscisse et ordonnee indiquant l'emplacement exact du point de départ des triangles à construire. .On utilisera aussi la commande goto(... ; ...) pour se déplacer à l'endroit voulu.

PROJET n°4

Le but de ce projet est de résoudre le problème suivant :

On demande à l'utilisateur de choisir un entier compris entre 1 et 3999. L'ordinateur le convertit ensuite en nombres romains.

Rappel : En nombres romains, on a :I : un II : deux III : trois IV : quatre V : cinq VI:sixVII : sept VIII : huit IX : neuf X : dixL : cinquante C : cent D : 500 M : mille

Vous chercherez sur Internet le principe d'écriture d'un nombre en nombre romain. Testez-le ensuite sur quelques exemples :

Convertir en nombres romains :• 2397• 3912• 3812

PROJET n°5


Un programme principal saisit une chaîne d’ADN valide et une séquence d’ADN valide (« valide » signifie qu’elles ne sont pas vides et sont formées exclusivement d’une combinaison arbitraire de "a", "t", "g" ou "c").

1. Écrire une fonction valide qui renvoie vrai si la saisie est valide, faux sinon.

2. Écrire une fonction saisie qui effectue une saisie valide et renvoie la valeur saisie sous forme d’une chaîne de caractères.

3. Écrire une fonction proportion qui reçoit deux arguments, la chaîne et la séquence et qui retourne la proportion de séquence dans la chaîne (c’est-à-dire son nombre d’occurrences).

Le programme principal appelle la fonction saisie pour la chaîne et pour la séquence et affiche le résultat.

Exemple d’affichage :Il y a 13.33 % de "ca" dans votre chaîne.

PS : vous rechercherez dans l'aide Python la commande count pour les chaines de caractères. La syntaxe est chaine.count(sous_chaine).

PROJET n°6


Le jeu de NimÉcrire un programme qui joue au jeu de Nim contre un être humain. Le principe est le suivant : Au départ, il y a un nombre N d'allumettes. Tour à tour, chaque joueur (humain comme ordinateur) a le droit de prendre entre 1 et 3 allumettes. Celui qui prend la dernière allumette a perdu.

É tape 1 : On suppose d'abord qu'il y a 15 allumettes initialement et que l'utilisateur joue en premier. On suppose en plus que le joueur ne triche pas en prenant bien entre 1 et 3 allumettes.

É tape 2 : Modifiez le programme précédent de sorte que l'on puisse choisir le nombre initial d'allumettes et qui commence (le joueur humain ou l'ordinateur).

É tape 3 : Finalisez le programme de l'étape 2 en incluant un test qui empêche le joueur humain de tricher.

PS : s'il reste moins de 3 allumettes et que c'est à l'ordinateur de jouer, il adopte une stratégie gagnante. Vous pouvez même programmer, dans le cas où l'ordinateur débute la partie, une stratégie où il gagne à coup sûr !

PROJET n°7

Le but de ce projet est de construire le motif suivant :

Vous fabriquerez d'abord une fonction carre(taille,couleur) et une fonction triangle(taille,couleur). Dans l'exemple choisi le carré a pour côté 50 et le triangle 35. Je me suis placé au départ au point de coordonnées (-100,-100).Sur la rangée du bas comme sur la rangée du haut, l'écart entre le premier carré et le triangle au milieu est de 20, puis de 35 entre le triangle du milieu et le carré de droite.Verticalement, sur la première colonne comme sur la troisième, je passe du premier carré au triangle du milieu avec un écart de 20, puis du triangle du milieu au carré du haut avec un écart de 40.

PROJET n°8

Le but de ce projet est de dessiner le flocon de Von Koch à une étape arbitraire choisie par l'utilisateur et pour un triangle équilatéral initial de côté choisi par l'utilisateur.

Pour rappel, on donne les trois premières figures, correspondant aux trois premières étapes :


On pourra utiliser une programmation par récursivité.

On donne ci-dessous quelques autres idées de projets.

• Contrôle d'un numéro de sécurité sociale

• Jeu du Mastermind

• Détermination du signe du zodiaque en fonction de la date de naissance

• Simulation du lancer de deux dés

Analyse et corrigé des projets

Corrigé du projet n°1

Considérons le pentagone régulier ABCDE.Il est aisé de constater que ABC = 108 ° . Comme le triangle ABC est isocèle en B, on en déduit que BAC = BCA = 36 ° . D'où EBD = 36 ° . Ainsi, partant d'une branche : [EC] par exemple, on devra tourner à droite de 180-36 =144° pour passer à la branche [CA].

D'où le programme suivant :

def etoile(taille): i=0 while i<5: forward(taille) right(144) # D'après ce qui précède i=i+1


from turtle import *up()goto(-50,0)down()j,taille,espacement=0,50,10while j<5: # première série d'étoiles de tailles croissantes etoile(taille) up() forward(taille+espacement) down() taille=taille+10 j=j+1

taille=taille-2*espacement # Attention à la transition ! k=0while k<4: # seconde série d'étoiles de tailles décroissantes etoile(taille) up() forward(taille+espacement) down() taille=taille-10 k=k+1


Algorithme En Python

nb ← entier aléatoire entre 1 et 100i ← 1écrire « saisissez un entier entre 1 et 100 »lire aTant que (a différent de nb) et (i<5) faire Si a<nb faire écrire « plus petit » lire a Sinon faire écrire « plus grand » lire a i ← i+1Fin Tant que

Si a = nb faire écrire « gagné en »,i, « essais »Sinon faire écrire « perdu ! Il fallait trouver »,nbFin Si

from random import *nb=randint(1,100)i=1a=int(input("saisissez un entier entre 1 et 100 "))

while a!=nb and i<5: if a>nb: print ("plus petit") a=int(input()) elif a<nb: print ("plus grand") a=int(input()) i=i+1

if a==nb: print ("gagné en ",i," essais")else: print ("perdu ! Il fallait trouver ",nb)

Commentaire pédagogique : Ce projet mêle boucle et instructions conditionnelles. Il est réalisable lorsque ces notions ont été travaillées un certain nombre de fois en classe. Il a été bien réussi par le groupe d'élèves l'ayant cherché ; il a fallu quelques tâtonnements, et après une aide (légère) de ma part, ils ont débloqué d'eux mêmes ce qui leur manquait pour l'achever.


# Construction de la fonction triangle

def triangle(taille): i=0 while i<3: forward(taille) left(120) i=i+1


from turtle import *i,taille,espacement=1,15,20abscisse,ordonnee=80,-60while i<=4: # construction de la spirale de triangles if i%2= =1: up() goto(abscisse,ordonnee) down() triangle(taille) abscisse,taille,espacement=abscisse+taille+espacement,taille+10,espacement+50 up() goto(abscisse,ordonnee) down() triangle(taille) else: up() ordonnee=ordonnee+espacement goto(abscisse,ordonnee) down() taille=taille+10 triangle(taille) espacement,taille=espacement+50,taille+10 abscisse=abscisse-espacement-taille up() goto(abscisse,ordonnee) down() triangle(taille) ordonnee=ordonnee-espacement taille=taille+10 i=i+1

Commentaire pédagogique : C'est un projet difficile. Le groupe qui en a hérité a néanmoins fait preuve d'acharnement en testant et re-testant ces scripts pour aboutir au résultat escompté. Il est utile de remplir à la main un tableau avec les coordonnées du « point de départ » de chaque triangle pour bien visualiser leur évolution.


ANALYSE : Avant de se lancer tête baissée dans l'écriture d'un script, les élèves ont commencé par manipuler quelques nombres en les convertissant en nombres romains. Ce faisant, en leur donnant en pâture quelques valeurs bien choisies, ils ont pu se rendre compte que certaines valeurs jouaient le rôle de « pivot ». De plus, l es lettres d'unités ont un rôle capital .

Rappelons le principe d'écriture en nombres romains (ce qu'ils ont cherché sur internet) La numérotation a été normalisée dans l’usage actuel et repose sur quatre principes :

• Toute lettre placée à la droite d’une autre figurant une valeur supérieure ou égale à la sienne s’ajoute à celle-ci.

• Toute lettre d’unité placée immédiatement à la gauche d’une lettre plus forte qu’elle, indique que le nombre qui lui correspond doit être retranché au nombre qui suit.

• Les valeurs sont groupées en ordre décroissant, sauf pour les valeurs à retrancher selon la règle précédente.

• La même lettre ne peut pas être employée quatre fois consécutivement sauf M.

Lettres d’unité : I est une unité pour V et X

X est une unité pour L et C

C est une unité pour D et M.

Traitons les exemples proposés.

Exemple 1 : écrire en nombres romains 2397. 2397 = 2000300907 = 2×10003×100907 .

Le chiffre des milliers et celui des centaines ne posent pas de problèmes : 2000 s'écrit MM et 300 s'écrit CCC ; par contre 97 est entre 50 et 100, mais plus précisément entre 90 et 100. Comme X est une lettre d'unité pour C, on interprète 97 comme 90 + 7, ce qui s'écrit XC suivi de VII

Finalement 2397 s'écrit MMCCCXCVIIExemple 2 : écrire en nombres romains 3912. Même question avec 3812.

3912 = 3×1000900102 . Le seul problème résulte en l'écriture de 900. C (cent) étant une unité pour M (mille), 900 s'écrit CM. Ainsi 3912 s'écrit MMMCMXIIPar contre 800 s'écrit 500 + 300. Ainsi 3812 s'écrit MMMDCCCXII.

Il apparaît au vu des règles d'écritures que pour écrire un nombre romain entre 1 et 3999 (ainsi M n'apparait pas plus de 4 fois), on aura à considérer la liste des lettres suivantes : [M,CM,D,CD,C,XC,L,XL,X,IX,V,IV,I], celles en rouge pouvant être répétées consécutivement.

en prenant bien en compte les considérations suivantes :

C étant une unité pour M, il faudra utiliser CM pour 900, donc après avoir « épuisé » tous les milliers distinguer les cas 500<reste<900 et 900<reste<1000 ;de même C étant une unité pour D (500), il faudra distinguer les cas 400<reste<500 et 100<reste<400 ;Ainsi de suite...On arrive alors au script suivant :

N=int(input("saisissez un entier entre 1 et 4999 "))R=""while N>=1000: # Car M peut être écrit plusieurs fois consécutivement R=R+"M" N=N-1000

# Une fois tous les milliers épuisés, on regarde les centainesif N>=900: R=R+"CM" N=N-900

if N>=500: R=R+"D" N=N-500

if N>=400: R=R+"XC" N=N-400

while N>=100: # Car C peut être écrit plusieurs fois consécutivement R=R+"C" N=N-100

# Une fois les centaines épuisées, on regarde les dizainesif N>=50: R=R+"L" N=N-50

if N>=40: R=R+"XL" N=N-40

while N>=10: # Car X peut être écrit plusieurs fois consécutivement R=R+"X" N=N-10

# Une fois les dizaines épuisées, on regarde les unitésif N>=9: R=R+"IX" N=N-9

if N>=5: R=R+"V" N=N-5

if N>=4: R=R+"IV" N=N-4

while N>=1: # Car I peut être écrit plusieurs fois consécutivement R=R+"I" N=N-1

print (N," s\ecrit ",R, "en chiffres romains")


# définition de la fonction estvalide

def estvalide(sequence): global reponse i=0 reponse=True while i<len(sequence) and reponse==True: if sequence[i]=='a' or sequence[i]=='t' or sequence[i]=='g' or sequence[i]=='c': reponse=True else: reponse=False break

i=i+1 return reponse

# définition de la fonction saisie

def saisie(sequence): global seq estvalide(sequence) while reponse==False: print("Saisie incorrecte ") sequence=input("Saisir votre chaine ") estvalide(sequence)

seq=sequence return seq

# définition de la fonction proportion

def proportion(sequence,chaine): n=len(chaine) k=chaine.count(sequence) # rechercher dans l'aide la commande count return 100*k/n # pour les chaines de caractères

# Programme principal

print("Saisie de la chaine d\'ADN ")adn=input("Saisir votre chaine ")saisie(adn)print("Saisie de la séquence de chainons ")s=input("Saisir votre liste de chainons ")saisie(s)print("Il y a ",proportion(s,adn),"% de ",s," dans votre chaine")


É tape 1 :ANALYSE : on sera amené à distinguer les cas où après chaque tour du joueur humain, il reste soit moins de 3 allumettes (0, 1, 2 ou 3), soit strictement plus de 3 allumettes. Dans le premier cas, l'ordinateur adopte une stratégie gagnante dès que la situation lui est favorable. Le jeu s'arrête grâce à la commande break. L'ordinateur décèle également les situations où il est perdant. Dans le second cas, il prend un nombre aléatoire d'allumettes entre 1 et 3.

from random import * # de manière à utiliser randint(a,b)

N=15 # on initialise N à 15while N>0: print("il y a ",N,"allumettes") N1=int(input("prenez entre 1 et 3 allumettes ")) # N1 est le nombre d'allumettes prises N=N-N1 # par le joueur humain if N==0: # N2 est le nombre d'allumettes prises print("Vous avez perdu !") # par l'ordinateur break elif N==1: N2,N=1,0 print("J\'ai pris la dernière allumette. Vous avez gagné") elif N==2: N2=N-1 print("Je prends une allumette") print("Il ne reste plus donc qu\'une allumette. Vous perdez au tour suivant") break elif N==3: N2=N-2 print("Je prends deux allumettes") print("Il ne reste donc plus qu\'une allumette. Vous perdez au tour suivant") break else: N2=randint(1,3) print("Je prends ",N2,"allumettes") N=N-N2

Etape 2ANALYSE : Le fait que l'ordinateur commence change la donne. On peut cependant partir du script précédent et le modifier en conséquence. Une instruction conditionnelle du type Si... Sinon est nécessaire de prime abord pour donner le choix du joueur qui commence : humain ou ordinateur.On aura donc un script construit de la sorte :

écrire "Voulez-vous commencer ? O ou N ?"lire réponseSi réponse="O" faire Bloc d'instructions établi à l'étape 1Sinon faire Blocs d'instructions où l'ordinateur débute.

C'est ce dernier bloc qu'il convient d'écrire en modifiant celui de l'étape 1. Là est la difficulté.

from random import *

N=int(input("Choisissez le nombre d'allumettes du jeu. N>3 "))print("Voulez-vous commencer à jouer ? O ou N")reponse=input()if reponse=="O": while N>0: print("il y a ",N,"allumettes") N1=int(input("prenez entre 1 et 3 allumettes ")) N=N-N1 if N==0: print("Vous avez perdu !") break elif N==1: N2,N=1,0 print("J\'ai pris la dernière allumette. Vous avez gagné") elif N==2: N2=N-1 print("Je prends une allumette") print("Il ne reste donc plus qu\'une allumette. Vous perdez au tour suivant") break elif N==3: N2=N-2 print("Je prends deux allumettes") print("Il ne reste plus qu\'une allumette. Vous perdez au tour suivant") break else: N2=randint(1,3) print("Je prends ",N2,"allumettes") N=N-N2

else: # partie du script où l'ordinateur commence while N>0: print("il y a ",N,"allumettes") if N>=1: if N>=3: # s'il reste un nombre supérieur ou égal à 3 N1=randint(1,3) # d'allumettes, l'ordinateur en choisit un print("Je prends ",N1,"allumettes") # nombre aléatoire au hasard entre 1 et 3. N=N-N1 print("il reste ",N,"allumettes") if N>=3: # on demande au joueur humain d'en faire de print("Choisissez entre 1 et 3 allumettes ") # même dans le même cas. N2=int(input()) N=N-N2 elif N==2: print("Choisissez entre 1 et 2 allumettes ") N2=int(input()) N=N-N2 elif N==1: print("Il ne reste plus qu\'une allumette que vous devez prendre. Vous avez perdu !") break else:

print("Arg ! J\'ai pris la dernière allumette. Vous avez gagné !") break elif N==2: N1,N=1,0 print("Je prends une allumette") print("Il ne reste plus qu\'une allumette que vous devez prendre. Vous avez perdu !") break elif N==1: print("Il ne reste qu\'une allumette que je dois prendre. Vous avez gagné !") break else: print("J\'ai pris la dernière allumette. Vous avez gagné !") break

Remarquez bien l'indentation des blocs d'instructions. Analysons plus en détail la construction de celui où l'ordinateur commence :• Dès lors qu'il reste un nombre d'allumettes inférieur ou égal à 3, l'ordinateur adopte une

stratégie gagnante (on aurait pu la programmer dès le départ !). En conséquence :* si après le tour du joueur humain il reste 3 allumettes, l'ordinateur en prendra deux.* si après le tour du joueur humain, il reste deux allumettes, l'ordinateur n'en prendra qu'une.* s'il n'en reste qu'une après le tour du joueur humain, il est obligé de la prendre et perd !

• Après le premier tour de l'ordinateur, on regarde si le joueur humain peut prendre entre 1 et 3 allumettes (si le nombre restant d'allumettes est supérieur ou égal à 3) ou pas. Cette action se répétera tant que le nombre d'allumettes dépassera 3. S'il n'en reste qu'une l'ordinateur annonce au joueur humain qu'il va perdre au tour suivant.

Étape 3Le test ne pose pas de problèmes. Tant que l'utilisateur ne choisit pas un nombre d'allumettes correct (entre 1 et 3 si le nombre d'allumettes restant est supérieur ou égal à 3, entre 1 et 2 s'il reste 2 allumettes et 1 s'il ne reste qu'une allumette), l'ordinateur lui intime de recommencer sa saisie. Pour ce faire, on peut définir une fonction test(N) par :

# cas où l'utilisateur doit choisir entre 1 et 3 allumettes.

def test(nombre): while nombre<1 or nombre>4: print("Entrer un entier de 1 à 3 svp") nombre=int(input())

Je laisse au soin du lecteur de la placer où il se doit.

Commentaire pédagogique : il est intéressant de traiter ce sujet à l'aide de fonctions : une dévolue au cas où le joueur humain débute la partie, une où c'est l'ordinateur et une de test du nombre d'allumettes prises par le joueur humain (s'adaptant au nombre d'allumettes restant). On peut par ailleurs raccourcir le script notamment en offrant à l'ordinateur une stratégie gagnante dès lors qu'il débute la partie. A vous de trouver comment faire !


def carre(taille,couleur): i=0 while i<4: color(couleur) forward(taille) left(90) i=i+1

def triangle(taille,couleur): i=0 while i<6: color(couleur) forward(taille) left(120) i=i+1

# programme principalfrom turtle import *i,taille1,taille2=1,50,35abscisse,ordonnee=-100,-100c=['blue','red']while i<=3: up() goto(abscisse,ordonnee) down() if i%2= =1: # motif des 1ère et 3ème ligne carre(taille1,c[0]) up() forward(taille1+20) down() triangle(taille2,c[1]) up() forward(taille2+35) down() carre(taille1,c[0]) else: # motif de la 2ème ligne up() ordonnee=ordonnee+taille1+20 goto(abscisse,ordonnee) down() triangle(taille2,c[1]) up() forward(taille2+110) down() triangle(taille2,c[1]) up() ordonnee=ordonnee+40 goto(abscisse,ordonnee) down() i=i+1


def koch(l,n): # on donne le procédé général pour un segment quelconque if n==0: forward(l) # l est la taille du segment du triangle initial else: koch(l/3,n-1) left(60) koch(l/3,n-1) right(120) koch(l/3,n-1) left(60) koch(l/3,n-1)

def flocon(l,n): # on applique la fonction précédente à chaque segment koch(l,n) right(120) koch(l,n) right(120) koch(l,n)


from turtle import * etape=int(input("Entrez l\'ordre de l\'étape du flocon de Von Koch ")) taille1=float(input("Entrez la taille du côté du triangle initial ")) flocon(taille1,etape)

Commentaire pédagogique : la notion de récursivité avait été abordée en cours sur quelques exemples calculatoires. Assez délicate à faire passer d'ailleurs. On peut également programmer le flocon sans récursivité, à l'aide des coordonnées, mais cela est délicat au niveau seconde.

CHAPITRE 5 : CORRIGE DES EXERCICES

Corrigé des séances 2 à 6 du chapitre 3

Séance n°2

Exercice 2


i ← 0Tant que i<7 faire avancer de 150 tourner à gauche de 360/7° i ← i+1Fin Tant que

from turtle import *i=0while i<7: forward(150) left(360/7) i=i+1

La figure tracée est un heptagone régulier.

Commentaire pédagogique : La difficulté est de trouver la mesure de l'angle duquel on va tourner : ici 360/7°. Un « truc » peut être de remarquer que tout polygone régulier est inscrit dans un cercle... Revenir sur le tracé d'un triangle équilatéral, d'un carré, d'un hexagone.

Exercice 3


i ← 0Tant que i<6 faire avancer de 50 tourner à gauche de 60° i ← i+1Fin Tant que

i ← 0Tant que i<3 faire avancer de 50 tourner à gauche de 120° avancer de 100 tourner à gauche de 120° i ← i+1Fin Tant que

from turtle import *i=0while i<6: forward(50) left(60) i=i+1

i=0while i<3: forward(50) left(120) forward(100) left(120) i=i+1

Commentaire pédagogique : la construction de l'hexagone ne pose pas de problème. Celle des diagonales est plus délicate. Certains élèves pensent qu'on ne peut pas repasser par des traits déjà tracés.

Exercice 4Analyse : comme dans l'exemple phare du cours, on aura besoin de deux variables : S la somme à calculer et un compteur i qui prendra successivement les valeurs : 5 ; 9 ; 13 … 101 ; 105. i varie donc de 4 en 4. Remarque : 105 = 5 +25*4.

Algorithme En PythonS ← 0i ← 5Tant que S<=105 faire S ← S+i i ← i+4Fin Tant que

Afficher S

S=0i=5while S<=105: S=S+i i=i+4 print(S)

Séance n°3

Exercice 1

Question 1 : Script pour dessiner un carré de côté 10L'algorithme a déjà été étudié lors de la première séance. On donne ici sa transcription en langage Python.

from turtle import *i=0while i<4: forward(10) left(90) i=i+1

Question 2 : On dessine ici une série de 10 carrés de côté 10 espacés entre eux de 10.Même remarque que précédemment. On aura besoin de deux boucles while imbriquées, la première servant pour le nombre de carrés à dessiner, la seconde pour dessiner un de ces carrés.

from turtle import *j=0while j<10: # Ce while sert à dessiner les 10 carrés i=0 while i<4: # Ce while sert à dessiner un carré forward(10) left(90) i=i+1 up() # pour ne pas dessiner entre les carrés forward(20) # car les carrés sont espacés de 10 entre eux down() # pour redessiner à nouveau j=j+1

Commentaire pédagogique : Cet exercice n'est pas évident de prime abord ; il convient de bien expliquer la construction de l'algorithme. On pourra également insister sur la manière dont les blocs

d'instructions sont indentés.

Remarque : En utilisant des boucles for on obtient la même structure.

Question 3 : Cette fois-ci, la taille des carrés consécutifs varie ; on aura donc besoin d'une variable supplémentaire. Appelons-là taille tout simplement !

from turtle import *j,taille=0,10 # le côté du premier carré est de 10while j<4: # Ce while sert à dessiner les 4 carrés i=0 while i<4: # Ce while sert à dessiner un carré forward(10) left(90) i=i+1 up() # pour ne pas dessiner entre les carrés forward(taille+10) # car les carrés sont espacés de 10 entre eux down() # pour redessiner à nouveau taille=taille+15 # la taille des carrés s'accroit de 15 à chaque itération j=j+1

Exercice 2Analyse : on doit dessiner une série de 6 hexagones alternés avec 6 carrés, tous de côté 20. L'espacement est de 30 entre chaque figure. On doit donc répéter 3 fois le même motif : un hexagone de côté 20 suivi d'un carré du même côté. D'où la nécessité de 3 boucles : une pour la répétition du motif, une pour le dessin d'un hexagone et une pour le dessin d'un carré.

from turtle import *j=0while j<3: # Ce while sert à dessiner les 3 motifs i=0 while i<6: # Ce while sert à dessiner un hexagone forward(20) left(60) i=i+1 up() # pour ne pas dessiner entre les figures forward(50) # car les figures sont espacés de 30 entre elles down() # pour redessiner à nouveau i=0 while i<4: # Ce while sert à dessiner un carré forward(20) left(90) i=i+1 up() forward(50) down() j=j+1

Commentaire pédagogique : il est essentiel de bien décortiquer le problème : de quoi a-t-on besoin ? Nombre de variables ? Quand doit-on lever le crayon, le rabaisser ? On voit par ailleurs apparaître

une difficulté : Et si le motif était plus compliqué, comment faire pour « réduire » la taille du script ? Dans l'exercice 1 comme dans celui-ci, il a fallu à chaque fois réécrire un bout de programme dessinant un carré. Ne pourrait-on pas conserver ce morceau de script pour l'utiliser à loisir ? La notion de fonction pointe le bout de son nez...

Exercice 3a=[20,3.5,44,37,151,28,15.5]i,S=0,0while i<len(a): # on parcourt la liste en entier S=S+a[i] i=i+1

print("la somme des éléments de la liste vaut ",S)

Séance n°4

Exercice 1i=0while i<20: if i%3==0: print(7*i,"*") else: print(7*i) i=i+1

Exercice 2 Analyse : on va avoir besoin de trois variables : la chaine de caractères elle-même, un compteur i parcourant les éléments de la chaine et une autre variable nb comptant le nombre d'apparitions de la lettre « g ».

a=input("Saisissez une chaîne de caractères ")i,nb=0,0while i<len(a): if a[i]=="g": nb=nb+1 # on incrément nb de 1 dès que g est décelé dans la chaine

# pas besoin de else, l'alternative étant de ne rien faire i=i+1

print("Dans votre chaîne la lettre g apparaît ",nb,"fois")

Exercice 3N=int(input("Saisissez un entier naturel "))if N%5==0: print("C\'est un multiple de 5")else: print("Ce n\'est pas un multiple de 5")

Exercice 4Analyse : on aura besoin d'une instruction conditionnelle if...else ainsi que de deux boucles pour

dessiner soit un carré, soit un triangle équilatéral. D'où le programme :

from turtle import *N=int(input("Saisissez un entier naturel "))if N%2==0: i=0 while i<4: forward(50) left(90) i=i+1else: i=0 while i<3: forward(70) left(120) i=i+1

Exercice 5A=input("Donnez votre avis : satisfait ? moyennement satisfait ? pas satisfait ? ")if A=="satisfait": print("Merci ! Very good")elif A=="moyennement satisfait": print("Ok ok")else: print("Snif !")

Séance n°5

Exercice 1ch=input("Saisissez une chaîne de caractères ")i,nb=0,0while i<len(ch): if ch[i]=="a": nb=nb+1 # on incrément nb de 1 dès que a est décelé dans la chaine

# pas besoin de else, l'alternative étant de ne rien faire i=i+1

if nb==0: # si « a » n'apparait pas on le rajoute à la fin de la chaine ch=ch+"a"

print(ch)

Exercice 2phrase=input("Saisissez une chaîne de caractères ")i,phrase_inv=len(phrase)-1,""while i>=0: phrase_inv=phrase_inv+phrase[i] i=i-1

Commentaire pédagogique : on n'incrémente pas toujours i d'une valeur positive !

Exercice 3a=[20,35,11,56,41,10]i,max=1,a[0]while i<len(a): if a[i]>max: max=a[i]

i=i+1

print("le max de la liste ",a,"est égal à ",max)

Exercice 4liste1=['coucou','bonjour','ça va ?']liste2=['Charles','Edouard','Au poil !']liste3=[] # on initialise la liste à construire par la liste videi=0while i<len(liste1): # les listes 1 et 2 sont de même longueur liste3.append(liste1[i]) # on ajoute d'abord un élément de liste1 liste3.append(liste2[i]) # puis ensuite un élément de liste2 i=i+1

print(liste3)

Commentaire pédagogique : ceci demande aux élèves de bien avoir compris le principe de la commande liste.append(objet), en lien étroit avec la notion de boucle dès lors qu'il s'agit de rajouter plusieurs éléments.

Séance n°6

Exercice 4# définition de la fonction carré

def carre(taille): i=0 while i<4: forward(taille) left(90) i=i+1


from turtle import *j=0 # on aurait aussi pu reprendre i comme variable (globale)while j<10: # pourquoi ? carre(10) # utilisation de la fonction carre up() forward(20) down() j=j+1

Exercice 5# définition de la fonction carrédef carre(taille): i=0 while i<4: forward(taille) left(90) i=i+1

# programme principalfrom turtle import *taille=10j=0while j<4: carre(taille) # utilisation de la fonction carre up() forward(taille+10) down() taille=taille+15 j=j+1

Exercice 6# définition des fonctions carre et hexagonedef carre(taille): i=0 while i<4: forward(taille) left(90) i=i+1

def hexagone(taille): i=0 while i<6: forward(taille) left(60) i=i+1

# programme principali=0while i<3: hexagone(20) up() forward(50) down() carre(20) up() forward(50) down() i=i+1

Exercice 7#création d'une fonction pentagone à deux arguments

def pentagone(taille,couleur): i=0 color(couleur) while i<5: forward(taille) left(72) i=i+1

#création d'une fonction triangle à deux arguments

def triangle(taille,couleur): i=0 color(couleur) while i<3: forward(taille) right(120) i=i+1

#programme principal

from turtle import *taille1,couleur1=15,'blue'taille2,couleur2=25,'red'up()goto(-100,0)down()i=0while i<5: pentagone(taille1,couleur1) up() forward(taille1+20) down() triangle(taille2,couleur2) up() forward(taille2+20) down() i=i+1

Commentaire pédagogique : on voit l'intérêt de la notion de fonction. On peut demander aux élèves de créer un motif plus compliqué pour les en convaincre.

TP Géométrie n°1 : distance et coordonnées

Question 1 : Écrire un programme qui étant donné les coordonnées x A et y A d'un point A, puis x B et yB d'un point B, renvoie les coordonnées du point I, milieu du segment [AB].

Sous Python vous créerez une fonction milieu(x_A,x_B,y_A,y_B)

réponse : def milieu(x_A,x_B,y_A,y_B): # création de la fonction milieu global I # I est déclarée comme variable globale pour utilisation dans le PP I=[(x_A+x_B)/2,(y_A+y_B)/2] # I est stocké sous la forme d'une liste return I


x_A=float(input("saisir x_A "))y_A=float(input("saisir y_A "))x_B=float(input("saisir x_B "))y_B=float(input("saisir y_B "))milieu(x_A,x_B,y_A,y_B)print("Le milieu de [AB] a pour coordonnées ",I)

Question 2 : Écrire un programme qui étant donné les coordonnées x A et y A d'un point A, puis x B et yB d'un point B, renvoie la distance AB.

Sous Python la fonction racine carrée se note sqrt() : sqrt(x) est la racine carrée d'un réel positif x. Vous créerez une fonction distance(x_A,x_B,y_A,y_B).

réponse : def distance(x_A,x_B,y_A,y_B): # création de la fonction distance global dist # de manière à se servir de dist dans le PP dist=sqrt((x_B-x_A)**2+(y_B-y_A)**2)


from math import *x_A=float(input("saisir x_A "))y_A=float(input("saisir y_A "))x_B=float(input("saisir x_B "))y_B=float(input("saisir y_B "))distance(x_A,x_B,y_A,y_B)print("La distance AB est égale à ",dist)

Commentaire pédagogique : c'est l'occasion d'insister à nouveau sur la structure d'un programme. D'abord la définition des fonctions, les « sous-programmes » et ensuite le programme principal.

Question 3 : Soit C le cercle de diamètre [AB]. Dans un repère orthonormé on se donne A(-2 ;2) et B(3 ; -5). On cherche à savoir si un point M(x ; y) appartient ou non au cercle C.

1. Écrire un programme utilisant les deux fonctions précédentes qui réponde à la question.

2. Le tester avec M( 1; 14) puis M 2 ; −3652

réponse : def milieu(x_A,x_B,y_A,y_B): global I I=[(x_A+x_B)/2,(y_A+y_B)/2] return I

def distance(x_A,x_B,y_A,y_B): global dist dist=sqrt((x_B-x_A)**2+(y_B-y_A)**2)


from math import * x_A=float(input("saisir x_A "))y_A=float(input("saisir y_A "))x_B=float(input("saisir x_B "))y_B=float(input("saisir y_B "))milieu(x_A,x_B,y_A,y_B) # calcul des coordonnées du centre I du cercledistance(x_A,x_B,y_A,y_B) # calcul du diamètre du cercled=dist/2 # calcul du rayon du cerclex_M=float(input("saisir x_M "))y_M=float(input("saisir y_M "))distance(I[0],x_M,I[1],y_M) # dist a été réaffecté par la distance IMif d==dist: print("M appartient au cercle de diamètre [AB]")else: print("M n\'appartient pas à au cercle de diamètre [AB]")

# On compile avec Ctrl+F5

>>> saisir x_A -2saisir y_A 3saisir x_B 2saisir y_B -5Le milieu de [AB] a pour coordonnées [0.0, -1.0]Le vecteur AB a pour coordonnées [4.0, -8.0]La distance AB est égale à 8.94427191saisir x_M 1saisir y_M 14M n'appartient pas à C

Commentaire pédagogique : La grande difficulté est de savoir à quel moment on déclare une variable comme globale. Ceci donne l'occasion de revenir sur les priorités entre variables. Ne pas hésiter à y passer du temps. La question 3 est délicate.

TP Géométrie n°2 : vecteurs et parallélogrammes

Question 1 : On considère un repère O ;i ;j . On se donne deux points A, B repérés par leurs coordonnées. Écrire un programme qui étant donné les coordonnées x A et y A d'un point A, puis x B et

yB d'un point B, renvoie celles du vecteur AB sous la forme d'une liste.

Sous Python vous créerez une fonction vecteur(x_A,x_B,y_A,y_B)

Réponse : def vecteur(x_A,x_B,y_A,y_B): global vec vec=[x_B-x_A,y_B-y_A] return vec


from math import * x_A=float(input("saisir x_A "))y_A=float(input("saisir y_A "))x_B=float(input("saisir x_B "))y_B=float(input("saisir y_B "))vecteur(x_A,x_B,y_A,y_B)print("Le vecteur AB a pour coordonnées ",vec)

Question 2 : On se donne quatre points distincts du plan A, B, C et D repérés par leurs coordonnées. 1. Écrire un programme qui étant donné les coordonnées des points A,B,C et D affiche si le

quadrilatère ABCD est un parallélogramme.2. Écrire un programme qui étant donné les coordonnées des points A,B,C et D affiche si le

quadrilatère ABCD est un trapèze.

Vous pourrez vous servir de la fonction créée à la question 1.Les tester avec A(-1 ; 2), B (3 ; 4), C(1 ; 5) et D(9 ; 7)

2) 1)# définition des fonctions

def vecteur(x_A,x_B,y_A,y_B): global vec vec=[x_B-x_A,y_B-y_A] # on définit les coordonnées de AB return vec


from math import * x_A=float(input("saisir x_A "))y_A=float(input("saisir y_A "))

x_B=float(input("saisir x_B "))y_B=float(input("saisir y_B "))x_C=float(input("Saisir x_C "))y_C=float(input("Saisir y_C "))x_D=float(input("Saisir x_D "))y_D=float(input("Saisir y_D "))vecteur(x_A,x_B,y_A,y_B) # vec1 reçoit la première valeur de vec utilisant A et Bvec1=vecvecteur(x_D,x_C,y_D,y_C) # on affecte à vec une nouvelle valeur utilisant D et Cvec2=vec # vec2 reçoit la seconde valeur affectée à vecif vec1==vec2: # on teste si AB = DC . print("ABCD est un parallélogramme")else: print("ABCD n\'est pas un parallélogramme")

2) 2)

from math import * x_A=float(input("saisir x_A "))y_A=float(input("saisir y_A "))x_B=float(input("saisir x_B "))y_B=float(input("saisir y_B "))x_C=float(input("Saisir x_C "))y_C=float(input("Saisir y_C "))x_D=float(input("Saisir x_D "))y_D=float(input("Saisir y_D "))

# on écrit directement le script principal

if (x_B-x_A)*(y_D-y_C)-(x_D-x_C)*(y_B-y_A)==0: print("ABCD est un trapèze")else: print("ABCD n\'est pas un trapèze")

Question 3 :On se sert de la propriété fondamentale qui assure que ABCD est un parallélogramme si et seulement si AB = DC . On a AB xB−x A ; yB− yA et DC xC−x D ; yC− y D .

On cherche donc x_D et y_D tels que {xC−x D= xB−x A

yC− y D= y B− y A} soit {xD=xC− xBx A

yD= yC− y B yA}Ceci permet de programmer facilement ce qui est demandé.

x_A=float(input("Saisir x_A "))y_A=float(input("Saisir y_A "))x_B=float(input("Saisir x_B "))y_B=float(input("Saisir y_B "))x_C=float(input("Saisir x_C "))y_C=float(input("Saisir y_C "))x_D=x_C-x_B+x_Ay_D=y_C-y_B+y_Aprint("x_D= ",x_D)print("y_D= ",y_D)

TP Fonction : tracé d'une courbe

Les versions de matplotlib et de numpy utilisées ici sont celles associées à Python 2.6

>>> import matplotlib.pyplot as plt>>> import numpy as np>>> x=np.linspace(-4,8,100) # on prendra 100 points entre - 4 et 8.>>> plt.plot(x,x**2-3*x-10) # tracé de C[<matplotlib.lines.Line2D object at 0x03B4C910>]>>> plt.plot(x,12*x**0) # tracé de la droite d'équation y = 12[<matplotlib.lines.Line2D object at 0x03D8BAB0>]>>> plt.plot(x,-10*x**0) # tracé de la droite d'équation y = -10[<matplotlib.lines.Line2D object at 0x03D8B9F0>]>>> plt.grid(True) # tracé de la grille>>> plt.show() # Affichage des graphiques

Réponse aux questions :

• Les solutions de l'équation f x = 0 sont les abscisses des points de la courbe C dont l'ordonnée est nulle. On place le curseur de la souris sur les deux points de C vérifiant la condition sus-indiquée. On trouve x1 = −2 et x2 = 5 .

• De même les antécédents de 12 par f sont -3,4 et 6,4 à 0,1 près. • On en déduit les solutions de l'inéquation f x 12 sur [−4 ;8] .

S = [−4 ;−3,4]∪[6,4 ;8]

Pour déterminer les coordonnées du sommet S de C, on procède en deux étapes :• on détermine les antécédents de – 10 par f : x1 = 0 et x2 = 3 .

• L'abscisse x0 du sommet S de C est égale à x1x2

2 , soit x0 = 1,5 .

• On lit alors l'image de 1,5 par f grâce au curseur de la souris : f 1,5 = −12,3 . Conclusion : S a pour coordonnées S 1,5 ;−12,3 .


Question 1 : Écrire un programme qui demande à un utilisateur de saisir N notes entre 0 et 20 (N choisi par l'utilisateur) sous la forme d'une liste et N nombres entre 1 et 3 (les coefficients de ces notes), puis qui renvoie la moyenne pondérée de ces N notes.

Réponse : liste_notes,liste_coeff=[],[]N=int(input("Entrez le nombre de notes à saisir "))i=1while i<=N: print("Entrez la note n° ",i) a=float(input()) liste_notes.append(a) # on crée la liste des notes b=print("Entrez le coefficient de la note n°",i," (de 1 à 3)") b=float(input()) liste_coeff.append(b) # on crée la liste des coefficients i=i+1

i,c,S=0,0,0while i<N: S=S+liste_notes[i]*liste_coeff[i] c=c+liste_coeff[i] i=i+1

print("la moyenne de vos notes est de ",S/c)

Question 2 : On considère un dé parfait à 6 faces et trois urnes numérotées de 1 à 3. L'urne 1 contient 3 boules blanches, 4 boules noires et 3 boules vertes.L'urne 2 contient 2 boules blanches, 2 boules noires et 6 boules vertes.L'urne 3 contient 4 boules blanches, 4 boules noires et 2 boules vertes. Toutes ces boules sont indiscernables au toucher.On considère l'expérience aléatoire qui consiste à lancer le dé :• Si le numéro est 1 ou 2, on tire une boule dans l'urne n°1• Si le numéro est 3, 4 ou 5 on tire une boule dans l'urne n°2• Sinon, on tire une boule dans l'urne n°3.

Nous allons écrire un algorithme modélisant ceci. La notion d'instruction conditionnelle sera omniprésente, sous forme de « if » imbriqués. Ceci tient à la nature même du problème. Prenons un exemple : pour calculer la probabilité de tomber sur une boule verte, on doit additionner les probabilités de toutes les branches de l'arbre se terminant par V.Les variables nécessaires seront :

n : le nombre d'essais effectuési : un compteur variant de 1 à nnb_blanc, nb_noir, nb_vert comptant le nombre d'apparitions d'une boule blanche, noire, verte.numde : le numéro affiché par le dénumboule : le numéro de la boule tirée dans l'urne n°i (i=1, 2, 3)

Réponse :


n=int(input("Combien d\'expériences souhaitez-vous réaliser ? "))i=1nb_blanc,nb_noir,nb_vert=0,0,0while i<=n: numde=randint(1,6) # on tire un entier aléatoire entre 1 et 6 (le dé) if numde<=2: # condition pour tirer une boule dans l'urne 1 numboule=randint(1,10) # l'urne 1 contient 10 boules if numboule<=3: nb_blanc=nb_blanc+1 elif numboule<=7: nb_noir=nb_noir+1 else: nb_vert=nb_vert+1 elif numde<=5: # condition pour tirer une boule dans l'urne 2 numboule=randint(1,10) # l'urne 2 contient 10 boules if numboule<=2: nb_blanc=nb_blanc+1 elif numboule<=4: nb_noir=nb_noir+1 else: nb_vert=nb_vert+1 else: # sinon on tire une boule dans l'urne 3 numboule=randint(1,10) # l'urne 3 contient 10 boules if numboule<=4: nb_blanc=nb_blanc+1 elif numboule<=8: nb_noir=nb_noir+1 else: nb_vert=nb_vert+1

i=i+1

print("La fréquence d\'apparition d\'une boule blanche est de ",nb_blanc/n)print("La fréquence d\'apparition d\'une boule noire est de ",nb_noir/n)print("La fréquence d\'apparition d\'une boule verte est de ",nb_vert/n)


Les versions de matplotlib et de numpy utilisées ici sont celles associées à Python 2.6

Question 1 :Est détaillée dans la fiche : petit guide Matplotlib

Question 2 : Création d'une boite à moustachesOn prélève 50 échantillons de taille 100 dans la population et on évalue dans chacun de ces échantillons la proportion de '1'.

from random import *import matplotlib.pyplot as plt

#création de la populationliste=[1 for n in range(3000)]+[2 for n in range(1500)]+[0 for n in range(5500)]shuffle(liste)

n=int(input("Combien d\'échantillons à prélever ? "))i=0prop_de_1=[]while i<n: #création de n échantillons « proportion de '1' » echantillon=sample(liste,100) #création d'un échantillon de taille 100 j,s=0,0.0 while j<100: if echantillon[j]==1: s=s+echantillon[j] j=j+1 prop_de_1.append(s/100.0) #création d'un échantillon de proportion de '1' i=i+1 #tracé de la boite à moustachesplt.boxplot(prop_de_1,notch=0,sym='+',vert=1,whis=1.5,positions=None,widths=None,patch_artist=False)plt.show()

Remarque : Encore une fois, on remarque la puissance de la méthode append associée à l'objet liste en parallèle avec l'utilisation d'une boucle. Ici, la démarche a été la suivante :• On a prélevé un échantillon de 100 nombres de la population.• On a calculé dans cet échantillon la proportion de '1'.• On a répété 50 fois cette opération successivement ce qui a permis de créer une matrice

ligne de 50 nombres, représentant la proportion de '1' dans chacun des échantillons. • On peut alors construire une boite à moustaches à partir de ces 50 observations

d'échantillons de taille 100.

Il suffit de rajouter une boucle et deux variables : un compteur et une variable qui sera une liste de listes pour tracer les 20 boites à moustaches demandées.

On obtient alors le script suivant :

from random import *import matplotlib.pyplot as plt

liste=[1 for n in range(3000)]+[2 for n in range(1500)]+[0 for n in range(5500)]shuffle(liste)m=int(input("Combien de boites a moustaches ? "))n=int(input("Combien d\'échantillons à prélever par boite ? "))k,matrix=0,[] #la variable matrix sera une liste de listeswhile k<m: i=0 prop_de_1=[] while i<n: echantillon=sample(liste,100) j,s=0,0.0 while j<100: if echantillon[j]==1: s=s+echantillon[j] j=j+1 prop_de_1.append(s/100.0) i=i+1 matrix.append(prop_de_1) k=k+1 plt.boxplot(matrix,notch=0,sym='+',vert=1,whis=1.5,positions=None,widths=None,patch_artist=False)plt.show()

TP Équations de droites

Question 1 : Écrire une fonction estverticale(x_A,y_A,x_B,y_B) qui étant donné deux points A xA ; y A et B xB ; y B détermine si la droite (AB) est verticale ou pas. La valeur

renvoyée par cette fonction sera un booléen : True pour vertical et False dans le cas contraire.

Réponse : def estverticale(x_A,y_A,x_B,y_B): global reponse # la variable reponse est globale pour la réutiliser à l'intérieur reponse=True # d'autres fonctions if x_A==x_B: reponse=True else: reponse=False

Question 2 : Dans le cas où la droite (AB) ne soit pas verticale, écrire une fonction equation(x_A,y_A,x_B,y_B) qui :• calcule le coefficient directeur m• calcule l'ordonnée à l'origine p• affiche le résultat sous la forme : "La droite (AB) a pour équation y = ",m,"x+",p

On stockera le couple (m,p) dans une liste.

Réponse : def estverticale(x_A,y_A,x_B,y_B): global reponse # la variable reponse est globale reponse=True # de manière à la réutiliser dans d'autres if x_A==x_B: # fonctions reponse=True else: reponse=False

def equation(x_A,y_A,x_B,y_B): global m,p # les variables m et p sont globales couple=[] m=(y_B-y_A)/(x_B-x_A) couple.append(m) p=y_A-m*x_A couple.append(p)

print("le coefficient directeur m est égal à ",m) print("l\'ordonnée à l\'origine est égale à ",p) print("la droite (AB) a pour équation y=",m,"x+",p)

# programme principal pour répondre à la question 2x_A=float(input("Saisir x_A "))y_A=float(input("Saisir y_A "))x_B=float(input("Saisir x_B "))y_B=float(input("Saisir y_B "))estverticale(x_A,y_A,x_B,y_B)

if reponse==True: print("Cette droite est verticale ") print("la droite a pour équation x= ",x_A)else: equation(x_A,y_A,x_B,y_B)

Question 3 : Écrire un programme qui détermine si deux droites (AB) et (CD) sont parallèles ou pas. Le cas où ces deux droites sont verticales sera considéré.

Réponse :

x_A=float(input("Saisir x_A "))y_A=float(input("Saisir y_A "))x_B=float(input("Saisir x_B "))y_B=float(input("Saisir y_B "))x_C=float(input("Saisir x_C "))y_C=float(input("Saisir y_C "))x_D=float(input("Saisir x_D "))y_D=float(input("Saisir y_D "))

if (x_A==x_B) and (x_C==x_D): print(" Ces deux droites sont des droites verticales parallèles")elif ((x_A!=x_B) and (x_C!=x_D)) and (y_B-y_A)/(x_B-x_A)==(y_D-y_C)/(x_D-x_C): print("Ces deux droites sont parallèles")else: print("Ces deux droites ne sont pas parallèles")

Commentaire pédagogique : la condition du elif est assez compliquée à faire comprendre. Ne pas hésiter à faire un dessin pour représenter les différents cas possibles.

CHAPITRE 6 : TP EN FILIERE S


La liste de TP qui suit est encore en construction et sera remaniée puis s'étoffera par la suite. On propose des exercices, voire des problèmes dans certains cas où l'algorithmique intervient là où la seule intuition ne suffit plus. J'aimerais développer certains problèmes dans leur contexte naturel pour aboutir naturellement à l'utilisation d'un logiciel de programmation, mais cela demande du temps et n'est pas encore achevé à l'heure où j'écris ces lignes.

Les thèmes choisis sont conformes aux nouveaux programmes :

• Étude de suites.

• Étude de fonctions et résolution d'équations.

• Probabilités.

A venir :

• Géométrie

• Arithmétique

• Optimisation et théorie des graphes

TP Suites

Exercice 1 (niveau 1ère S)On définit la suite de Collatz de la manière suivante : ● On se donne un entier u0 strictement positif. ● Pour tout entier n1 , on calcule un1 en fonction de un de la manière suivante :

a) Si un est pair, on a un1 =un

2b) Si un est impair, on a un1 = 3un1

On donne ci-dessous un exemple traité avec le tableur. On a choisi comme valeur initiale u0 = 5 et il est affiché les 21 premiers termes de cette suite.

1. Que remarquez-vous ? 2. Écrire à l'aide du logiciel Algobox ou Python un programme demandant à l'utilisateur de :

a) saisir à l'écran un entier u0 strictement positif, b) de saisir un entier n (l'indice maximum de calcul des uk ) c) et qui affiche tous les termes de u0 à un .

3. Tester votre programme avec u0 = 3 puis u0 = 7 . (faire varier n également)4. Que remarquez-vous ?

Remarques : 1) La suite un définie de la manière précédente est dite définie par récurrence. On calcule chacun de ses termes de proche en proche.

2) On ne sait toujours pas prouver ce que vous avez constaté ! C'est un problème ouvert.

0 51 162 83 44 25 16 47 28 19 410 211 112 413 214 115 416 217 118 419 220 1

n un

Exercice 2 (niveau 1ère S)On se donne une suite définie par récurrence par u0=x x0 et pour tout entier naturel n

par un1=un

2

n1.

1. Écrire un programme à l'aide du logiciel Python qui :• demande à l'utilisateur de saisir la valeur x du terme initial• demande de saisir n• renvoie la valeur de un .

2. Tester ce programme avec x= 1,65 puis n=5, 10, 12, 15. Quelle semble être la limite de la suite u ?

3. Tester ce programme avec x = 1,67 puis n=5, 10, 12, 15. Quelle semble être la limite de la suite u ?

Exercice 3 (niveau Terminale S)Le but de cet exercice est de tester pour différentes valeurs de réel le comportement de la suite

définie pour tout entier naturel n1 par un = ∑k=1

n 1k

.

1. Écrire un algorithme demandant à l'utilisateur de saisir un réel et un entier naturel n non nul et affichant la valeur de un .

2. Implémentez cet algorithme à l'aide de Python. Testez le programme pour =2 et n=1000, 10000, 106 .

3. Testez le programme pour =1 puis pour =1,5 avec les mêmes valeurs de n qu'à la question précédente.

5. Que remarquez-vous au niveau du temps de calcul lorsque n augmente ? Pour avoir une idée du temps de calcul, cherchez dans l'aide de Python une fonction appropriée.

6. Modifiez le programme précédent de sorte que :• on demande à l'utilisateur la valeur de à tester.• Le nombre de valeurs de n à tester• on affiche la valeur de S pour chacune des valeurs de n saisies.

7. Complétez ensuite le tableau suivant :

nalpha 100 10000 106 107 108 109 1010

0,91

1,5

PS : le coût en terme de temps de calcul est une composante de ce qu'on appelle la « complexité » de l'algorithme. Il est possible dans certains cas de le réduire en trouvant un algorithme plus efficace aboutissant au même résultat. Mais gare à la place mémoire que cela nécessite en contrepartie !

Problème (niveau terminale S)Soit la fonction f définie sur [0 ; +∞[ par f x = x2 – a où a est un réel strictement positif donné. Le but de cet exercice est de trouver une « bonne approximation » de la solution x* de l'équation f x = 0 .

Partie 1On choisit a = 2. Soit . A le point de C d'abscisse 1.

1. Donner une équation de la tangente T à C au point A. Cette dernière coupe l'axe des abscisses en un point d'abscisse x0 .

2. Après avoir calculé x0 , donner une équation de la tangente T 0 à C au point d'abscisse x0 . Cette dernière coupe l'axe des abscisses en un point d'abscisse x1 . Calculer x1

et comparer x1 à x0 . 3. On définit ainsi une suite xnn0 de réels de proche en proche. (on justifiera proprement

son existence un peu plus loin) Soit n un entier naturel quelconque. Donner l'expression littérale de xn1 en fonction de xn .

4. Écrire un programme à l'aide du logiciel Python qui demande à l'utilisateur :• de saisir la valeur de l'entier n• renvoie la valeur de xn défini précédemment.

5. Le tester avec n=2, n=3, n=10.

Partie 2On souhaite répondre à deux questions :• La suite xnn0 converge-t-elle ? Si oui, est-ce bien vers x* ?• Évaluer la qualité de l'approximation de x* par xn , autrement dit, pour une précision

arbitraire p>0 fixée par l'utilisateur, combien nous faut-il d'itérations pour avoir ∣x*−xn∣p ? On restreint désormais f à l'intervalle I = [1 ; 2].

Sous-partie A)1. Quelle est la valeur exacte de x* ? Justifier que x*∈[1; 2] .2. En se servant du résultat du I)3) démontrer que pour tout entier naturel n

xn1=12 xn

2xn . On posera g x=1

2 x2

x .

3. Démontrer que g x=x si et seulement si f x =0 . (on s'est ramené à un problème de point fixe).

4. On admet le résultat suivant : Soit unn0 une suite d'éléments d'un intervalle fermé I telle que pour tout entier naturel n, un1=g un . On suppose que :• unn0 converge vers un réel l• g est continue sur I• ALORS on a l=g l .

a) Étudier les variations de g sur l'intervalle [1 ; 2].b) Justifier que tous les termes de la suite xnn0 sont bien définis et appartiennent à

I=[1 ;2 ] (le prouver par récurrence).c) Prouver que la suite xnn0 est décroissante. En déduire que xnn0 converge, et ce

vers x* .

Sous-partie B)On pose pour tout entier naturel n, en= xn – x* .

5. Démontrer que en1=1

2 xnen

2 puis que en1

12

en2 .

6. Démontrer par récurrence que pour tout entier naturel n en122n

7. Soit p>0 la précision recherchée.. On supposera p<1. Déterminer un entier naturel N tel que si n>N, alors en p .

8. Écrire un programme à l'aide du logiciel Python qui demande à l'utilisateur :• de saisir la précision recherchée p• renvoie la valeur de x* à p près.

Remarque : Les résultats de la sous-partie B justifient à nouveau la convergence de la suite xnn0 vers x* .

TP Fonctions

Exercice 1 (niveau 1ère S)Le but de cet exercice est de déterminer le nombre et une valeur approchée des solutions de l'équation du second degré a x2b xc=0 . Écrire un programme à l'aide de Python qui :

1. demande à l'utilisateur de saisir les coefficients a,b et c2. détermine le nombre de solutions de a x2b xc=03. dans le cas où elles existent, écrive ces solutions.

Exercice 2 (niveau 1ère S)Soit f une fonction dérivable sur [0 ; 2] vérifiant : pour tout réel x f ' x= f x et f 0=1 . On souhaite tracer la courbe représentative de f à l'aide de la méthode d'Euler.Écrire un programme à l'aide du logiciel Python qui :

1. demande à l'utilisateur de saisir le pas h de la méthode (0<h<1).2. découpe l'intervalle [0 ; 2] en N (à déterminer) intervalles égaux [ xi ; x i1] et évalue

l'image de x i par f par approximation affine. On notera y i cette évaluation. 3. trace la ligne polygonale reliant les points de coordonnées x i ; y i . 4. Tester ce programme avec h=0,2 ; h=0,1 ; h=0,05.

Exercice 3 (niveau Terminale S)Données : nous disposons d'une fonction f définie sur un intervalle [a ; b] à valeurs dans ℝ telle que :• f est strictement monotone sur [a; b]• f est continue sur [a ; b]• f a f b0

Alors (théorème des valeurs intermédiaires) il existe un unique réel c appartenant à ]a; b[ tel que f c = 0 .

Principe de la dichotomie : Supposons que l'on sache qu'il y a une racine x0 dans l'intervalle [a ; b]. Pour préciser sa valeur, nous allons découper [a ; b] de manière plus fine de sorte à encadrer avec la précision voulue le réel x0 .

Posons m = ab2 .

• Si f a f m0 alors x0∈[a ;m ] . On pose alors a1=a et b1=m . • Si f a f m0 alors x0∈[m ;b ] . On pose alors a1=m et b1=b

On recommence en prenant l'intervalle [a1 ;b1] et ainsi de suite. On obtient alors des intervalles

[a2 ;b2] ,..., [an ;bn] . Lorsque ∣bn−an∣

2p , on a

anbn

2= x0 à p près.

1. Écrire un programme en Python qui étant donnés deux réels a et b (a<b) et une fonction f continue et strictement monotone sur [a ; b], donne une approximation de x0 à une précision p près (p choisie par l'utilisateur). Pour simplifier on supposera f strictement croissante sur [a ; b].

2. Testez ce programme pour les fonctions suivantes : a) f est définie sur [-5 ; 10] par f x = x32 x1b) f est définie sur [-0,5 ; 1] par f x = x−cos x

Exercice 4 (niveau Terminale S)Méthode des rectangles Données : nous disposons d'une fonction f définie sur un intervalle [a ; b] à valeurs dans ℝ telle que :• f est strictement monotone sur [a; b]. Pour simplifier, on supposera f strictement croissante.• f est continue et positive sur [a ; b]

1. Écrire une fonction subdivision(a,b,n) qui partage l'intervalle [a ; b] en n intervalles [ak ;a k1] de longueurs égales. (on pourra conserver les ak 0kn dans une

liste). 2. Écrire une fonction aire_moins(f,subdi) qui calcule l'aire des n rectangles de base

[ak ;a k1] 0kn et de hauteur f ak . 3. Écrire une fonction aire_plus(f,subdi) qui calcule l'aire des n rectangles de base [ak ;a k1]

0kn et de hauteur f ak1 .

4. A l'aide des fonctions précédentes en déduire un encadrement de ∫a

b

f x dx selon la

valeur de n choisie par l'utilisateur.

5. Application : évaluer ∫0

5

x32 x1dx avec n=100,400 puis n=1000.

Exercice 5 (Terminale S)Méthode des trapèzesDonnées : nous disposons d'une fonction f définie sur un intervalle [a ; b] à valeurs dans ℝ telle que :• f est strictement monotone sur [a; b]. Pour simplifier, on supposera f strictement croissante.• f est continue et positive sur [a ; b]

1. Écrire une fonction subdivision(a,b,n) qui partage l'intervalle [a ; b] en n intervalles [ak ;a k1] de longueurs égales. (on pourra conserver les ak 0kn dans une

liste). 2. Écrire le script principal qui calcule la somme des aires des trapèzes reliant les points de

coordonnées ak ;0 ; a k ; f ak ; ak1 ;0 ; ak1 ; f ak1 , 0kn−1 . L'utilisateur décidera de la valeur de n.

3. Tester le programme avec n=50, 100, 500 pour évaluer ∫0

5

x32 x1dx .

TP Statistiques-Probabilités

Exercice 1 (niveau 1ère S)On considère le jeu suivant dont la mise est de 2€ : on lance deux dés parfaits à 6 faces et on s'intéresse à la somme obtenue. • Si la somme est entre 6 et 8 (compris) on perd sa mise.• Si la somme est 5 ou 9 on gagne 2€.• Si la somme est 4 ou 10 on gagne 5€.• Si la somme est 3 ou 11 on gagne 10€.• Si la somme est 2 ou 12 on gagne 50€.

1. Intéressons-nous pour le moment de manière théorique à la somme des nombres obtenus sur la face supérieure de chacun des 2 dés.

a. Compléter le tableau suivant par la valeur de la somme des deux dés.

Dé 1Dé 2 1 2 3 4 5 6

123456

b. Quelles sont les différentes valeurs possibles pour cette somme ? Compléter le tableau suivant :

Somme Total

Fréquence théorique d’apparition

2. Soit X la variable aléatoire égale au gain (algébrique) du joueur : on tient donc compte de la mise !! a) Compléter le tableau suivant :

x i -2 0 3 8 48P X=x i

Valeur approchée à

0,01 près

b) Calculer l'espérance de X (valeur exacte puis à 0,01 près). Que représente ce nombrec) Calculer la variance de X puis l'écart-type X . Interpréter ces nombres.

3. Simulation informatique. simulation avec un lancer de n dés

Écrire un programme avec Python qui :• demande à l'utilisateur le nombre n de lancers• calcule sur ces n lancers le gain moyen de l'utilisateur.

4. Comparer avec le résultat de la question b pour n = 50, 200 puis 5000 lancers.

Exercice 2 (niveau Terminale S)On souhaite répondre au problème suivant : Une urne U1 contient 2 boules rouges, 3 boules bleues et 5 boules vertes ; une urne U2 contient 4 boules rouges et 5 boules bleues, tandis qu'une troisième urne U3 contient 3 boules bleues et 6 boules vertes. On procède alors à l'expérience suivante :on tire au hasard une boule de l'urne U1 que l'on place dans l'urne U2, puis on tire au hasard une boule de l'urne U2 que l'on place dans U3. Enfin, on tire au hasard une boule de U3 que l'on place dans U1.Quelle est la probabilité que la composition de l'urne U1 n'ait pas changé à l'issue de ces 3 manipulations ?

1. Nous allons d'abord modéliser le problème par un programme utilisant l'approche fréquentiste des probabilités. Pour cela, on demandera à l'utilisateur de saisir le nombre n d'expériences aléatoires à reproduire, puis on simulera le tirage d'une boule dans l'urne

U 1 , puis ceux dans U 2 et U 3 et enfin la dernière composition acquise par U 1 . On comptera alors les cas où la composition de U 1 n'a pas varié.

Variables à utiliser : nb_rouges1, nb_bleues1, nb_vertes1, nb_rouges2, nb_bleues2, nb_vertes2, nb_rouges3, nb_bleues3, nb_vertes3 à initialiser dans chaque cas ; a qui simulera le numéro de la boule tirée dans les urnes 1, 2 et 3 et enfin i (un compteur), cas_favorables (un autre compteur) et n. Pour simuler le tirage au hasard, on pourra supposer numérotées les boules présentes dans chaque urne (à vous de voir comment procéder) et utiliser la fonction randint.

2. En utilisant la formule des probabilités totales, répondre à la question de manière théorique. On pourra noter Bi , V i , Ri les événements : « Au ième tirage la boule est respectivement bleue, verte, rouge » (i=1, 2, 3).

3. Tester le programme avec n=100, n=1000, n=5000 et comparer avec le résultat précédent.

Analyse et corrigé des TP

TP Suites

Exercice 1 (niveau 1ère S)On définit la suite de Collatz de la manière suivante : ● On se donne un entier u0 strictement positif. ● Pour tout entier n1 , on calcule un1 en fonction de un de la manière suivante :

a) Si un est pair, on a un1 =un

2b) Si un est impair, on a un1 = 3un1

Réponse : N'oublions pas l'opérateur modulo % qui sert à déterminer si un entier est divisible par un autre. Par exemple si a%b = 0 ceci signifie que a est divisible par b. Partant de cette remarque, on peut définir parfaitement la suite de Collatz.

Algorithme Avec Pythonécrire "saisir un entier positif u"saisir uécrire "Combien de termes à calculer ? "lire ni ← 0Tant que i<n faire Si u est divisible par 2 faire u ← u/2 Afficher u Sinon faire u ← 3*u+2 Afficher u Fin Si i ← i+1Fin Tant que

u=int(input("Saisir le premier terme de la suite (entier positif) "))n=int(input("Combien de termes de la suite voulez-vous calculer ?"))i=0while i<n: if u%2==0: u=u/2 print(int(u)) # pourquoi int(u) ? else: u=3*u+1 print(int(u))

i=i+1

Exercice 2 (niveau 1ère S)On se donne une suite définie par récurrence par u0=x , x0 et pour tout entier naturel n

par un1=un

2

n1.

2. Écrire un programme à l'aide de Python qui demande à l'utilisateur :• de saisir la valeur x du terme initial• de saisir n• renvoie la valeur de un .

On aura besoin de trois variables : u, n et i (un compteur car la suite est définie par récurrence donc les termes se calculent de proche en proche).

Algorithme Avec Pythonécrire "saisir un réel positif u (valeur initiale) "lire uécrire "saisir un entier positif n "lire ni ← 0Tant que i<n faire u ← u²/(n+1) i ← i+1Fin Tant que Afficher u

u=float(input("Saisir le premier terme de la suite (réel positif) "))n=int(input("Saisir n "))i=0while i<n: u=u**2/(i+1) i=i+1

print(u)

Remarque : on peut fabriquer un tableau en faisant varier le terme initial u et n. Que remarquez-vous ?

Exercice 3 (niveau Terminale S)Le but de cet exercice est de tester pour différentes valeurs de réel le comportement de la suite

définie pour tout entier naturel n1 par un = ∑k=1

n 1k

.

1. Écrire un algorithme demandant à l'utilisateur de saisir un réel et un entier naturel n non nul et affichant la valeur de un .

2. Implémentez cet algorithme à l'aide de Python. Testez le programme pour =2 et n=1000, 10000, 106 .

3. Testez le programme pour =1 puis pour =1,5 avec les mêmes valeurs de n qu'à la question précédente.

4. Que remarquez-vous au niveau du temps de calcul lorsque n augmente ? Pour avoir une idée du temps de calcul, cherchez dans l'aide de Python une fonction appropriée.

5. Modifiez le programme précédent de sorte que :• on demande à l'utilisateur la valeur de à tester.• Le nombre de valeurs de n à tester• on affiche la valeur de S pour chacune des valeurs de n saisies.

6. Complétez ensuite le tableau suivant :

nalpha 100 10000 106 107 108 109 1010

0,91

1,5

Réponse :

Question 1 et 2 : Nous allons avoir besoin de plusieurs variables : (paramètre), n, k un compteur destiné à varier entre 1 et n, et enfin u. L'algorithme est très proche de l'exemple phare du cours servant à calculer

S=12…99100 .

Algorithme Avec Pythonécrire "saisir un réel positif "lire écrire "saisir un entier positif n "lire nk ← 1u ← 0Tant que k<=n faire u ← u1/ k k ← k+1Fin Tant que Afficher u

alpha=float(input("Saisir un réel positif alpha "))n=int(input("Saisir un entier positif n "))k=1u=0while k<=n: u=u+1/(k**alpha) k=k+1

print(u)

Question 4 : Le temps de calcul augmente énormément lorsque n grandit.

Question 5 : il suffit de rajouter une boucle permettant d'afficher tous les un demandés. Ceci nécessite l'utilisation d'une autre variable que l'on appellera nb_de_n et d'un autre compteur variant de 1 à nb_de_n que l'on appellera i. Notons que ce programme permettra de remplir le tableau de la question 6 assez rapidement.

Algorithme Avec Pythonécrire "saisir un réel positif "lire écrire "combien de valeurs un à calculer ? "lire nb_de_ni ← 1Tant que i<=nb_de_n faire écrire "saisir l\'entier n choisi " lire n k ← 1 u ← 0 Tant que k<=n faire u ← u1/ k k ← k+1 Fin Tant que écrire "u_n est égal à " afficher u i=i+1Fin Tant que

alpha=float(input("Saisir un réel positif alpha "))nb_de_n=int(input("Combien de valeurs de u_n à calculer ? "))i=1while i<=nb_de_n: n=int(input("Saisir l\'entier n choisi ")) k=1 u=0 while k<=n: u=u+1/k**alpha k=k+1

print("u_",n,"est égal à ",u) i=i+1

Problème (niveau Terminale S)Partie 1Question 1 : f est une fonction polynôme donc est dérivable sur ℝ et pour tout réel x,

f ' x = 2 x . T a pour équation y= f ' 1x−1 f 1 , soit après calculs y = 2 x−3 .

Question 2 : T coupe l'axe des abscisses au point d'abscisse 32 . Donc x0=

32 . Pour déterminer

x1 , on cherche l'équation de la tangente à C au point d'abscisse x0 . C a pour équation :

y= f ' 32 x – 3

2 f 32 , soit après calculs : y=3 x – 174 . On en déduit immédiatement

x1=1712 . On a x1x0 .

Question 3 : L'existence de chacun des termes de la suite xnn0 est assurée par la dérivabilité de f sur ℝ et du fait que aucun xn n'est nul (justifié plus loin). T n la tangente à C au point d'abscisse xn a pour équation : y= f ' xnx−xn f xn , soit y=2 xnx−x n xn

2 – 2 . Cette dernière coupe l'axe des abscisses au point d'abscisse xn1 (par définition). D'où

xn1=xn

2 1

xn.

Question 4 : On donne l'algorithme de construction des xn et le programme en Python.

Algorithme Avec Pythonécrire "saisir le terme initial de la suite "lire xécrire "saisir n "lire ni ← 0Tant que i<=n faire

x ← x21

x i ← i+1Fin Tant que Afficher x

x=float(input("saisir le terme initial de la suite "))n=int(input("saisir n "))i=0while i<=n: x=x/2 + 1/x i=i+1

print(x)

Question 5 : do it alone !

Partie 2Sous-partie A

Question 1 : Par définition de x* on a x*2=2 et x*0 donc x*= 2 . f 10 et f 20 donc d'après le théorème des valeurs intermédiaires, x*∈[1; 2]

Question 2 : Soit n∈ℕ . xn1=xn

2 1

xn=1

2 xn2xn , soit xn1=g xn .

Question 3 : Soit x∈[1 ;2] . g x= x⇔ 12x2

x=x⇔ 2

x= x⇔ x2=2⇐ f x=0 .

Question 4 : a) g est dérivable sur [1 ; 2] (théorèmes généraux) et pour tout x∈[1 ;2]

g ' x = 121 – 2

x2 = x2 – 22 x2 . g ' x est du signe de x2 – 2 . On en déduit que

g ' x 0 sur [1 ; x*] et g ' x 0 sur [ x* ;2 ] . En vertu d'un théorème du cours g est décroissante sur [1 ; x*] et croissante sur [ x* ; 2] .De plus g x*=x* . D'où le tableau de variations :

x 1 x* 2

Signe de g ' x − 0 +

Variations de g1,5 1,5

x*

g 1=1,5 ; g 2=1,5

b) Posons pour tout n entier naturel (HRn) : xn existe et xn∈[1 ;2 ] .

• x0=1,5 donc (HR0) est vraie.• Soit n un entier naturel quelconque. Supposons (HRn) vraie. • Comme xn∈[1 ;2 ] on peut définir g xn . Or xn1=g xn . En vertu du tableau de

variations de g, xn1∈[ x*;1,5]⊂[1 ;2] . Donc (HRn+1) est vraie.

On en déduit que (HRn) est vraie pour toutes les valeurs de n.

Remarque : pour tout n0 on a xn∈[x* ;1,5] . Ceci sert notamment pour ce qui suit.

c) De ce qui précède on déduit que la suite x est minorée par 1. Soit n entier naturel

quelconque. xn1− xn=−12

xn1xn=

2 – xn2

2 xn=x*2− xn

2

2 xn. On en déduit que xn1− xn est du

signe de x*−x n , quantité négative en vertu de la remarque précédente. La suite x est donc décroissante. Étant décroissant et minorée, la suite x converge, notons vers l. l0De xn1=g xn et de la continuité de g on a en vertu du résultat admis, l=g l . Soit

f l =0 . Or x* est l'unique racine de f sur [1 ; 2] donc l=x* .

Sous partie 2

Question 5 : Commençons par remarquer que pour tout entier naturel n en0 . Soit n un entier

naturel. en1= xn1−x*=12 xn

2xn − x*=xn1− xnxn−x*=

2−xn2

2 xnxn−x*=

x*2−x n2

2 xn xn− x*

D'où en1=xn− x*1−x* xn

2 xn= xn−x*2

2 xn=

en2

2 xn.

Or pour tout entier naturel n xn1 donc 1

2 xn 1

2 . On en déduit immédiatement que

en112

en2 .

Question 6 : Posons pour tout entier naturel n, (HRn) : 0en 12

2n

.

• Quand n=0 , 12 2n

=12

. Or e0= x0−x*=32− x* . Comme x*1 , e0

12 . donc

(HR0) est vraie.• Soit n un entier naturel quelconque. Supposons (HRn) vraie.

• D'après la question 5 en112

en2 . Or par hypothèse de récurrence (et croissance de la

fonction carré sur [0 ; +∞[ ), 0en2 1

22n1

, d'où en112 12

2n1

122n1

. Donc

(HRn+1) est vraie.

On en déduit que pour tout entier naturel n, 0en 12

2n

.

Question 7 : Soit p∈]0 ;1 [ . Alors :

12 2n

p⇔ln122n

ln p⇔2n ln12 ln p⇔2n ln p

ln12 ⇔n ln 2ln ln p

ln12 . En posant

=ln ln p

ln12 , on a 12 2n

p⇔n ln 2

. On choisit pour N le plus petit entier naturel

supérieur à

ln 2 .

Question 8 :

Algorithme Avec Pythonécrire "saisir le terme initial de la suite "lire xécrire "saisir la précision p"lire pn ← 0Tant que (1/2)**(2**n)>p faire

x ← x2 1

x n← n1Fin Tant que écrire "une valeur approchée de la racine est"Afficher x

x=float(input("saisir le terme initial de la suite "))p=float(input("saisir la précision p"))n=0while (1/2)**(2**n)>p: x=x/2 + 1/x n=n+1

print("une valeur approchée de la racine est",x)

TP Fonctions

Exercice 1 (niveau 1ère S)Le but de cet exercice est de déterminer le nombre et une valeur approchée des solutions de l'équation du second degré a x2b xc=0 . Écrire un programme à l'aide du logiciel Python qui :

1. demande à l'utilisateur de saisir les coefficients a,b et c2. détermine le nombre de solutions de a x2b xc=03. dans le cas où elles existent, écrive ces solutions.

Réponse :

Algorithme Avec Pythonécrire "saisir les coefficients de l'équation"lire alire blire cdelta ← b^2-4*a*cSi delta>0 faire écrire "il y a deux solutions"

afficher −b−delta2a

afficher −bdelta2a

Sinon si delta=0 faire écrire "il y a une solution"

afficher −b2a

Sinon faire écrire "pas de solution"Fin Si

from math import sqrtprint("saisir les coefficients de l\'équation")a=float(input("a ? "))b=float(input("b ? "))c=float(input("c ? "))delta=b**2-4*a*c

if delta>0: print("il y a deux solutions ") print("x_1 = ",(-b-sqrt(delta))/(2*a)) print("x_2 = ",(-b+sqrt(delta))/(2*a))elif delta==0: print("il y a une solution ") print("x_0 = ",-b/(2*a))else: print("pas de solution")

Exercice 3 (niveau Terminale S)Données : nous disposons d'une fonction f définie sur un intervalle [a ; b] à valeurs dans ℝ telle que :• f est strictement monotone sur [a; b]• f est continue sur [a ; b]• f a f b0•

Alors (théorème des valeurs intermédiaires) il existe un unique réel c appartenant à ]a; b[ tel que f c = 0 .

1. Écrire un programme en Python qui étant donnés deux réels a et b (a<b) et une fonction f continue et strictement monotone sur [a ; b], donne une approximation de x0 à une précision p près (p choisie par l'utilisateur). Pour simplifier on supposera f strictement croissante sur [a ; b].

2. Testez ce programme pour les fonctions suivantes : a) f est définie sur [-5 ; 10] par f x = x32 x1b) f est définie sur [-0,5 ; 1] par f x = x−cos x

Réponse : on ne donne la correction que pour la fonction polynôme du 2)a) avec Python et l'algorithme général quelle que soit la fonction f choisie.

Algorithme Avec Python

écrire "saisir la borne inférieure a "lire aécrire "saisir la borne supérieure a "lire bTant que (b-a)>2p faire c ← (a+b)/2 Si f(a)f(c)<0 faire b ← c Sinon faire a ← c x ← (a+b)/2 Fin SiFin Tant que écrire "la solution de f(x) = 0 est à p près"Afficher x

def f(x): return x**3+2*x+1

def dico(y,a,b,p): global x while (b-a)>2*p: c=(a+b)/2 if f(a)*f(c)<0: b=c else: a=c x=(a+b)/2 print("la solution de f(x)=0 est dans [",x-p";",x+p,"]")


from math import *a=float(input("saisir la borne inf de l\'intervalle "))b=float(input("saisir la borne sup de l\'intervalle "))p=float(input("saisir la précision p "))

dico(f,a,b,p)

Exercice 4 : méthode des rectangles. (niveau Terminale S)

Réponse :

#subdivision d'une intervalle fermé borné

def subdivision(a,b,n): global subdi subdi=[] i,c=0,0 while i<=n: c=a+i*(b-a)/n # création des points de la subdivision subdi.append(c) i=i+1

return subdi

#définition de la fonction f

def f(x): return x**3 + 2*x+1

#aire des rectangles inférieurs

def aire_moins(f,subdi): global aire1 i,aire1=0,0 while i<n: aire1=aire1+(subdi[i+1]-subdi[i])*f(subdi[i]) i=i+1

return aire1

#aire des rectangles supérieurs

def aire_plus(f,subdi): global aire2 i,aire2=0,0 while i<n: aire2=aire2+(subdi[i+1]-subdi[i])*f(subdi[i+1]) i=i+1

return aire2


a=float(input("Entrer la borne inférieure de l\'intervalle "))b=float(input("Entrer la borne supérieure de l\'intervalle "))n=int(input("Saisir n "))subdivision(a,b,n)aire_moins(f,subdi)aire_plus(f,subdi)print("La valeur de l\'intégrale de ",a," à ",b," de f appartient à [", aire1," ; ",aire2,"]")

Exercice 5 : méthode des trapèzes. (niveau Terminale S)

Réponse :

#subdivision d'une intervalle fermé borné

def subdivision(a,b,n): global subdi subdi=[] i,c=0,0 while i<=n: c=a+i*(b-a)/n # création des points de la subdivision subdi.append(c) i=i+1

return subdi

#définition de la fonction f

def f(x): return x**3 + 2*x+1


a=float(input("Entrer la borne inférieure de l\'intervalle "))b=float(input("Entrer la borne supérieure de l\'intervalle "))n=int(input("Saisir n "))subdivision(a,b,n)i,aire=0,0while i<n: aire=aire+(f(subdi[i+1]+f(subdi[i]))*(subdi[i+1]-subdi[i])/2 i=i+1

print("La valeur de l\'intégrale de ",a," à ",b," de f est environ ",aire)

Prolongement des exercices 4 et 5 : estimation de l'erreur (conformément au programme, on n'exposera pas de méthode générale, mais on répondra uniquement avec les fonctions proposées).

TP Statistiques-Probabilités

Exercice 1 (niveau 1ère S)On considère le jeu suivant dont la mise est de 2€ : on lance deux dés parfaits à 6 faces et on s'intéresse à la somme obtenue. • Si la somme est entre 6 et 8 (compris) on perd sa mise.• Si la somme est 5 ou 9 on gagne 2€.• Si la somme est 4 ou 10 on gagne 5€.• Si la somme est 3 ou 11 on gagne 10€.• Si la somme est 2 ou 12 on gagne 50€.

1. Intéressons-nous pour le moment de manière théorique à la somme des nombres obtenus sur la face supérieure de chacun des 2 dés.

a) Compléter le tableau suivant par la valeur de la somme des deux dés.

Dé 1Dé 2 1 2 3 4 5 6

1 2 3 4 5 6 72 3 4 5 6 7 83 4 5 6 7 8 94 5 6 7 8 9 105 6 7 8 9 10 116 7 8 9 10 11 12

b) Quelles sont les différentes valeurs possibles pour cette somme ? Il y en a 11Compléter le tableau suivant :

Somme 2 3 4 5 6 7 8 9 10 11 12 Total

Fréquence théorique d’apparition

136

236

336

436

536

636

536

436

336

236

136 1

2. Soit X la variable aléatoire égale au gain (algébrique) du joueur : on tient donc compte de la mise !! a) Compléter le tableau suivant :

x i -2 0 3 8 48

P X=x i1636

836

636

436

236

Valeur approchée à

0,01 près0,44 0,22 0,17 0,11 0,06

b) E X = −2×1636

0×8363×6

368×4

36 48×2

36= 114

36 , soit E(X) ≈ 3,17€.

Ce nombre représente le gain moyen. À ce jeu. Si l'utilisateur jouait un très grand nombre de parties, il gagnerait en moyenne 3,17€.

c) V X = E X 2– E X 2 . Soit en détaillant les calculs

V X = 4×1636

9×63664×4

36482×2

36−114

36 2

= 1663561296

, soit V(X) ≈ 128,36. On a

X =E X , soit X ≈11,33 . Ces nombres servent à mesurer les écarts des gains à la moyenne.

3. Simulation pour un lancer de n dés

Analyse : on simulera le lancer d'un dé avec la commande randint(1,6), après l'avoir apportée via la bibliothèque random. On aura besoin des variables n (nombres d'essais), i (compteur variant de 1 à n), gain et somme.

Algorithme Avec Python

écrire "Combien de parties voulez-vous jouer ?"lire ni ← 1gain ← 0Tant que i<=n faire somme=entier_aléatoire_entre1_et_6+entier_aléatoire_entre1_et_6 Si somme>=6 et somme<=8 faire gain ← gain – 2 Si somme=4 ou somme=10 faire gain ← gain + 3 Si somme=3 ou somme=11 faire gain ← gain + 8 Si somme=2 ou somme=12 faire gain ← gain + 48 Fin Si i ← i+1Fin Tant que Afficher gain/n

from random import randint

n=int(input("Combien de parties voulez-vous jouer ? "))i=1gain=0while i<=n: somme=randint(1,6)+randint(1,6) if somme>=6 and somme<=8: gain=gain-2 if somme==4 or somme==10: gain=gain+3 if somme==3 or somme==11: gain=gain+8 if somme==2 or somme==12: gain=gain+48

i=i+1

print("Le gain moyen est de ",gain/n)

Commentaire pédagogique : Pas besoin de else à la fin car l'alternative au cas où la somme des deux dés est 5 ou 9 est de ne pas incrémenter le gain.

Exercice 2 (niveau Terminale S)On souhaite répondre au problème suivant : Une urne U1 contient 2 boules rouges, 3 boules bleues et 5 boules vertes ; une urne U2 contient 4 boules rouges et 5 boules bleues, tandis qu'une troisième urne U3 contient 3 boules bleues et 6 boules vertes. On procède alors à l'expérience suivante :on tire au hasard une boule de l'urne U1 que l'on place dans l'urne U2, puis on tire au hasard une boule de l'urne U2 que l'on place dans U3. Enfin, on tire au hasard une boule de U3 que l'on place dans U1.Quelle est la probabilité que la composition de l'urne U1 n'ait pas changé à l'issue de ces 3 manipulations ?

Réponse : on ne donne que le programme en Python. L'algorithme se déduit du texte.

from random import randintn=int(input("saisir le nombre d\'essais "))i=1cas_favorables=0while i<=n: nb_rouges1,nb_bleues1,nb_vertes1=2,3,5 nb_rouges2,nb_bleues2,nb_vertes2=4,5,0 nb_rouges3,nb_bleues3,nb_vertes3=0,3,6 a=randint(1,10) if a<=2: nb_rouges2=nb_rouges2+1 nb_rouges1=nb_rouges1-1 elif a<=5: nb_bleues2=nb_bleues2+1 nb_bleues1=nb_bleues1-1 else: nb_vertes2=nb_vertes2+1 nb_vertes1=nb_vertes1-1

a=randint(1,10) if a<=nb_rouges2: nb_rouges3=nb_rouges3+1 elif a<=nb_rouges2+nb_bleues2: nb_bleues3=nb_bleues3+1 else: # quand bien même aucune boule verte ne provient de nb_vertes3=nb_vertes3+1 # l'urne 2 : cas où nb_rouges2+nb_bleues2 = 10

a=randint(1,10) if a<=nb_rouges3: nb_rouges1=nb_rouges1+1 elif a<=nb_rouges3+nb_bleues3: nb_bleues1=nb_bleues1+1 else: nb_vertes1=nb_vertes1+1 # idem avec les urnes 3 et 1

if nb_rouges1==2 and nb_bleues1==3 and nb_vertes1==5: cas_favorables=cas_favorables+1

i=i+1

print("Sur ces ",n,"essais la composition de l\'urne n\'a pas changé en proportion de ",cas_favorables/n)

En testant le programme précédent avec n=10000, on trouve approximativement une probabilité de 0,423.

Justification théorique : On cherche à déterminer la probabilité de l'événement A=B1∩B3∪R1∩R3∪V 1∩V 3 . Les événements B1∩B3 , R1∩R3 et V 1∩V 3

étant deux à deux incompatibles, on a p A=p B1∩B3 pR1∩R3 p V 1∩V 3 . Calculons par exemple p B1∩B3 , les autres membres se traitant de manière identique.

{ B2 ; R2 ; V 2 } constitue un système complet d'événements. On a donc p B1∩B3= pB1∩B2∩B3p B1∩R2∩B3p B1∩V 2∩B3 , soit

p B1∩B3=310× 6

10× 4

10 3

10× 4

10× 3

100= 108

1000 .

De même, p R1∩R3=10

1000 et p V 1∩V 3=305

1000 . D'où p A= 4231000 . On retrouve le

résultat subodoré expérimentalement.

CHAPITRE 7 : THÈMES D'ÉTUDE


Le but de ce chapitre est de donner sous forme de longs TP (qui peuvent par ailleurs faire office de projets) des thèmes d'étude dans divers domaines : statistiques et probabilités, arithmétique, optimisation, géométrie. Certains d'entre eux font appel à d'autres logiciels que Python : tableur Open Office, Geogebra pour la géométrie dynamique et maxima ou Xcas pour le calcul formel. Cette approche expérimentale permet d'entrevoir toute la puissance des nouveaux outils TICE pour la résolution de problèmes mathématiques. On n'oubliera pas pour autant la démarche démonstrative indispensable pour une formation complète. Le fond ne doit pas faire oublier la forme !

La plupart peuvent être traités en seconde mais l'apprentissage des divers logiciels font qu'ils sont plutôt utilisables en première ou terminale S. Quelques thèmes offrent une ouverture vers le supérieur et donneront lieu à des compléments.

PROBABILITES ET STATISTIQUES

TP 1 : Le jeu du lièvre et de la tortue

Une partie se déroule de la manière suivante : on lance un dé.• Si le dé tombe sur un entier compris entre 1 et 5, la tortue avance d'une case. Elle doit

franchir 5 cases avant d'atteindre l'arrivée. La partie est alors terminée et elle a gagné.• Si le dé tombe sur 6, le lièvre atteint directement l'arrivée. La partie est terminée et le lièvre

a gagné. • La partie continue jusqu'à l'obtention d'un gagnant.

Le but de cet exercice est de savoir qui en moyenne gagne le plus souvent.

Modélisation d'une partie

On rappelle que la commande randint(a,b) renvoie un entier aléatoire entre a et b (bornes entières). Pour cela, on doit d'abord appeler la bibliothèque random via : from random import randint.

Parcours de la tortue

Parcours du lièvre si le dé amène 6

Cahier des charges : • De combien de variables a-t-on besoin ? • A-t-on besoin d'une boucle ? A quel moment ?• A-t-on besoin d'une instruction conditionnelle ?

Analyse : une variable a servira à simuler le lancer d'un dé à 6 faces. Tant que ce dé n'amène pas 6 la tortue avance d'une case. On aura donc besoin d'une variable pas servant à donner le nombre de pas effectués par la tortue durant la partie et d'une boucle Tant que. Si le dé amène 6 le lièvre gagne immédiatement : on aura donc besoin d'une instruction conditionnelle et de deux autres variables gain_lievre et gain_tortue s'incrémentant d'une unité en cas de victoire d'un des deux animaux.

Écrire un script modélisant une partie.

Modélisation de plusieurs parties

On souhaite répondre à la question suivante : Quelle est la probabilité que la tortue gagne ? Nous allons pour cela utiliser l'approche fréquentiste en répétant un grand nombre de fois le « jeu » précédent.

1. Modifier le script précédent pour répéter n fois l'expérience et renvoyer la fréquence de gain du lièvre et celui de la tortue. Remplir ensuite le tableau précédent avec une précision de

10−4 et avec n = 10000.

Départ Arrivée

10000 parties Fréquence gain du lièvre Fréquence gain de la tortueJeu 1Jeu 2Jeu 3Jeu 4Jeu 5

Moyenne des fréquences

2. Quelle semble être la durée moyenne d'une partie ? (en terme de lancers de dé)

Approche théorique

Appelons T l'événement : « la tortue gagne ». Ceci signifie qu'au cours des 6 lancers de dé, ce-dernier n'amène jamais un 6.

1. Calculer p T 2. En déduire p T . 3. Comparer avec les résultats obtenus précédemment.

Représentation graphique

Importer la librairie matplotlib via la commande :import matplotlib.pyplot as plt

On créera deux listes : listex et listey pour représenter les abscisses et les ordonnées des points à dessiner initialisées chacune à partir de la liste vide.

Quelques commandes utiles :plt.plot([1,5,9],[0,4,-1]) affiche les points A(1,0) ; B(5,4) et C(9,-1). plt.axis([xmin,xmax,ymin,ymax]) trace deux axes orthogonaux x variant entre xmin et x max

et y variant entre ymin et ymaxplt.show() pour afficher le tout

Simuler ensuite un jeu de 100 parties de la manière suivante (n désigne le numéro de la partie) : • Si la tortue gagne la partie n, on fait apparaître le point de coordonnées (n,-1)• Sinon on fait apparaître le point de coordonnées (n,1)• On relie ensuite tous les points entre eux par des segments.

Corrigé du TP1

Modélisation d'une partie

Algorithme Avec Pythonpas ← 1a ← entier aléatoire entre 1 et 6Tant que pas<6 et a ≠ 6 faire pas ← pas + 1 a ← entier aléatoire entre 1 et 6Fin Tant que

Si a = 6 faire gain_lievre ← gain_lievre + 1Sinon faire gain_tortue ← gain_tortue + 1Fin Si

pas=1a=randint(1,6)while pas<6 and a!=6: pas=pas+1 a=randint(1,6)

if a==6: gain_lievre=gain_lievre+1else: gain_tortue=gain_tortue+1

Modélisation de plusieurs parties

1. Algorithme et programmation

Algorithme Avec Pythonécrire "Combien de parties à jouer ?"lire nb_partiesi ← 1gain_lievre ← 0gain_tortue ← 0Tant que i<=nb_parties faire pas ← 1 a ← entier aléatoire entre 1 et 6 Tant que pas<6 et a ≠ 6 faire pas ← pas + 1 a ← entier aléatoire entre 1 et 6 Fin Tant que

Si a = 6 faire gain_lievre ← gain_lievre + 1 Sinon faire gain_tortue ← gain_tortue + 1 Fin Si i ← i + 1Fin Tant queécrire "Fréquence de gain du lièvre"afficher gain_lievre/nb_partiesécrire "Fréquence de gain de la tortue"afficher gain_tortue/nb_parties


nb_parties=int(input("Combien de parties à jouer ? "))i,gain_lievre,gain_tortue=1,0,0while i<=nb_parties: pas=1 a=randint(1,6) while pas<6 and a!=6: pas=pas+1 a=randint(1,6)

if a==6: gain_lievre=gain_lievre+1 else: gain_tortue=gain_tortue+1

i=i+1

print("Fréquence de gain du lièvre :",gain_lievre/nb_parties)print("Fréquence de gain de la tortue :",gain_tortue/nb_parties)

Nous allons tester 5 fois le programme précédent avec n=10000. Bien entendu, les résultats renvoyés par la machine que j'ai utilisée seront très probablement différents des vôtres. C'est un des

aspects de la fluctuation d'échantillonnage.

10000 parties Fréquence gain du lièvre Fréquence gain de la tortueJeu 1 0,6663 0,3337Jeu 2 0,6593 0,3407Jeu 3 0,6665 0,3335Jeu 4 0,6665 0,3335Jeu 5 0,6721 0,3279

Moyenne des fréquences 0,6661 0,3339

Il semble que la proportion de parties gagnées par le lièvre est de l'ordre de 67%.

2. Durée moyenne d'une partie

Le calcul de l'espérance ne figurant pas au programme de seconde, nous allons encore une fois utiliser l'approche fréquentiste pour avoir une idée du résultat. On aura besoin d'une variable nb_pas comptabilisant le nombre de pas nécessaires pour qu'une partie se termine.

Algorithme Avec Pythonécrire "Combien de parties à jouer ?"lire nb_partiesi ← 1nb_pas ← 0Tant que i<=nb_parties faire pas ← 1 a ← entier aléatoire entre 1 et 6 Tant que pas<6 et a ≠ 6 faire pas ← pas + 1 a ← entier aléatoire entre 1 et 6 Fin Tant que

nb_pas ← nb_pas + pas i ← i + 1Fin Tant que

écrire "Le nombre moyen de coups par partie est de : "afficher nb_pas/nb_parties


nb_parties=int(input("Combien de parties à jouer ? "))i,nb_pas=1,0while i<=nb_parties: pas=1 a=randint(1,6) while pas<6 and a!=6: pas=pas+1 a=randint(1,6)

nb_pas=nb_pas+pas i=i+1

print("Le nombre moyen de coups par partie est de : ",nb_pas/nb_parties)

On trouve avec n=10000 une durée moyenne de 3,99 coups par partie.

Approche théorique

1. Dire que la tortue gagne signifie qu'au cours des 6 lancers, le dé amène un autre nombre que

6, ce qui a chaque lancer se produit avec une probabilité de 56 . D'où p T = 56

6

.

2. p T = 1– p T soit p T = 1−566

≈0,67 .

3. On retrouve les résultats simulés précédemment. Ouf !

Représentation graphique

On donne directement une représentation graphique associée à 100 parties.

TP 2 : Une histoire de grenouilles

Le but de cet exercice est de résoudre le problème suivant : Au départ, trois grenouilles (assimilées à des points et ayant l'éternité devant elles) sont respectivement situées aux sommets A, C et D du carré ABCD. Toutes les minutes, une grenouille (n'importe laquelle) saute au dessus d'une autre pour atteindre le point symétrique du départ de son saut par rapport au point occupé par celle au dessus de qui elle saute.Se peut-il qu'à un moment donné une des grenouilles se retrouve au point B ?

Petit préliminaire mathématique

On se donne un point M x ; y et un point a ;b . Exprimer les coordonnées x ' et y ' du point M ' symétrique de M par rapport à .

Modélisation du problème

A) Création d'un repère orthonormé

Sans perte de généralité, on peut supposer que le carré est de côté 1. On considère alors le repère orthonormé (B ; C ; A). Ainsi B est l'origine.Donner les coordonnées des points A, C et D dans ce repère.

B) Cahier des charges

• On aura besoin de trois couples de coordonnées correspondant aux positions respectives de chacune des trois grenouilles. On utilisera des listes à 2 éléments.

• On aura besoin d'une variable a renvoyant un entier aléatoire entre 1 et 3 (les numéros attribués aux grenouilles) pour déterminer quelle grenouille va sauter.

• On aura besoin d'une variable b renvoyant un entier aléatoire entre 1 et 3 (et différent de la valeur affectée à a) pour déterminer au-dessus de quelle grenouille s'effectue le saut.

• Enfin on aura besoin de n, une variable pour le nombre de sauts à effectuer. D'où la nécessité d'une boucle et de i compteur variant de 1 à n.

• Le résultat est positif si l'une des grenouilles revient à l'origine. D'où une instruction conditionnelle. Elle est également nécessaire pour déterminer les nouvelles positions des grenouilles en fonction de celle qui a sauté par dessus l'une de ses deux autres congénères.

C) Première approche

On va écrire dans un premier temps un script demandant à l'utilisateur de saisir le nombre de sauts à effectuer (on pourra tester avec n=100, puis n=1000 et n=10000). Conjecturer alors la réponse à l'exercice posé.

D) Visualisation des positions successives

Importer le module turtle Tracer le carré initial. On prendra comme côté 20. On fera apparaître les points A, C et D correspondant aux positions initiales des trois grenouilles.Tracer ensuite un nuage de points simulant 20 sauts de grenouille.

Attention à modifier en conséquence les coordonnées de A, B, C et D. Pour représenter un point, on pourra tracer un cercle de rayon 5 grâce à la commande circle(5). On ne représentera que les « points » et pas les trajets des grenouilles.

Retour à la théorie

1. Relevez la parité des coordonnées des positions initiales de chacune des trois grenouilles.2. On reprend les notations du préliminaire mathématique.

a) On suppose que a deux coordonnées impaires et que M a deux coordonnées de parité différente. Déterminer la parité des coordonnées de M ' . b) Même question si a deux coordonnées de parité différente et que M a deux coordonnées impaires.c) Pareillement si et M ont deux coordonnées impaires (respectivement de parité différente)

3. Prouvez que lorsqu'une grenouille se déplace elle tombe nécessairement sur un point dont les coordonnées sont toutes deux impaires ou de parité différente.

4. Conclure.

Corrigé du TP2

Préliminaire mathématique

Par définition, est le milieu de [MM']. On aboutit donc au système : {x x '2=a

y y '2 =b} , d'où

{x '=2 a−xy '=2 b− y} .

Modélisation du problème

Dans le repère (B,C,A) les points A, B C et D ont respectivement pour coordonnées A0 ;1 , B 0 ;0 , C 0 ;1 , D 1 ;1 .

from random import randintn=int(input("Combien de sauts à effectuer ? "))i=1gre1=[0,1] #coordonnées de départ pour les 3 grenouillesgre2=[1,0]gre3=[1,1]while i<=n and (gre1!=[0,0] or gre2!=[0,0] or gre3!=[0,0]): a=randint(1,3) #numéro de la grenouille qui saute b=randint(1,3) #numéro de la grenouille par dessus qui on saute while b==a: #b est nécessairement différent de a, d'où ce test b=randint(1,3) #calcul des nouvelles coordonnées des grenouilles après saut if a==1: if b==2: #a=1 et b=2 gre1[0]=2*gre2[0]-gre1[0] gre1[1]=2*gre2[1]-gre1[1] else: #a=1 et b=3 gre1[0]=2*gre3[0]-gre1[0] gre1[1]=2*gre3[1]-gre1[1] elif a==2: if b==1: #a=2 et b=1 gre2[0]=2*gre1[0]-gre2[0] gre2[1]=2*gre1[1]-gre2[1] else: #a=2 et b=3 gre2[0]=2*gre3[0]-gre2[0] gre2[1]=2*gre3[1]-gre2[1] else: if b==1: #a=3 et b=1 gre3[0]=2*gre1[0]-gre3[0] gre3[1]=2*gre1[1]-gre3[0] else: #a=3 et b=2 gre3[0]=2*gre2[0]-gre3[0] gre3[1]=2*gre2[1]-gre3[1] i=i+1

if (gre1==[0,0] or gre2==[0,0] or gre3==[0,0]): print("Problème résolu en ",n," sauts")else: print("Pas de passage par l\'origine")

En testant à plusieurs reprises avec des valeurs de n de plus en plus grandes on trouve à chaque fois qu'aucune grenouille ne passe par l'origine. La réponse semble être négative.

Une simulation à l'aide du mode turtle

Remarque : je ne donne pas le script permettant d'effectuer le dessin ci-dessus ; il suffit de modifier légèrement celui qui précède en rajoutant des cercles aux positions des grenouilles, tout en n'oubliant pas de lever et de rabaisser le crayon pour ne pas tracer les trajets des grenouilles. On peut utiliser 3 couleurs pour chaque grenouille.

La justification théorique est laissée à la sagacité du lecteur. Don't worry, it's easy !

TP 3 : Marche aléatoire sur un tétraèdre

On considère un tétraèdre ABCD sur lequel on promène un pion. Toutes les secondes, on déplace le pion d'un sommet à l'autre en choisissant au hasard parmi les trois sommets possibles. On s'intéresse au temps écoulé entre le début de la promenade du pion et le premier retour au point de départ.

• Pour simuler le choix de l'arête à emprunter, on lancera un dé équilibré à 6 faces et on considérera la codage donné par la figure ci-dessous.

• On limitera une promenade à 60 secondes.• On choisit de partir du sommet A.

Modélisation d'une promenade

On va commencer par numéroter les sommets du tétraèdre : 1 pour A, 2 pour B, 3 pour C et 4 pour D. Le sens de parcours des arêtes est indifférent. Par exemple si l'on est en A et que le dé amène 2, le pion se déplace en B. Si au lancer suivant le dé amène encore 2, on se retrouve à nouveau en A (et dans ce cas la promenade est finie).

Variables nécessaires : t le temps de parcours pour une promenade ; numde l'entier aléatoire amené par le lancer du dé ; numsommet le numéro du sommet du tétraèdre.

Structures nécessaires : une structure conditionnelle qui donne le numéro du sommet atteint en fonction du résultat du dé ; une boucle : on continue le parcours tant qu'on n'est pas revenu au point de départ ou que le temps de parcours n'a pas excédé 60 secondes.

En utilisant des flèches pour le sens de parcours sur le tétraèdre, on peut modéliser le tétraèdre et ses arêtes par le schéma qui suit :

Écrire un script simulant une promenade sur le tétraèdre. On pourra créer une fonction promenade lors du passage à la programmation.

Modélisation de plusieurs promenades

Écrire un script qui demande à l'utilisateur de saisir le nombre de promenades voulues et renvoie le temps moyen d'une promenade. Le tester avec n=10000 cinq fois de suite et remplir le tableau ci-dessous avec une précision de 10−4 près.

Temps moyen d'une promenadeSérie 1 de 10000 promenadesSérie 2 de 10000 promenadesSérie 3 de 10000 promenadesSérie 4 de 10000 promenadesSérie 5 de 10000 promenades

moyenne

1 2

3

4

1 ou 2

5 ou 6

3 ou 4 5 ou 61 ou 2

3 ou 4

Corrigé du TP3

Modélisation d'une promenade

• Obtenir 1 ou 2 en lançant le dé permet de passer du sommet 1 au sommet 2 (et réciproquement) ou du sommet 3 au sommet 4 (et réciproquement). Dans chaque cas ces sommets ont 1 d'écart en valeur absolue.

• Obtenir 3 ou 4 en lançant le dé permet de passer du sommet 1 au sommet 3 (et réciproquement) ou du sommet 2 au sommet 4 (et réciproquement). Dans chaque cas, ces sommets ont 2 d'écart en valeur absolue.

• Obtenir 5 ou 6 en lançant le dé permet de passer du sommet 1 au sommet 4 (et réciproquement) : écart de 3 en valeur absolue, ou du sommet 2 au sommet 3 (et réciproquement) : écart de 1 en valeur absolue.

La condition dans la boucle Tant que porte sur deux choses : revenir au sommet 1 et ne pas dépasser un temps de 60s. Pour faire rentrer dans la condition « revenir au sommet 1 », on doit déjà avoir avancé une fois. On peut procéder plus directement. A vous de voir comment.

from random import randintnumsommet=1 #initialisation des donnéesnumde=randint(1,6) #premier mouvementif numde<=2: numsommet=2elif numde<=4: numsommet=3else: numsommet=4t=1 while (t<=60) and (numsommet!=1): #la ballade proprement dite numde=randint(1,6) if numde<=2: #cas où le dé amène 1 ou 2 if numsommet==1 or numsommet==3: numsommet=numsommet+1 else: numsommet=numsommet-1 elif numde<=4: #cas où le dé amène 3 ou 4 if numsommet<=2: numsommet=numsommet+2 else: numsommet=numsommet-2 else: #cas où le dé amène 5 ou 6 if numsommet==1: numsommet=4 elif numsommet==2: numsommet=3 elif numsommet==3: numsommet=2 else: numsommet=1 t=t+1if numsommet==1: print('Promenade terminée en ',t,'secondes')

Modélisation de plusieurs promenades

# fonction promenade

def promenade(): global t #la variable t est globale pour la réutiliser dans le PP numsommet=1 #initialisation des données numde=randint(1,6) #premier mouvement if numde<=2: numsommet=2 elif numde<=4: numsommet=3 else: numsommet=4 t=1 while (t<=60) and (numsommet!=1): #la ballade proprement dite numde=randint(1,6) if numde<=2: #cas où le dé amène 1 ou 2 if numsommet==1 or numsommet==3: numsommet=numsommet+1 else: numsommet=numsommet-1 elif numde<=4: #cas où le dé amène 3 ou 4 if numsommet<=2: numsommet=numsommet+2 else: numsommet=numsommet-2 else: #cas où le dé amène 5 ou 6 if numsommet==1: numsommet=4 elif numsommet==2: numsommet=3 elif numsommet==3: numsommet=2 else: numsommet=1

t=t+1

if numsommet==1: return t


from random import randintn=int(input("Combien de promenades voulez-vous faire ? "))temps_total,i=0,1while i<=n: promenade() temps_total=temps_total+t i=i+1print("Le temps moyen d\'une promenade est de ",temps_total/n)

Les résultats numériques

Temps moyen d'une promenadeSérie 1 de 10000 promenades 3,9889Série 2 de 10000 promenades 4,0123Série 3 de 10000 promenades 3,9612Série 4 de 10000 promenades 3,9993Série 5 de 10000 promenades 3,9786

Moyenne 3,9881

Il semble que le temps de parcours moyen est d'environ 4 secondes.

TP 4 : Un sondage

Un sac de haricots contient dans une certaine proportion des haricots rouges et des haricots blancs. On aimerait pouvoir déterminer précisément la proportion p de haricots rouges et celle q de haricots blancs. (Quel est le lien entre p et q ?).

Une première méthode consiste à renverser le sac et à tout compter. Long et fastidieux ! Ce serait comme demander à l'ensemble des votants à une élection vers quel candidat s'est porté leurs suffrages. Il n'y aurait alors plus aucun doute quant au résultat final. La seconde méthode, celle qu'utilisent les instituts de sondages consiste à demander à un échantillon de personnes pour qui elles ont voté.

Que signifie ce terme d'échantillon ? Une partie de la population ? Autre chose ? Comment en constituer un qui soit représentatif de la population ? Tout autant de questions auxquelles on ne répondra pas entièrement ni précisément ici mais qu'il est intéressant de se poser.

Un modèle simplifié de sondage

Rappelons notre but : déterminer avec le moins d'incertitude possible la proportion p de haricots rouges dans notre sac.

Comment va-t-on effectuer le prélèvement d'un échantillon ? Successivement AVEC remise.

Remarque : Dans le cas où la population est très grande par rapport à la taille de l'échantillon, on assimilera ce mode de prélèvement à celui d'un sous-ensemble de la population. On supposera cette hypothèse vérifiée ici.

On suppose que le sac comporte 37500 haricots rouges et 62500 haricots blancs, soit 100000 haricots au total. Autrement dit p = 0,375. Cette information est a priori inconnue de celui qui achète le sac. Dans ce but, on va prélever des échantillons dans le sac afin d'estimer la proportion p de haricots rouges.

Création de la populationOuvrir un fichier vierge via Program files>Python3.1>IDLE(Python GUI)>File New windowSaisir ensuite les lignes suivantes :from random import *population=[1 for n in range(37500)]+[0 for n in range(62500)]# on constitue une liste ordonnée de 1 et de 0 ; 1 code un haricot rouge et 0 un haricot blanc.shuffle(population)#on mélange les éléments de la population.

Prélèvement d'un échantillon de taille 100A la suite de ce qui précède, saisir les lignes de commandes :echantillon=sample(population,100)#la commande sample permet d'extraire un échantillon de la population de la taille voulue.On calcule ensuite dans cette échantillon la proportion f de '1'.f=0for n in range(len(echantillon)):

if echantillon[n]==1:f=f+1

print(f/100)

#Tester ensuite cette proportion sur plusieurs échantillons en compilant avec Ctrl+F5

Prélèvement de plusieurs échantillons# Nous allons faire mieux en prélevant 50 échantillons de taille 100 et en calculant la proportion de '1'. Nous tracerons ensuite un nuage de points pour illustrer ces proportions. Question 1 : Modifier le script précédent de manière à créer 50 échantillons de taille 100. Vous créerez un vecteur ligne de taille 50 donnant dans chaque cas la proportion de '1'.

Question 2 : Tracer le nuage de points correspondant aux proportions trouvées. En abscisse on notera le numéro de l'échantillon.

Question 3 : Calculer la moyenne des proportions trouvées.

Question 4 : Mêmes questions mais avec 50 échantillons de taille 1000.

Initiation à l'inférence statistique On peut démontrer dans le cadre de la théorie des probabilités la « formule » suivante :Si on fait un grand nombre de sondages de taille n, au moins 95% d'entre eux vérifient :

f ∈[ p – 1 n

; p 1n] .

Question 1 : Effectuer 1000 sondages de taille 100 et compter combien de fréquences f obtenues expérimentalement sont dans la fourchette [0,275 ; 0,475]. Comparer avec le résultat théorique cité précédemment.

Question 2 : Représenter le nuage de points associé à 1000 sondages de taille 100 et les droites horizontales d'équation y=27,5 et y=47,5 . Compter le nombre de points qui sont en dehors des bandes horizontales limitées par ces droites.

Corrigé du TP4

Un modèle simplifié de sondage

Prélèvement de plusieurs échantillons de taille 100

On donne en même temps le script permettant de tracer le nuage de points et de calculer la moyenne des fréquences de '1' relevées dans les 50 échantillons de taille 100.


population=[1 for n in range(37500)]+[0 for n in range(62500)]shuffle(population) #mélange des 0 et des 1print(len(population)) #un test :on a bien une population de 100000 individus

listex,vect_frequences=[],[]i=0while i<50: echantillon_100=sample(population,100) #création de 50 échantillons p=0 # de taille 100 for n in range(len(echantillon_100)): if echantillon_100[n]==1: p=p+1

listex.append(i) vect_frequences.append(p) #on construit le vecteur fréquence i=i+1 #les fréquences sont exprimées en %

# moyenne des proportions trouvéesS=0for j in range(len(vect_frequences)): S=S+vect_frequences[j]

print ("La moyenne des fréquences est de :",S/len(vect_frequences),"%")

# tracé du nuage de pointsimport matplotlib.pyplot as pltimport numpy as np

x=np.arange(0,60,10)plt.plot(x,37.5*x**0) # tracé de la droite d'équation y = 37.5plt.plot(listex,vect_frequences,'ro')plt.axis([0,50,20,70])plt.show()

Initiation à l'inférence statistique

Rappelons que dans le cas présent on connaît la proportion p de haricots rouges. Si dans la pratique p représente la proportion d'électeurs d'un candidat A opposé à un candidat B lors d'une élection, peut-on raisonnablement estimer cette valeur à l'aide d'un ou plusieurs échantillons de personnes sondées ? p n'est pas connu et il faut pourtant en trouver une estimation la plus précise possible.

On peut démontrer le résultat suivant : Si on fait un grand nombre de sondages de taille n, environ

95% d'entre eux vérifient : p∈[ f – 1 n

; f 1n] .

Pour un sondage de taille n, dont le résultat est f, l'intervalle [ f – 1n

; f 1n] est appelé

fourchette de sondage au niveau 0,95. Donnons à présent un script répondant aux 2 questions posées :


population=[1 for n in range(37500)]+[0 for n in range(62500)]shuffle(population)

listex,vect_frequences=[],[]i=0while i<1000: echantillon_100=sample(population,100) #création de 1000 échantillons p=0 # de taille 100 for n in range(len(echantillon_100)): if echantillon_100[n]==1: p=p+1

listex.append(i) vect_frequences.append(p) #on construit la matrice ligne des fréquences i=i+1

# moyenne des proportions trouvées et nombre de f en dehors de [0.275 ; 0.475]S,out=0,0 #out compte le nombre de f en dehorsfor j in range(len(vect_frequences)): S=S+vect_frequences[j] if vect_frequences[j]<27.5 or vect_frequences[j]>47.5: out=out+1

print ("La moyenne des fréquences est de :",S/len(vect_frequences),"%")print ("Sur 1000 échantillons de taille 100 ",out,"ne sont pas dans [0.275 ; 0.475]")

# tracé du nuage de pointsimport matplotlib.pyplot as pltimport numpy as np x=np.arange(0,1100,10)plt.xlabel('essais')plt.ylabel('frequences exprimees en %')plt.plot(x,27.5*x**0,color='blue')plt.plot(x,37.5*x**0,color='red')plt.plot(x,47.5*x**0,color='blue')plt.plot(listex,vect_frequences,'ro')plt.axis([0,1000,20,70])plt.show()

Un exemple de nuage de points où l'on a pris 1000 échantillons de taille 100.On trouve que 42 valeurs de f ne sont pas dans l'intervalle [0,275 ; 0,475]. Le résultat théorique n'est pas mis en défaut.

Remarque : on peut affiner les fourchettes de sondage mais nous dépassons là le cadre du programme du lycée. Notons simplement que plus l'échantillon est grand, meilleure sera l'estimation. Cependant, ce que l'on gagne en précision : f très proche de p avec une probabilité proche de 1, est perdu car la taille de la fourchette augmente sensiblement.

Prolongement possible : Un boulanger vend des baguettes de poids nominal 200g. Un consommateur suspectant une fraude pèse 40 baguettes et obtient les résultats suivants :

192 205 189 188 200 201 194 190185 185 187 201 184 196 203 200201 184 187 189 194 196 200 205193 189 185 186 190 204 191 186189 183 200 184 191 192 193 187

Le consommateur peut-il au risque de 5% attaquer le boulanger pour défaut sur le poids de son pain ?

TP 5 : Modélisation d'un réseau d'informations

On considère un réseau de sommets ABCD (que l'on peut se représenter comme un réseau d'ordinateurs par exemple) reliés par des liaisons L1 à L5 comme représenté sur le schéma ci-dessous.

Ce réseau a pour objet de transmettre de l'information de A vers D . Ces informations transitent par n'importe quel chemin en fonctionnement : par exemple L5L2L1 est un chemin possible et il fonctionne si et seulement si les trois liaisons L5, L2 et L1 fonctionnent. Chaque liaison a la même probabilité p de fonctionnement durant une unité de temps. Durant cette unité de temps, on considère qu'une liaison ne change pas d'état : ou bien elle reste en fonctionnement ou bien elle est en panne. Les cinq liaisons sont indépendantes les unes des autres en ce qui concerne leurs pannes. On dit que le réseau fonctionne durant une unité de temps si l'un des chemins possibles entre A et D a permis le passage de l'information entre ces points.

1. Déterminer en fonction de p la probabilité f p que le réseau fonctionne durant une unité de temps. Vous raisonnerez formellement ou vous écrirez un script modélisant le fonctionnement du réseau.

2. Pour renforcer la fiabilité du réseau, on remplace chacune des liaisons simples par des liaisons multiples constituées de n brins en parallèle, ayant chacun la même probabilité de fonctionnement durant une unité de temps. Une liaison multiple fonctionne si au moins l'un des brins la constituant fonctionne. a) On appelle A l'événement « une liaison multiple fonctionne » et pour une liaison multiple donnée on note X la variable aléatoire égale au nombre de brins qui la constitue qui fonctionnent. a) i) Justifier que X suit une loi binomiale dont on précisera les paramètres.

D B

C

A

L1 L

2

L3

L4 L

5

a) ii) En déduire p(A). Remarque : comme A dépend de et de n on écrira p A=g , n . b) En déduire la probabilité h , n de fonctionnement du réseau ainsi constitué.c) Écrire un script qui demande à l'utilisateur :• de saisir le nombre n de brins constituant chaque segment• de saisir la probabilité de fonctionnement de l'un des n brins d'un segment• et qui renvoie la probabilité h , n de fonctionnement du réseau ainsi constitué.

Vous pouvez soit vous servir de la formule établie précédemment, soit modéliser le transit de l'information entre A et D. Il sera judicieux de créer une fonction segment(beta,n).

Tester le programme avec quelques valeurs : n=5 et =0,25 , etc...3. Posons le coût unitaire des brins constituant les liaisons. Soit le gain par unité de

temps de l'opérateur du réseau lorsque celui-ci fonctionne. a) Calculer l'espérance du gain de l'opérateur pour une unité de temps. b) Si =5 , =0,2 et =500 , déterminer le nombre n de brins en parallèle nécessaire pour maximiser l'espérance de gain de l'opérateur. Vous pourrez vous aider d'un tableur au besoin.

Corrigé du TP5

Question 1 : Solution expérimentale from random import *

p=float(input("Entrez la probabilité de fonctionnement de chaque segment "))while p>1 or p<0: #un test pour que l'utilisateur saisisse bien un print("un nombre entre 0 et 1 SVP ") #réel entre 0 et 1 p=float(input())

# on va définir l'état de chacun des segments du réseau en créant une matrice ligne vecliaisons constitué de 0 et de 1

def liaison(p): global vecliaisons #de manière à réutiliser cette variable dans le script principal vecliaisons=[] i=1 while i<=5: #on va définir l'état des 5 branches k=random() #on génère un réel aléatoire entre 0 et 1 if k<=p: #on ajoute 1 à la liste si k inférieur ou égal à p et 0 sinon vecliaisons.append(1) #p sert à donner la proportion de 0 et de 1 else: vecliaisons.append(0) i=i+1

return vecliaisons

# on modélise le fonctionnement du réseau sur n unités de temps

n=int(input("Sur combien d\'unités de temps voulez-vous observer le réseau ? "))i=0test_bon=0while i<n: liaison(p) if vecliaisons[3]==1 or (vecliaisons[4]==1 and vecliaisons[2]==1) or (vecliaisons[4]==1 and vecliaisons[1]==1 and vecliaisons[0]==1): #les conditions pour que le réseau fonctionne test_bon=test_bon+1 i=i+1

print("La fréquence de fonctionnement du réseau par unité de temps est de ",test_bon/n)

Analyse : Le but du script est de modéliser le fonctionnement du réseau. Les différents chemins menant de A à D sont : L4, L5L3 et L5L2L1. Il s'ensuit d'après les hypothèses du texte que le circuit fonctionne au cours d'une unité de temps si et seulement si l'un au moins de ces chemins est opérationnel. ➢ On va être amené à construire une matrice ligne de 5 éléments, chacun d'entre eux

représentant l'état de la liaison : 1 pour en état de marche et 0 sinon. Par exemple [1,0,0,1,0] signifie que les chemins L1 et L4 sont en état de marche, mais pas L2, L3 et L5.

➢ Un problème se pose alors : en quelle proportion de '1' et de '0' doit-on compléter la matrice ligne ? A ce moment on doit prendre en compte les données du texte : chaque liaison a la même probabilité p de fonctionnement durant une unité de temps. L'idée est de procéder

comme on le ferait dans un tableur pour générer des nombres en proportion déterminée à l'avance.

La cellule A1 contient la formule =SI(ALEA()<=0.2,1,0) qui a été recopiée dans 199 autres cellules et permet de générer des '1' en proportion 0,2 et des '0' en proportion 0,8. On a vérifié les proportions de '1' et de '0' dans les cellules C22 et C23. Bien entendu, plus le nombre de cellules est grand plus les fréquences calculées se rapprochent de ce que l'on attend en théorie. (reparler de la loi des grands nombres).

➢ La fonction liaison(argument) joue ce rôle. On simulera le fait qu'un segment fonctionne avec une probabilité p en générant un réel aléatoire entre 0 et 1. Si ce nombre est inférieur ou égal à p, on renvoie 1 et 0 sinon. On répète cette opération pour chacun des 5 segments. Il n'est pas inintéressant d'insister sur le fait qu'il faut considérer un nombre important de matrices lignes pour « calculer » la probabilité de fonctionnement du réseau.

➢ Enfin, le réseau fonctionne si et seulement si les segments L4 OU les segments L5 et L3 OU les segments L5, L2 et L1 fonctionnent. Ceci est à la base du script principal.

Essayons maintenant de trouver un lien entre p et f p . Pour ce faire, on fera fonctionner le script précédent plusieurs fois avec n=10000 en complétant le tableau suivant.

p f p

0,2 0,23710,3 0,37780,5 0,65380,7 0,88360,8 0,94680,9 0,9869

On remarque qu'à chaque test, dès lors que p≠0 ou p≠1 : f p p . On peut chercher un polynôme d'interpolation des points du graphe. Il est possible de se servir du logiciel Graph. On a f p =0,625 p21,71 p – 0,05 en se limitant au degré 2 ; f p =1,2 p31,17 p2 – 1,02 p au degré 3 et f p =1,26 p5−2,67 p40,58 p30,807 p21,02 p au degré 5. (Tiens, pourquoi 5 ?)

Courbe représentative du polynôme interpolateur de degré 5

Remarque : il ne s'agit là bien sûr que d'une démarche expérimentale. Rien n'indique a priori que la fonction f soit polynomiale et encore moins de quel degré si tel est le cas. Cependant, on est en droit de s'attendre à des résultats relativement proches de la réalité.

Solution formelle : On reprend l'analyse faite précédemment. Les différents chemins menant A à D sont : L4, L5L3 et L5L2L1. Il s'ensuit d'après les hypothèses du texte que le circuit fonctionne au cours d'une unité de temps si et seulement si l'un au moins de ces chemins est opérationnel. Fixons donc une unité de temps. Notre expérience consiste à observer le fonctionnement des 5 segments du réseau. Tous les segments ont la même probabilité p de fonctionnement. Soit X i la variable aléatoire qui prend la valeur 1 si le segment n°i fonctionne et 0 sinon. Pour tout i=1...5,

X i suit une loi de Bernoulli de paramètre p. Appelons F l'événement : « le circuit fonctionne ». F= X 4=1∪ X 5=1∩X 3=1∪X 5=1∩X 2=1∩X 1=1 .

On suppose connue la formule suivante ou on peut la re-démontrer (exercice intéressant d'ailleurs) : p A∪B∪C = p A pB pC −p A∩B−p A∩C −p B∩C p A∩B∩C .

L'appliquant avec A= X 4=1 , B= X 5=1∩ X 3=1 et C= X 5=1∩X 2=1∩X 1=1 et utilisant la mutuelle indépendance des X i (que l'on a grâce au texte), on obtient que

p F = p p2p3−p3−p4− p4p5 , soit avec les notations de l'énoncé : f p = p5−2 p4 p2 p .

Remarque : En complétant le tableau de valeurs obtenu expérimentalement auparavant, on obtient les résultats suivants :

p f p

0,2 0,23710,3 0,37620,5 0,65620,7 0,87780,8 0,94840,9 0,9882

-0.05 0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5 0.55 0.6 0.65 0.7 0.75 0.8 0.85 0.9 0.95

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

x

y

On retrouve bien heureusement des valeurs très proches de celles obtenues expérimentalement.

Question 2 : a) i) Chaque brin a deux possibilités : soit il fonctionne (S) avec la probabilité p S = , soit il ne fonctionne pas ( S ) avec la probabilité p S =1− . Il y a n brins et le fonctionnement des brins est indépendant.On en déduit que X suit la loi binomiale de paramètres n et .

a) ii) p A = 1− p A = 1−1−n soit g , n = 1−1−n . b) De la question 1 on en déduit que la probabilité que le réseau fonctionne est égale à :

h , n = 1−1−n1−1−n2−21−1−n41−1−n5 .c) script calculant h , n #fonction de fonctionnement du réseaudef reseau(beta,n): proba=(1-(1-beta)**n)**5-2*(1-(1-beta)**n)**4+(1-(1-beta)**n)**2+(1-(1-beta)**n) return (proba)

#Programme principaln=int(input("Saisir le nombre n de brins par segment "))beta=float(input("Saisir la probabilité de fonctionnement d\'un brin "))print("Le réseau fonctionne avec la probabilité de ",reseau(beta,n))

Avec n=5 et =0,25 on trouve que le réseau fonctionne avec une probabilité de 0,9257. Le parallélisme des segments offre un net gain de fiabilité !

Question 3 : a) Il y a n brins par liaison : le coût d'une liaison par unité de temps est donc égal à n . Comme il y a 5 liaisons, le réseau coûte 5n par unité de temps. • Si le réseau fonctionne (avec la probabilité h , n ) l'opérateur gagne –5n• Sinon, il perd 5n (avec la probabilité 1−h , n )

L'espérance de gain de l'opérateur est donc égale à – 5nh , n–5n1−h , n soit h , n –5n .

b) Avec =5 , =0,2 et =500 , on a : h , n–5n=5001−0,8n11−0,8n−2 1−0,8n31−0,8n4−25n .

Utilisons un tableur pour observer les valeurs prises par h , n –5n en fonction de n.

Il semble que l'espérance de gain est maximale pour l'opérateur lorsque n=6.

n

0 01 93,562 181,033 245,24 283,855 301,536 304,097 296,488 282,339 264,0410 243,1911 220,76

Espérance de gain

GEOMETRIE

TP 1 : La spirale de Pythagore

Le but est d'écrire un script utilisant une boucle de manière à obtenir la figure suivante à l'ordre voulu. La longueur AB est égale à la longueur AC et toutes deux valent 1. Les longueurs BC, CD, DE et EF sont égales.

Utilisation d'un logiciel de géométrie dynamique

Construire la figure précédente à l'aide du logiciel Geogebra. En déduire un algorithme de construction de la figure à n'importe quel rang n. Le programmer sur Geogebra. (on travaillera dans la fenêtre Protocole de construction)

Utilisation du mode turtle de Python

On donne le programme ci-dessous :

from turtle import *from math import *l1=40 #les côtés hors hypoténuse sont égaux à 40l2=sqrt(l1**2+40**2) #calcul de la longueur de l'hypoténusealpha=45n=int(input("Combien de triangles à dessiner ? "))i=1while i<=n: forward(l1) left(90) forward(40) left(90+alpha) forward(l2) left(180) l1=l2 l2=sqrt(l1**2+40**2) alpha=degrees(atan(40/l2)) #car atan renvoie une valeur en radians i=i+1

1. Quel est le résultat de ce programme ?2. Comment l'expliquez-vous ?3. Comment remédier à cela ?

Écrire un programme en Python qui :• demande à l'utilisateur de saisir le nombre n de triangles rectangles à construire.• Les construise précisément (on pourra prendre pour AB la longueur 40)

Indication : il pourra être judicieux de calculer certains angles et certaines longueurs comme les hypoténuses de chaque triangle. On peut aussi se servir de la commande goto(a,b) mais prendre garde à l'orientation de la tortue une fois qu'elle est revenue à son point de départ (pour s'en convaincre, testez-le uniquement sur la construction du premier triangle).

Corrigé du TP1

Utilisation d'un logiciel de géométrie dynamique

On donne la construction des deux premiers triangles, celle des troisièmes et quatrièmes s'effectuant de même que celle du second.

Algorithme de construction en langage naturel :

A←(0,0)B←(1,0)C←(1,1)Saisir n Pour i variant de 1 à n faire

Créer polygone [A,B,C]Créer segment [A,B]Créer segment [B,C]Créer segment [C,A]Tracer la perpendiculaire d à [C,A] passant par C Tracer le cercle e de centre C et de rayon 1. Créer le point d'intersection D de d et de e dans le demi-plan limité par (AC) ne contenant

pas B.B←CC←D

On laisse le soin au lecteur la programmation de ce script sur Geogebra. Attention, il y a quelques subtilités !

Utilisation du mode turtle de Python

1. Le résultat du programme (pourtant valide dans sa conception) ne donne pas le résultat escompté.

2. En effet, les erreurs d'arrondi se cumulent lors du calcul de alpha et de l2. Il nous faudrait plus de précision afin d'avoir un tracé « exact ». Ceci tient à la représentation des réels sous

forme de nombres flottants en simple précision. 3. Une solution pourrait être d'augmenter la précision des calculs en représentant alpha et l2

sous forme de nombres flottants en double précision ou de changer l'algorithme.

TP 2 : Un problème de lieu

Le plan est rapporté à un repère orthonormé O ;i ;j . C est un cercle de centre O et de rayon 3, H est un point du plan tel que OH = 5. On note d la perpendiculaire à (OH) passant par H. Sans perte de généralité on peut supposer le point H sur la droite (Ox).M est un point quelconque de d. On construit les tangentes issues de M en B et C au cercle C. La droite (BC) coupe (OM) en N et (OH) en I.

Question 1 : Tracer la figure à l'aide d'un logiciel de géométrie dynamique.

Question 2 : Démontrer que les droites (OM) et (BC) sont perpendiculaires.

Question 3 : Justifier les égalités suivantes :OI .OH=OM .OI=OM .ON=OM .OC=OC2=9 .

Question 4 : Que peut-on en déduire pour le point I ?

Question 5 : Sur quelle courbe le point N se déplace-t-il ?

Corrigé du TP2

Question 1La figure est construite à l'aide du logiciel Geogebra.

Question 2 Solution numériqueOn vérifie à l'aide de Geogebra que les droites (BC) et (OM) forment un angle de 90° grâce à l'outil angle, et ceci en faisant varier M sur d. Autre méthode : créer les vecteurs u=OM et v=BC puis créer le réel x(u)*y(u)+x(v)*y(v) et vérifier qu'il est toujours nul en déplaçant M sur d.

Solution formelle Par définition de B et de C : OB .BM=0 et OC .CM=0 .D'après la relation de Chasles et via les propriétés calculatoires du produit scalaire on a : OM .BC=OBBM . BMMC =OB .BMOB .MCBM .BMBM .MC .

Soit OM .BC=OCCB .MCBM 2BM .MC=CB .MCBM 2BM .MC c'est-à-dire : OM .BC=CM .MCBM 2=MB2−MC 2 .

D'autre part les triangles OBM et OCM sont respectivement rectangles en B et en C. On en déduit d'après le théorème de Pythagore que MB = MC. D'où OM .BC=0 et le résultat.

Question 3 : M se projette orthogonalement en H sur (OI) donc OM .OI=OH .OI . Par commutativité du produit scalaire OM .OI=OI .OH .

Comme les droites (OM) et (CI) sont perpendiculaires (question 2), le point I se projette orthogonalement en N sur (OM). D'où OI .OM=ON .OM . Par commutativité du produit scalaire : OM .OI=OM .ON . C appartenant à la droite (BI), orthogonale à (OM), on a OM .OI=OM .OC . Ainsi OM .OI=OM .OC=OCCM .OC=OC .OCCM .OC=0OC 2=OC 2=9 .

Question 4 : Les vecteurs OI et OH sont colinéaires de même sens d'où OI .OH=OI.OH

donc OI=95 c'est-à-dire I appartient au cercle de centre O et de rayon

95 . Comme I appartient

à l'axe des abscisses, I est le point de coordonnées 95 ;0 . Remarquons que les coordonnées de I

ne dépendent pas de celles de M.

Question 5 : (ON) et (NI) sont perpendiculaires quelle que soit la position de N. On en déduit que N se déplace sur le cercle de diamètre [OI]. On peut faire apparaître le lieu de M en activant le mode lieu de Geogebra : N lieu de M.

PS : Où intervient l'algorithmique dans ce TP ??

ANALYSE

TP 1 : Une suite d'intégrales

On considère la suite unn∈ℕ définie pour tout entier naturel n par un=∫0

1

1−t ne t dt .

Question 1 : En vous aidant éventuellement d'un logiciel de calcul formel, démontrer que pour tout entier naturel n on a : un1=−1n1un . Justifier que la suite u est bornée, positive et que

u0=e−1 .

Question 2 : On décide d'écrire un programme sous Python calculant et affichant tous les termes de la suite de u0 à un (n choisi par l'utilisateur).

from math import *n=int(input("Saisir n "))i=0u=exp(1)-1while i<=n: print(u) u=-1+(i+1)*u i=i+1

On obtient le résultat suivant : Saisir n 201.718281828460.7182818284590.4365636569180.3096909707540.2387638830170.1938194150850.1629164905120.1404154335870.1233234686980.1099112182830.09911218282550.09023401108030.08280813296320.07650572852210.07108019930910.06620298963660.0592478341860.00721318116121-0.870162739098-17.5330920429-351.661840857

Comment expliquer les résultats négatifs alors que tous les termes de la suite sont positifs ? Vous pourrez prospecter sur wikipedia à propos de la représentation d'un nombre réel par les machines ou à l'adresse http://arsene.perez-mas.pagesperso-orange.fr/numeration/reels.htm.

Question 3 (niveau L1) : En utilisant un changement de variables, prouver que un=e∫0

1

un e−u du .

En utilisant un logiciel de calcul formel tel Xcas ou Maxima, calculer les termes u0 à u20 de la suite u à l'aide de la formule précédente. Comparer avec les résultats précédents. Renseignez-vous sur ces logiciels pour expliquer ce que vous constatez.

Question 4 : Trouver une méthode autre que la programmation impérative d'une récurrence pour calculer les termes u0 à u20 de la suite u à l'aide de Python (sans augmenter sa précision de calcul).

Corrigé du TP1

Question 1 : Soit n un entier naturel quelconque, la fonction f n définie sur [0 ; 1] par f nt =1−t n et est continue (resp positive) comme produit de deux fonctions continues (resp

positives) sur [0 ; 1]. Par conséquent, l'intégrale un=∫0

1

f nt dt est parfaitement définie et

positive. D'autre part u0=∫0

1

e t dt=[et ]01=e−1 . De plus pour tout entier naturel n et pour tout

t∈[0 ;1] on a 1−t n e te t . Par croissance de l'intégrale on a donc unu0 . Ainsi pour tout n∈ℕ 0une – 1 .

un1=∫0

1

1−t n1 e t dt . Effectuons une intégration par parties en posant u t =1−t n1 et

v ' t =et . u ' t =−n11−t n et v t =e t . D'où un1=[1−t n1e t ]01n1un soit

un1=−1n1un .

Question 2 : La précision de calcul est tout simplement dépassée ! Détaillons un petit peu :

Question 3 : Posons u=1 – t . Ainsi du=−dt . Il vient en vertu du théorème de changement de

variables : un=∫0

1

1−t ne t dt=∫1

0

une1−u−du soit un=e∫0

1

un e−u du .

En utilisant Maxima, on trouve :(%i1) romberg((1-x)^18*exp(x), x, 0, 1); # calcul de u18

(%o1) 0.055394425666897(%i2) romberg((1-x)^19*exp(x), x, 0, 1); # calcul de u19

(%o2) 0.052494087217742(%i3) romberg((1-x)^20*exp(x), x, 0, 1); # calcul de u20

(%o3) 0.049881743054661

La précision de calcul est élevée et on ne retrouve pas l'erreur survenue précédemment.

Question 4 : Voilà une question bien intéressante que je laisse ouverte ! Bonne imagination cher lecteur !

TP 2 : Une équation différentielle

Soit f une fonction définie et dérivable sur [0 ; 5]. On considère l'équation différentielle suivante :( E ) : f ' x = 5 f x x2 . Le but est de trouver l'unique solution de ( E ) telle que f 0=2 .

Tracé de Cf à l'aide de la méthode d'Euler

Principe : Soit f une fonction définie et dérivable sur un intervalle I = [a ; b]. On subdivise I en N intervalles [ x0 ; x1] , [ x1, x2] , …, [ xN−1 ; x N ] que l'on supposera de même longueur. Remarque : x0=a et x N=b .Données : f x0= et une relation fonctionnelle du type f ' x=g x , f x .

Propriété et définition : Soit f une fonction définie sur un intervalle I et a un réel appartenant à I.Si f est dérivable en a, alors il existe une fonction telle que pour tout réel h, avec ah∈I :

f ah = f a h f ' ahh et limh 0h = 0 .

est appelée approximation affine de f ah lorsque h est proche de 0.

On aura donc f ah≈ f ah f ' a pour h « petit ».

Pas 1 : On sait calculer f x0 et f ' x0 . On connait donc l'équation de la tangente T 0 à C f au point d'abscisse x0 : T 0 : y= f ' x0x− x0 f x0 .

Comme on ne peut pas calculer directement f x1 , on remplace cette valeur par y1= y x1 calculé à partir de l'équation de T 0 . On obtient ainsi un point A1x1 ; y1 . Pas 2 : On fait « comme si » A1 était un point de C f de manière à réutiliser la relation liant

f x à f ' x . Ceci nous permet de calculer l'équation T 1 de la « tangente à C f » en A1 . On pose alors y2= y x 2 calculé à partir de l'expression de T 1 . On obtient ainsi un

point A2 x2 ; y2Pas suivants : on procède de la même manière de proche en proche.

Question 1 : La subdivision de [a ; b] étant régulière, on se donne k un entier compris entre 0 et N. Quelle relation lie xk à x0 , k et N ?

Question 2 : Dans cette question on suppose N = 10. Compléter le tableau suivant :

k xk yk

012

Donner l'expression de yk1 en fonction de yk .

Question 3 : Écrire un script en Python qui demande à l'utilisateur :• de saisir la valeur de N• subdivise [0 ; 5] en N intervalles de mêmes longueurs• Trace approximativement la courbe de f en utilisant la méthode d'Euler décrite ci-dessous.

Tester ce programme avec N=10 puis N=100.

Remarque : si vous utilisez numpy vous pouvez vous servir de la commande linspace pour créer la subdivision.

Étude théorique

Question 1 : On pose E0 : f ' x=5 f x . A l'aide du cours ou d'un logiciel de calcul formel, résoudre l'équation E0 .

Question 2 : Prouver que la fonction p définie sur [0 ; 5] par p x =−15

x2− 225

x− 2125 est une

solution de ( E ).

Question 3 : Soit f une fonction définie et dérivable sur [0 ; 5]. Prouver que f est solution de ( E ) si et seulement si f − p est solution de E0 .

Question 4 : Répondre alors au problème posé. Vous tracerez la courbe représentative de f avec l'expression exacte de cette fonction.

Corrigé du TP2

Tracé de Cf à l'aide de la méthode d'Euler

Question 1 : Pour tout entier k compris entre 0 et N on a : xk=x0k b−aN .

Question 2 : On sait que f ' x=5 f x x2 et que f 0=2 . Cette dernière relation nous donne immédiatement y0=2 . Calcul de y1 : La tangente T 0 à C f au point d'abscisse 0 a pour équation :

y= f ' 0 x f 0. . Sachant que f 0=2 et que f ' x=5 f x x2 . On obtient immédiatement f ' 0=10 et donc : T 0 : y=10 x2 .

Comme N = 10, x1=0 510 ie x1=0,5 . Par construction y1=10×0,52=7 .

Calcul de y2 : Par construction on a y2=5 y1 x12x2 – x1 y1 . (on a remplacé f x1

que l'on ne peut pas calculer directement par y1 et f ' x1=5 f x1 x12 par 5 y1 x1

2 ). On trouve y2=5×70,52×0,57 soit y2=24,625 avec bien sûr x2=1 .

Test avec un tableur

On saisit dans la cellule C3 la formule =(5*C2+PUISSANCE(B2;2))*0,5+C2 que l'on recopie verticalement pour compléter la colonne C. La relation de récurrence liant yk1 à yk est : yk1=5 yk xk

2×0,5 yk 0kN−1 . Ceci donne une piste sérieuse pour concevoir l'algorithme sous Python. Cependant, comme le but est de tracer un graphe, on aura besoin de créer deux matrices lignes, la première donnant les abscisses des points à tracer et la seconde leurs ordonnées.

Remarque : on peut aussi programmer ceci de manière récursive. On travaille ici sous la version 2.6

Question 3 : import matplotlib.pyplot as plt

N=int(raw_input("Combien de subdivisions ? "))i,x,y=1,0,2listex,listey=[x],[y]while i<=N:

k x_k y_k0 0 21 0,5 72 1 24,633 1,5 86,694 2 304,535 2,5 1067,866 3 3740,637 3,5 13096,718 4 45844,639 4,5 160464,1910 5 561634,81

Cellule C2

y=(5*y+x**2)*5./N+y #on change d'abord la valeur de y listey.append(y) #avant celle de x x=x+5./N listex.append(x)

i=i+1

plt.plot(listex,listey)plt.show()

Pour N=10 on obtient le graphique suivant :

Remarque : on ne sait a priori rien de la précision de ce tracé (L'étude de l'erreur est totalement hors-programme). L'étude théorique nous permettra de connaître l'expression exacte de f x .

Étude théorique

Question 1 : Les solutions de E0 sont les fonctions f C définies sur [0 ; 5] par f C x =C e5 x .

Question 2 : Il est clair que p ' x=−25

x− 2125 . Un simple calcul permet alors de vérifier que

p ' x=5 p x x2 . Ainsi p est solution de (E).

Question 3 : Nous allons raisonner par double-implication. Soit f une fonction définie et dérivable sur [0 ; 5]. ( ⇒ ) Supposons que f est solution de (E). Alors pour tout réel x appartenant à [0 ;5] on a :

f ' x=5 f x x2 . D'autre part comme p est une solution de (E) on a : p ' x=5 p x x2

On en déduit que f ' x– p' x=5 f x – 5 px , soit f −p ' x =5 f −p x sur [0 ; 5]. Donc f – p est solution de ( E0 ). ( ⇐ ) Réciproquement, supposons que f – p est solution de ( E0 ). Alors pour tout réel x appartenant à [0 ; 5] on a : f −p ' x =5 f −p x soit f ' x– p' x=5 f x – 5 px . Or p est solution de (E) donc p ' x=5 p x x2 . Un calcul rapide aboutit alors à

f ' x=5 f x x2 . Donc f est solution de (E).

Question 4 : On déduit immédiatement des questions 1 et 3 que les solutions de (E) sont les

fonctions définies sur [0 ;5] par f x =C e5 x – 15

x2 – 225

x− 2125

C∈ℝ . Comme f 0=2 on

a C=2 2125

, soit C= 252125 . Finalement f x =252

125e5 x – 1

5x2 – 2

25x− 2

125 .

En utilisant le logiciel Graph, on obtient la courbe suivante :

Comparer avec les valeurs obtenues avec la méthode d'Euler pour N = 10. Tester ensuite le tracé avec la méthode d'Euler pour N=100 puis N=1000. Conclusion.

-0.5 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5

2E10

4E10

6E10

8E10

1E11

1.2E11

x

y

ARITHMETIQUE

TP 1 : Algorithmes classiques

Question 1 : Écrire un algorithme qui demande à l'utilisateur :• de saisir un entier naturel n• et qui détermine si cet entier est premier ou non.

Indication : Un entier naturel n est premier si n1 et si n n'a pour diviseurs que 1 et lui-même.

Question 2 : Modifier l'algorithme précédent pour construire une liste contenant tous les nombres premiers inférieurs ou égaux à 100.

Question3 : Écrire un programme en Python qui demande à l'utilisateur :• de saisir un entier naturel n inférieur ou égal à 10000• et qui renvoie la décomposition de n en facteurs premiers.

Indication : Il suffit de chercher tous les diviseurs premiers inférieurs ou égaux à n .

Question 4 : Écrire un programme en Python qui étant donné deux entiers naturels a et b renvoie leur PGCD. Vous utiliserez l'algorithme d'Euclide.

Question 5 : Modifier le programme précédent pour déterminer deux entiers relatifs u et v tels que a ub v=d où d désigne le PGCD de a et de b.

Application : résoudre sur ℤ2 l'équation 13 x – 84 y=1

Corrigé du TP1

Question 1 :

Algorithme Avec PythonÉcrire « Saisir un entier naturel n »lire ni←1j←0Tant que i<=n faire Si n est divisible par i faire j←j+1 Fin Si i←i+1Fin Tant queSi j=2 faire écrire n, « est premier »Sinon faire écrire n, « n'est pas premier »Fin Si

# on va définir une fonction est_premier(n)

def est_premier(n): i,j=1,0 while i<=n: if n%i==0: j=j+1 i=i+1 if j==2: print(n,"est premier") else: print(n,"n\'est pas premier")

Remarque : le compteur j est incrémenté d'une unité dès lors que i entier entre 1 et n, divise n. Si une fois sorti de la boucle j est égal à 2 (ce qui signifie que n n'a que deux diviseurs), alors on peut conclure à la primalité de n.

Question 2 :

Algorithme Avec PythonÉcrire « Saisir un entier naturel n »lire nliste←liste videPour k variant de 1 à n faire i←1 j←0 Tant que i<=k faire Si k est divisible par i faire j←j+1 Fin Si i←i+1 Fin Tant que Si j=2 faire ajouter k à liste Fin SiFin Pour

Afficher liste

# on va définir une fonction liste_premiers(n)# cette fonction va créer la liste de tous les nombres premiers inférieurs ou égaux à n.

def liste_premiers(n): global liste # de manière à la réutiliser dans le programme principal à la question 3 liste=[] for k in range(1,n+1): i,j=1,0 while i<=k: if k%i==0: j=j+1 i=i+1 if j==2: liste.append(k)

return(liste)

Remarque : on a mélangé ici les deux types de boucles mais ce n'était pas nécessaire.

Question 3 : Il convient de s'arrêter un instant sur la décomposition en facteurs premiers d'un entier naturel (non nul). C'est sa mise en œuvre « à la main » qui va donner l'idée du programme. On rappellera par ailleurs quelques résultats élémentaires d'arithmétique. Commençons par une remarque : On sait que tout entier naturel n>1 admet au moins un diviseur premier p. Le résultat qui suit est plus précis : Soit n>1 un entier naturel. Alors n est composé (c'est-à-dire non premier) si n admet un diviseur premier pn . Pour déterminer si un entier n est composé, on testera tous les nombres premiers compris entre 2 et n . On doit pour cela disposer de tous les nombres premiers appartenant à [2 ;n ] mais ceci

a été résolu à la question précédente. Cahier des charges : on aura besoin de deux listes : une constituée des nombres premiers p entrant dans la décomposition de n (d'où une instruction conditionnelle pour les repérer) et une autre constituée des exposants de chacun de ces nombres premiers (d'où une boucle : Tant que n est divisible par p on remplace n par n/p, et ceci pour chacun des facteurs premiers de la première liste : d'où une autre boucle). La dernière valeur prise par n est alors soit 1 soit un nombre premier. D'où le programme suivant :

n=int(input("Saisir un entier n inférieur ou égal à 10000 "))liste_premiers(100)decomposition,puissance=[],[]i=0while i<len(liste): j=0 if n%liste[i]==0: decomposition.append(liste[i]) # construction de la liste des facteurs premiers while n%liste[i]==0: j=j+1 n=n/liste[i] # n est alors converti en flottant puissance.append(j) # construction de la liste de leurs exposants i=i+1print("décomposition de n en facteurs premiers :")i=0while i<len(decomposition): print(decomposition[i],"^",puissance[i],end="") i=i+1print(int(n)) # pour que n soit affiché en entier

Remarque : cet algorithme, bien que répondant au problème posé est relativement couteux en temps. Heureusement, des tests de primalité beaucoup plus efficaces que celui de la question 1 existent et réduisent énormément le temps de calcul.

Question 4 : L'algorithme d'Euclide repose sur l'égalité suivante : PGCD(a,b) = PGCD(b,r) où r est le reste de la division Euclidienne de a par b. Son détail est dans tous les bons manuels. Pour simplifier, on supposera a>b. En Python on obtient le programme suivant :

a=int(input("Saisir le plus grand des deux entiers naturels a"))b=int(input("Saisir le plus petit des deux entiers naturels b"))r=a%bwhile r!=0: a=b b=r r=a%bprint("Le PGCD de ",a,"et de ",b,"vaut ",b)

Question 5 : Nous allons modifier l'algorithme précédent de manière à trouver deux entiers relatifs u et v tels que au+bv = PGCD(a,b). Cet algorithme qu'on appelle algorithme d'Euclide étendu peut être réalisé en faisant d'abord le travail « à la main ». Par exemple, déterminons le PGCD de 38 et de 144. ( 1 ) 144=38×330 a0=b0×q1r1 où a0=a et b0=b . ( 2 ) 38=30×18 b0=r1×q2r 2 où a1=b0 et b1=r1 . ( 3 ) 30=8×36 r 1=r 2×q3r 3 où a2=b1 et b2=r 2 . ( 4 ) 8=6×12 r 2=r3×q4r 4 où a3=b2 et b3=r3 .( 5 ) 6=2×30 r 3=r 4×q5r5 où r 5=0 . Le PGCD de 38 et de 144 est le dernier reste non nul, soit r 4=2 . Exprimons r 4 en fonction de a0 et de b0 par une méthode de remontée.

r 4=r2 – r3×q4=8−6×1 . Or 8=38−30=38 – 144 –38×3=38×4 – 144 . Puis 6=30– 8×3=144 –38×3−38−30×3=144 –38×6144−.38×3×3=144×4−38×15 .

Finalement r 4=144×−538×19 . Le couple u , v =−5,19 est une solution de l'équation diophantienne 144 x38 y=2 .

Exprimé uniquement à l'aide de r i et de q i : r i1=r i−1−r i×q i1 (*).

Analyse : on va construire deux suites unn1 et vnn1 telles que r n=a unb vn . Si N est le dernier indice tel que r N≠0 alors on aura trouvé les coefficients voulus (car

r N=PGCD a ,b ). • On a r 1=a – q1×b , soit u1=1 et v1=−q1 . • On a r 2=b – r1×q2=b – a−b×q1×q2=a×−q2b×1q1 q2 , soit u2=−q2 et

v2=1q1 q2 . • De la relation (*) on en déduit que :

r n2=rn1 – rn×qn1=a un2bv n2=a×un1 – un qnbvn1 – vn qn1 .

D'où {un2=un1−un qn1

u1=1 ; u2=−q2 } et { vn2=vn1−v n qn1

v1=−q1 ; v2=1q1 q2}Cette relation nous mène à l'algorithme suivant où l'on va créer et se servir de la liste donnant les différentes valeurs des quotients q i . La notion d'affectation parallèle permet de traiter ce problème de manière simple et efficace. ATTENTION au décalage d'indice dans les listes. Le premier élément d'une liste se note liste[0]. Ainsi N = len(liste_restes)-2.

a=int(input("Saisir le plus grand des deux entiers naturels a "))b=int(input("Saisir le plus petit des deux entiers naturels b "))if a%b==0: print("u= ",0,"et v= ",1) #car alors PGCD(a,b)=belse: r=a%b q=int((a-r)/b) # on peut aussi utiliser la division entière: q=a//b liste_restes,liste_quotients=[r],[q] while r!=0: a=b b=r r=a%b q=int((a-r)/b) liste_restes.append(r) # la construction de cette liste est facultative liste_quotients.append(q) print(b,liste_restes,liste_quotients)

# on construit les suites (u_n) et (v_n)

i=1 u,v=1,-liste_quotients[1] while i<=len(liste_restes)-2: # on peut remplacer liste_restes par liste_quotients u,v=v,u-v*liste_quotients[i+1] i=i+1

print("u= ",u)

j=1 w,t=-liste_quotients[0],1+liste_quotients[0]*liste_quotients[1] while j<=len(liste_restes)-2: w,t=t,w-t*liste_quotients[j+1] j=j+1

print("v= ",w)

Remarque : L'algorithme générique pour calculer et afficher les termes d'une suite définie par un2= f un , un1 avec u1=a et u2=b peut s'écrire ainsi en Python :

u,v,i=a,b,1n=int(input("Saisir n "))while i<n: print(u) u,v=v,f(u,v) # spécificité Python ! i=i+1

Le principe de l'affectation parallèle, à savoir évaluer d'abord les valeurs des variables dans le membre droit de l'égalité avant de les affecter aux variables du membre de gauche permet l'économie de variables auxiliaires et réduit le script.

TP 2 : Bases et conversion

Question 1 : Écrire un programme qui demande à l'utilisateur de saisir un entier naturel n écrit en base 10 et renvoie son écriture en binaire (base 2).

Question 2 : Modifier le script précédent pour convertir n dans n'importe quelle base a avec1a10 choisie par l'utilisateur.

Question 3 : Écrire un programme qui génère un entier aléatoire écrit en base a ( 1a10 ) choisie par l'utilisateur et qui le convertit dans une autre base b ( 1b10 ) également choisie par l'utilisateur.

Corrigé du TP2

Question 1 : Traitons un exemple concret pour avoir une idée de l'algorithme.

Tout entier naturel n s'écrit en base 10 sous la forme : n=∑i=0

∞

a i 10i où les a i sont presque tous

nuls (tous sauf un nombre fini d'entre eux). Pour tout i 0a i9 .

En base 2, le même entier naturel n s'écrit n=∑j=0

∞

b j 2j où les b j sont presque tous nuls. Le but

est donc d'exprimer n comme somme de coefficients multiplicateurs de puissances de 2. Pour ceci, on effectuera des divisions euclidiennes successives et on observera les restes.

Exemple : écrire 106 en base 2.

on remonte pour obtenir l'écriturebinaire de 106

106=53×2053=26×2126=13×2013=6×216=3×203=1×211=0×21

Ainsi, en base 2 106 s'écrit 1101010

106 2

530 2

261 2

130 2

61 2

30 2

1 1 2

01

On en déduit l'algorithme qui suit :

N,liste=int(input("Saisir un entier en base 10 ")),[]if N==0: print("En base 2 N =0")elif N==1: print("En base 2 N = 1")else: while N>=1: liste.append(N%2) N=N//2

i=len(liste)-1print("En base 2 N s\'écrit : ")while i>=0: print(liste[i],end="") i=i-1

Question 2 : On modifie légèrement le script précédent :

a=int(input("Saisir la base choisie a (1<a<=10) pour convertir votre entier en base 10 "))N,liste=int(input("Saisir un entier en base 10 ")),[]if N==0: print("En base a N =0")elif N==1: print("En base a N = 1")else: while N>=1: liste.append(N%a) N=N//a

i=len(liste)-1print("En base a N s\'écrit : ")while i>=0: print(liste[i],end="") i=i-1

Question 3 : On peut procéder de plusieurs façons.• Raisonner directement comme cela a été fait dans les questions précédentes.• Passer par l'intermédiaire de la base 10.

ATTENTION : il y a quand même une difficulté : comment générer avec Python un entier aléatoire dans une base a choisie par l'utilisateur. Par soucis de simplification d'écriture, on s'est limité à

1a10 , mais la problématique est la même. Rappelons que tout entier n écrit en base a s'écrit

sous la forme n=∑i=0

∞

i ai où les i sont presque tous nuls.

Bibliographie

Gérard Swinnen : Apprendre à programmer avec Python 3 – aux éditions Eyrolles

Bob Cordeau : Introduction à Python – notes de cours et TP à l'IUT de mesures physiques d'Orsay

Documents d'accompagnement des programmes de seconde 2000 et 1ère S 2011.

RMS – Chapitres de mathématiques concrètes

ALGORITHMIQUE AU LYCEE - Créer un blog gratuitement sur...

Documents

Transcript of ALGORITHMIQUE AU LYCEE - Créer un blog gratuitement sur...