1

Exercices d’informatique pour la 2e B

Exercice 1 : année bissextile

Ecrire un programme qui détermine si une année a introduite par l'utilisateur est

bissextile ou non. Depuis l'instauration du calendrier, sont bissextiles les années soit

divisibles par 4 mais non divisibles par 100, soit divisibles par 400. Par exemple : 2012,

2016, et 2000 sont bissextiles mais 2001, 2002 et 2100 ne le sont pas.

Exercice 2 : nombre et signe des racines Ecrire un programme qui détermine le nombre et le signe des racines d'une équation

du 2e degré 2 0ax bx c , sans calculer les racines. On pourra supposer que

0a et on discutera en fonction du discriminant , du produit P et de la somme S

des racines.

Exercice 3 : équation du 1er degré Ecrire un programme qui permet de résoudre une équation du premier degré du type :

a x b c x d , d’inconnue x. Les coefficients réels a, b, c et d seront entrés au

clavier par l’utilisateur et stockés dans des variables de même nom. Ensuite le

programme devra analyser si l’équation a une solution unique et afficher cette

solution le cas échéant. Dans le cas où l’équation n’a pas de solution ou une infinité

de solutions, l’utilisateur en sera également informé correctement.

Exercice 4 : triangles Ecrire un programme triangles qui demande à l’utilisateur d’entrer les longueurs

(réels positifs) des trois côtés d’un triangle.

• Si la longueur d’un côté est ≥ la somme des longueurs deux autres côtés alors le

triangle n’existe pas et le programme doit en informer l’utilisateur.

• Sinon le triangle existe le programme doit déterminer de quel type de triangle il

s’agit : équilatéral, rectangle, isocèle, rectangle isocèle ou scalène (c.-à-

d. dont les trois côtés ont des longueurs distinctes).

2

Exercice 5 : intersection de droites Ecrire un programme qui demande à l’utilisateur d’étudier la position relative de

deux droites d1 et d2 du plan rapporté à un repère cartésien. On suppose que les

équations cartésiennes des droites sont de la forme 1 1 1a x b y c et

2 2 2a x b y c . Il suffit donc de demander à l’utilisateur de préciser les coefficients

(réels) a1, b1, c1, a2, b2 et c2 des deux équations.

Si 1 1 0a b ou 2 2 0a b , le programme affichera le message : « Equation non

valide » et se terminera.

Sinon le programme devra analyser si les deux droites d1 et d2 sont sécantes (et il

affichera alors les coordonnées de leur point d’intersection) ou si les deux droites sont

strictement parallèles ou alors si elles sont confondues. Utiliser la méthode des

déterminants de Cramer, vue en 3e.

Exercice 6 : suites - while

Ecrire un programme qui écrit à l’écran les suites d’entiers commençant par les nombres

donnés, aussi longtemps que le terme de la suite reste inférieur à une limite donnée par

l’utilisateur. Déterminer aussi le nombre de termes affichés de chaque suite.

(1) 1 , 3, 6, 8, 16, 18, 36, 38, 76, … (+2, puis 2 , …)

(2) 1 , 6, 16, 36, 76, … (+2 puis 2 en une étape, …)

(3) 1, 8, 3, 24, 19, 152, 147, … ( 8 , puis –5, …)

(4) 1, 3, 19, 147, … ( 8 puis –5 en une étape …)

(5) 0, 1, 1, 2, 3, 5, 8, 13, 21, …. (suite de Fibonacci)

(6) 2, 1, 3, 4, 7, 11, 18, …. (suite de Lucas, même principe)

(7) 1, 0, 100, 50, 150, 75, 175, 87, 187, … (// 2, puis +100)

Exercice 7 : suites - for A l’aide de boucles for écrire un

programme qui produit l’écran-sortie ci-

contre. Remarque : pour représenter un

entier n de sorte qu’il occupe 5 colonnes

sur l’écran (à partir de la droite) on utilise

la méthode format :

‘{:5d}’.format(n) (voir https://docs.python.org/3.6/library/string.html 6.1.3)

3

Exercice 8 : maximum et minimum de réels Ecrire un script qui affiche le plus grand et le

plus petit nombre d'une suite de nombres réels

positifs entrés au clavier par l'utilisateur. Le

programme se termine si l'utilisateur entre –1 ou

un autre réel négatif. (–1 ne fait pas partie de la

suite.)

Exercice 9 : nombre secret à deviner Ecrire un script qui choisit au hasard un entier

naturel secret compris entre 1 et 100 et qui

demande à l'utilisateur de deviner cet entier

naturel. Le programme informera le joueur à

chaque essai si le nombre secret est > ou < que

le nombre entré. Lorsque le joueur aura deviné le

nombre correct, le programme le félicitera. De

plus :

a) Pour signaler qu'il n'a plus envie de jouer en

cours d'une partie, le joueur entrera 0 au clavier.

Le programme affichera alors le nombre secret et

la partie se termine et le programme affichera le

nombre secret.

b) Après chaque partie, le programme demandera au joueur s'il veut faire une nouvelle

partie et le joueur entrera le caractère 'o' pour oui, 'n' pour non.

Remarque : Etant donnés deux entiers a et b tels que a b , la fonction

random.randint(a,b) retourne un entier aléatoire au hasard dans l’intervalle [a,b].

Il faut importer le module random pour l’utiliser.

Exercice 10 : somme des chiffres / nombre renversé Ecrire deux scripts qui permettent respectivement :

a) de calculer la somme des chiffres d’un entier donné

b) de renverser un entier donné, par exemple 1234 devient 4321.

4

Exercice 11 : motifs étoilés Réaliser un projet avec des scripts permettant de représenter respectivement chacun

des motifs étoilés ci-dessous.

a) Rectangle :

b) Bordure :

c) Escalier descendant :

d) Escalier ascendant :

e) Escalier double :

f) Diamant : seulement pour n

impair

g) Croix : différence entre les

cas n pair ou impair.

5

h) Damier 1 i) Damier 2

Exercice 12 : série harmonique

Pour n , on définit : 1 1 1

1 ...2 3n

un

.

Trouver le plus petit entier n tel que 10n

u . (La suite ( )n

u est appelée série

harmonique : elle diverge, c.-à-d. la limite de n

u , lorsque n est .)

Exercice 13 : algorithme d’Héron

Ecrire un programme qui implémenter l’algorithme d’Héron (d’Alexandrie) pour

calculer la racine carrée d’un nombre réel positif a donné. Pour cela, on demande à

l’utilisateur d’entrer le réel a et un réel 0

0u quelconque : 0

u est le premier terme de

la suite de Héron. De plus l’utilisateur peut choisir une précision 0 avec laquelle il

souhaite calculer a . La suite de Héron est alors définie récursivement par:

11

12n n

n

au u

u

, pour 1n .

On demande de calculer et d’afficher tous les termes de cette suite tant que la différence

(en valeur absolue) de deux termes successifs soit . Par exemple pour calculer 2

on part par exemple de 0

1u , alors 31 2

1, 5u , 172 12

1, 41666...u ,577

3 409=1,414215686...u etc. Remarquer que la suite converge toujours très vite.

N.B. Pour que les cases soient plus « carrées »,

afficher des suites de ‘* ’ (avec un espace) au lieu

de ‘*’.

6

Exercice 14 : suite de Collatz Ecrire un programme qui affiche la suite de Collatz pour un entier naturel non nul

donnée. Cette suite est définie de la manière suivante :

On part d'un entier naturel non nul ; s’il est pair, on le divise par 2 ; s’il est

impair, on le multiplie par 3 et on ajoute 1. En répétant l’opération, on obtient

une suite récurrente, c.-à-d. une suite d'entiers positifs dont chacun ne dépend

que de son prédécesseur. Par exemple, à partir de 14, on construit la suite des

nombres : 14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1. La suite

s'arrête si on tombe sur 1.

Le programme devra aussi afficher le nombre de termes de la suite.

On conjecture mais on n'a pas démontré jusqu'à aujourd'hui que la suite de Syracuse

se termine pour chaque entier naturel.

Exercice 15 : listes Les questions ci-dessous sont indépendants. On écrira un script par question.

(1) Ecrire un script qui permet de renverser l’ordre des éléments d’une liste

d’entiers entrée par l’utilisateur sans utiliser la méthode reverse. Il est

interdit dans la programmation d’utiliser une deuxième liste, on modifiera donc

la liste originale. Exemple d’exécution :

(2) A partir de deux listes d’entiers données, par exemple li1 = [4,7,3,8] et

li2 = [1,5,8,0,2,4,0], on demande de créer et d’imprimer sur l’écran la

liste « tirette », à savoir : li = [4,1,7,5,3,8,8,0,2,4,0]. Le script

copiera donc dans li alternativement les éléments de li1 et de de li2 (en

commençant toujours par li1), jusqu’à ce que l’on ait atteint la fin de la liste la

plus petite. Ensuite les éléments restants de la liste la plus longue sont ajoutés à

li.

(3) Ecrire un script qui demande à l’utilisateur d’entrer un entier naturel non nul. Le

script place alors tous les entiers de 1 à n dans une liste, dans un ordre aléatoire.

Attention : Chaque entier devra figurer une seule fois dans la liste. Par exemple

7

si n = 5, la liste obtenue pourrait être [3,1,4,2,5]. On pourra importer le module

random, mais on utilisera uniquement la fonction randint de ce module.

(4) Ecrire un script qui permet d’enlever les éléments répétés (doubles) d’une

liste donnée d’entiers. Pour chaque élément répété, on affichera le nombre

d’occurrences dans la liste originale. Consignes à respecter : a) La 1re

occurrence d’un élément répété doit rester dans la liste, les autres exemplaires de

cet élément doivent être enlevés. b) Il est interdit dans la programmation d’utiliser

une deuxième liste, on modifiera donc la liste originale en utilisant par exemple

del ! Voici un exemple d’exécution :

(5) Ecrire un script dans lequel l’ordinateur choisit au hasard une liste strictement

croissante de 3 entiers a, b et c compris entre 1 et 100, par exemple

[14,27,56]. Le programme demande ensuite à l’utilisateur d’entrer

successivement des entiers positifs, qui sont alors insérés dans la liste de telle

façon qu’elle reste croissante. La nouvelle liste sera affichée après l’initialisation

et après chaque insertion. Lorsque l’utilisateur entre un entier < 0, l’exécution

s’arrête. Exemple d’exécution :

8

(6) Ecrire un script qui permet de générer la liste de tous les nombres premiers jusqu’à

un entier n donné par l’utilisateur. On utilisera l’algorithme du crible

d’Erathosthène :

• d’abord on met dans la liste tous les entiers de 2 jusqu'à n.

• On garde 2 (premier élément) et on élimine tous les autres multiples de 2.

• On garde 3 qui est le premier élément non éliminé après 2 et on élimine

tous les autres multiples de 3.

• On garde 5 qui est le premier élément non éliminé après 3 et on élimine

tous les autres multiples de 5.

• On réitère ce procédé jusqu'à la partie entière de la racine de n.

Les nombres non éliminés sont alors les nombres premiers n .

Pour les « pros » : On essaiera d’écrire un script qui permet de trouver tous les nombres premiers

jusqu’à 1'000'000 dans un temps raisonnable (< 30 secondes). Pour mesurer le temps d’exécution d’un

script, on pourra importer la fonction time du module time. L’instruction t=time() donne le temps

actuel de la machine.

(7) Ecrire un script qui permet de simuler une suite de lancers d’un dé, jusqu’à

l’apparition du ne 6, n étant donné par l’utilisateur. Les résultats des lancers

seront stockés dans une liste et seront écrits sur l’écran dans une ligne. Par

exemple, pour n = 3, on pourra obtenir :

dice = [3,4,1,2,2,6,3,5,5,4,3,3,2,1,6,6]

a) Ecrire une fonction throws_until_6 qui compte le nombre de lancers entre

deux 6 successifs (respectivement jusqu’au premier 6). La valeur de retour

de cette fonction sera une liste avec les n résultats du comptage, donc [7,9,1]

pour l’exemple ci-dessus.

b) Ecrire une fonction qui permet de répéter l’expérience : « lancer le dé

jusqu’à l’apparition du 1er 6 » un grand nombre de fois (paramètre) et qui

retourne le nombre moyen de lancers de cette expérience.

(8) On donne une liste d’entiers, par exemple [1,2,3,3,4,5,4,4,3,2,6,8,9,12,5,14]. Ecrire

une fonction split_list qui scinde cette liste en sous-listes croissantes

respectivement décroissantes. Pour l’exemple ci-dessus, la valeur de retour de la

fonction est :

[ [1,2,3,3,4,5], [5,4,4,3,2], [2,6,8,9,12], [12,5], [5,14] ].

En déduire une fonction qui permet de déterminer la plus longue sous-suite

croissante de la liste donnée d’entiers, sans utiliser max.

9

(9) Ecrire un script qui permet de rechercher tous les maxima et minima locaux d’une

liste d’entiers aléatoire, dont les éléments peuvent varier entre 0 et 1000. Par

définition, un maximum local (resp. minimum local) de la liste est un élément n

de la liste dont les deux voisins (ou le seul voisin) sont n (resp. n ). Les

maxima et minima locaux seront stockés dans une nouvelle liste.

Exercice 16 : une histoire de lampes 276 lampes sont numérotées de 1 à 276. Pour passer le temps, 25 enfants appuient sur

les interrupteurs à tour de rôle. Le premier enfant presse chaque interrupteur. Le second

presse les boutons 2, 4, 6, etc. (tous les boutons ayant un numéro multiple de 2), le

troisième appuie sur les boutons 3, 6, 9, etc. Le quatrième presse tous les boutons ayant

un numéro multiple de 4, et ainsi de suite jusqu'au 25e enfant.

Avant le passage du premier enfant, toutes les ampoules sont éteintes. Combien

d'ampoules seront allumées après le passage des 25 enfants ? (Défi Turing, problème

90, voir http://www.nymphomath.ch/turing/enonces.php)

Exercice 17 : suites palindromiques Un nombre palindromique (ou palindrome) est un entier naturel qui reste le même

qu’on le lise de droite à gauche ou de gauche à droite. Par exemple : 47374, 101, 6 et

9449 sont des palindromes.

Partant d’un entier naturel quelconque N, on obtient la suite palindromique associé

à cet entier de la manière suivante :

• On inverse l’ordre des chiffres de N et on ajoute N à ce nombre inversé.

• On recommence l’opération avec le nouveau nombre jusqu’à ce qu’on obtienne

un palindrome.

Exemples :

N Suite palindromique

13 13, 44

29 29, 121

1048 1048, 9449

64 64, 110, 121

87 87, 165, 726, 1353, 4884

89 89, 187, 968, 1837, … , 8813200023188 (24 étapes en tout !)

196 196, 887, 1675, … (suite infinie ??)

10

On ne sait pas à ce jour si la suite palindromique de 196 se termine par un palindrome

ou non, même après plus de 700 millions d’itérations de renversement-addition …

Ecrire un script qui, à partir d’un entier naturel N donné détermine et affiche sa suite

palindromique. On utilisera une fonction qui permet de calculer le terme suivant de la

suite palindromique, pour un terme donné. Le programme devra s’arrêter lorsque le

nombre d’éléments de cette suite dépasse une limite que l’utilisateur pourra fixer. Pour

plus d'informations, voir http://www.jasondoucette.com/worldrecords.html.

Exercice 18

Ecrire un programme qui simule un jeu de pile ou face : avant de commencer le jeu, le

joueur entrera son capital de départ (entier). A chaque partie, le programme demande

au joueur de choisir sa mise et d'entrer 'P' s'il décide de miser sur 'Pile', 'F' s'il

décide de miser sur 'Face'. Le programme contrôle ensuite si la mise pariée n'est pas

plus élevée que le capital restant du joueur (auquel cas il demande d'entrer une nouvelle

mise), puis il choisit au hasard l'un des deux entiers 0 (correspondant à 'Pile') ou 1

(correspondant à 'Face'). Si le joueur a correctement deviné, sa mise est ajoutée à son

capital, sinon elle est retranchée du capital. Le programme se termine soit si le joueur

n'a plus d'argent, soit s'il décide d'arrêter lui-même de jouer.

Exercice 19 Ecrire : a) Une fonction phi qui pour un entier naturel non nul n, retourne le nombre

d’entiers m tels que pgcd( , ) 1m n . b) Une fonction diviseurs qui compte pour un

entier naturel non nul n donné, le nombre de diviseurs de n. c) Une fonction sigma

qui calcule, pour un entier n donné, la somme de tous les diviseurs de n.

11

Exercice 20 Ecrire un programme qui demande à l’utilisateur deux mots contenant exactement un

trait d’union et qui intervertit et écrit à l’écran les deux parties derrière les traits

d’union. Donc par exemple : croque-monsieur et porte-avions deviennent

respectivement croque-avions et porte-monsieur.

Exercice 21 Ecrire une procédure delChar qui enlève toutes les occurrences d’une lettre donnée

d’une chaîne de caractères. Par exemple, si s := ‘informatique’ et si on écrit

l’appel delChar(‘i’,s) alors la variable s sera transformée en ‘nformatque’. On

demande d’utiliser la procédure prédéfinie delete.

Exercice 22 Ecrire une fonction countChar qui compte le nombre de lettres distinctes dans une

chaîne de caractères. Par exemple : countChar(‘mathematiques’) retourne 9.

Exercice 23 Ecrire une fonction avecEspaces qui insère entre deux lettres successives d’un mot

donné un espace. Par exemple : avecEspaces(‘info’) = ‘i n f o’. On demande

d’utiliser la procédure prédéfinie insert.

Exercice 24 Ecrire une fonction motAleatoire qui prend en entrée un mot et qui retourne un

mot formé exactement des mêmes lettres, mais dans un ordre aléatoire. Par exemple :

motAleatoire(‘informatique’) = ‘utonirafqmei’.

Exercice 25 a) Ecrire une fonction toDecimalHours qui prend en entrée une durée de type

string et dans le format ‘…h…m…s’ (heures, minutes, secondes) et qui retourne cette

durée en heures décimales. Par exemple : toDecimalHours (‘5h30m’)=5,5h.

b) Ecrire la fonction réciproque toHMS de la fonction précédente.

Exercice 26

12

Ecrire une fonction booléenne testParentheses qui vérifie si les parenthèses dans

un string représentant une expression mathématique sont correctement placées. On ne

demande pas de vérifier la syntaxe des autres opérations. Par exemple :

testParentheses('(3+4x)*(8x-5)-(2*(x-3)-x)') = true testParentheses('3+(4x*(8x-5)-(2*(x-3)-x)') = false

testParentheses('3+4x*8x-5-(2*(x-3)-x))') = false Exercice 27 Ecrire une fonction alphabeticString qui prend en entrée un caractère majuscule

et un entier n non nul et qui retourne le string formé de n lettres successives de

l’alphabet et commençant avec la lettre fournie par l’utilisateur. Si on dépasse la lettre

‘Z’, on recommence cycliquement avec ‘A’. Par exemple :

alphabeticString(‘T’,5)=‘TUVWX’ alphabeticString(‘X’,8)=‘XYZABCDE’ alphabeticString(‘Z’,28)=‘ZABCDEFGHIJKLMOPQRSTUVWXYZA’

13

Exercice 28 Ecrire un programme qui demande à l'utilisateur d'entrer autant de mots qu'il veut.

Lorsque l'utilisateur entre un '.', le programme forme une phrase en concaténant tous

les mots entrés dans l'ordre et en les séparant par un espace. La phrase écrite à l'écran

devra se terminer par un point.

Exercice 29 Ecrire les fonctions booléennes suivantes :

(1) Une fonction palindrome qui teste si une chaîne de caractères donnée est un

palindrome, c.-à-d. un texte ou un mot dont l'ordre des lettres reste le même qu'on

le lise de gauche à droite ou de droite à gauche comme dans l'expression «ZEUS

A ETE A SUEZ».

(2) Une fonction souschaine(a,b:string):boolean, qui examine si un string

donné a est une sous-chaîne d'un deuxième string donné b. Par exemple :

a) souschaine(titi,tatitito) retourne true et

b) souschaine(titi,titatoti) retourne false.

(3) Une fonction anagramme qui teste si deux chaînes de caractères données sont des

anagrammes l'une de l'autre. Un anagramme d'un mot est un mot différent formé

avec exactement les mêmes lettres. Par exemple :

a) anagramme(algorithme,logarithme) retourne true et

b) anagramme(test,tete) retourne false.

Exercice 30 Ecrire les procédures suivantes :

(1) Une procédure diviseurs(n:integer) qui écrit à l’écran tous les diviseurs de

l’entier naturel non nul n.

(2) Une procédure hasard(n,a,b:integer) qui écrit à l’écran n entiers naturels

aléatoires tels que a n b .

(3) Une procédure premiers(a,b:integer) qui écrit à l’écran tous les nombres

premiers compris entre a et b.

(4) Une procédure parfaits(a,b:integer), qui recherche et écrit à l’écran tous

les nombres parfaits compris entre a et b. Par définition, un nombre n est parfait

lorsqu’il est égal à la somme de tous ses diviseurs propres (c.-à-d. tous les diviseurs

autres que n). Par exemple, 6 est parfait car 6 1 2 3 .

14

(5) Une procédure titre(s :string) qui écrit le string s sur l’écran entouré d’un

cadre formé de caractères ‘*’.

(6) Une procédure somme(a,b:extended ; var s :extended) qui calcule la

somme de deux réels a et b et la stocke dans le paramètre s.

(7) Une procédure echange(var s:string;i,j:integer) qui échange les

caractères d’indices i et j du string s.

(8) Une procédure effacer(var s:string;debut,n:integer) qui efface n

caractères du string s à partir du caractère d’indice debut.

(9) Une procédure separer(s :string; var prenom, nom :string) qui

prend en entrée une chaîne de caractères s du type a_b et qui stocke les deux

parties a et b dans les paramètres prenom et nom respectivement.

Exercice 31 (1) Ecrire une procédure factorisation(n :integer) qui écrit à l’écran la

décomposition en facteurs premiers de n. Exemple : Pour n = 360, la procédure

affichera : 2*2*2*3*3*5.

(2) Même question, mais on demande d’afficher le résultat comme produit de

puissances. Exemple : Pour n = 360, la procédure affichera à l’écran :

2^3*3^2*5^1.

Exercice 32 a) Ecrire une fonction factorial qui calcule la factorielle d'un entier naturel n. On

rappelle que : ! 1 2 3 ....n n et par définition : 0 ! 1 .

b) Ecrire une fonction binomial qui calcule le coefficient binomial

!

! !kn

nC

k n k

,

avec 0 k n . ( kn

C est le nombre de façons qu'il y a à choisir un sous-ensemble de k

éléments dans un ensemble de n éléments donné.)

Exercice 33 Leonhard Euler (1707-1783) a trouvé le polynôme quadratique remarquable suivant :

2( ) 41p n n n .

De façon surprenante, en remplaçant n par les valeurs successives de n allant de 0 à

39, on montre que ( )p n est un nombre premier. Toutefois, lorsque 40n ,

15

2 2(40) 40 40 41 40 (40 1) 41 40 41 41 41p

est divisible par 41 et n’est donc plus premier. A l’aide de l’ordinateur, un polynôme

encore plus incroyable a été découvert : 2( ) 79 1601p n n n

fournit 80 nombres premiers pour les valeurs successives de n allant de 0 à 79.

Ecrire un programme qui permet à l’utilisateur d’entrer deux entiers relatifs a et b et

qui permet d’afficher la liste des nombres premiers générée par le polynôme 2( )p n n an b . On affichera donc la suite (0)p , (1)p , (2)p , … jusqu’à ce que l’on

rencontre pour la première fois un entier ( )p i non premier (qui ne sera plus affiché).

Le programme comprendra

a) la fonction premier(n:integer):boolean; qui permet de déterminer si un

entier naturel donné est premier ou non ;

b) la fonction poly(a,b,n:integer):integer; qui retourne ( )p n pour des

valeurs a, b et n données ;

c) une procédure afficherSuitePremiers(a,b:integer) qui affiche tous les

nombres premiers ( )p i , i variant de 0 à 1m , où m est le plus petit entier tel que

( )p m est non premier.

Exercice 34 Ecrire un programme qui affiche le tableau des images de la fonction

3 2:f x ax bx cx d . On demandera à l'utilisateur d'entrer les coefficients a, b, c

et d du polynôme f au clavier. L'utilisateur choisira par ailleurs les bornes min et max

entre lesquels x varie et le pas h à utiliser dans le tableau de variation.

Exercice 35 (1) Ecrire une fonction somme qui retourne la somme des chiffres (=Quersume) d'un

entier naturel. Par exemple : somme 94 ' 307 9 4 3 0 7 23 . On se

servira des opérateurs div et mod.

• div 10x retourne le reste entier de la division de x par 10 (donc le dernier

chiffre de x)

• mod 10x retourne le quotient entier de la division de x par 10 (donc le

nombre formé des chiffres de x à l'exception du dernier chiffre)

16

(2) Ecrire une fonction somme_alt qui retourne la somme alternée des chiffres d'un

entier naturel (les chiffres sont précédés alternativement du signe + et du signe –

). Par exemple : somme_alt 94 ' 307 9 4 3 0 7 15 .

(3) Utiliser ces fonctions pour écrire un programme qui teste si un entier naturel entré

par l'utilisateur est divisible par 3, par 9 ou par 11.

Exercice 36 Ecrire un programme qui recherche une racine d’un polynôme p du 3e degré par la

méthode dichotomique :

• L’utilisateur entre deux réels a b tels que 0p a p b , c.-à-d. tels que

p a et p b soient de signes opposés. (Le programme devra vérifier si cette

condition est bien remplie et afficher au cas contraire un message d’erreur).

• Le programme calcule 2a bp : il y a alors 3 possibilités :

- ou bien 2 0a bp , alors 2a b est une racine de p et le problème est

résolu ;

- ou bien 2 0a bp p a , alors le programme posera 2: a ba ;

- ou bien 2 0a bp p b alors le programme posera 2: a bb ;

Cet algorithme se poursuit jusqu’à ce que b a , où est l’erreur tolérée

sur la racine, fixée au préalable par l’utilisateur.

Exercice 37 Ecrire le programme qui recherche et compte tous les triplets pythagoriciens (x,y,z) tels

que 1 maxx y , où max est un entier entré par l’utilisateur. On rappelle qu’un

triplet pythagoricien est un triplet d’entiers naturels (x,y,z) tels que 2 2 2x y z .

Exemple d’exécution :

Exercice 38 On définit le type liste par :

17

const max = 10; //déclaration d’une constante

type liste = array[1..max] of integer;

(1) Ecrire une procédure echanger qui prend en entrée un tableau du type liste et

deux entiers i et j. Cette procédure devra échanger les deux éléments d’indices

i et j du tableau.

(2) Ecrire une procédure effacer qui prend en argument un tableau de type liste

et un indice pos. La procédure devra supprimer l’élément d’indice pos et décaler

les éléments qui le suivent d’un indice vers la gauche.

(3) Ecrire une procédure inserer qui prend en argument un tableau de type liste,

un indice pos et un nouvel élément de type integer à insérer à l’endroit pos.

Les éléments d’indices supérieurs ou égaux à pos seront donc décalés d’une

position vers la droite. Le dernier élément de la liste sera supprimé.

(4) Ecrire une fonction rotation prenant en argument un tableau de type liste, et

un entier n. La fonction effectue la rotation (décalage) des éléments du tableau

de n positions vers la droite. Par exemple, avec n=2, le tableau

(1,2,3,4,5,6,7,8,9,10) contiendra après rotation (9,10,1,2,3,4,5,6,7,8).

(5) Ecrire une procédure randomFill qui prend en entrée un tableau du type liste

et qui le remplit de façon aléatoire avec les entiers de 1 à 100, chaque entier

apparaissant exactement une seule fois dans le tableau.

Exercice 39 Ecrire un programme qui permet de trier par ordre croissant une liste d’entiers dont

les éléments et leur nombre sont donnés par l’utilisateur. L’algorithme à implémenter

est le tri par sélection : on cherche dans la liste le plus petit élément et on l’échange

avec le premier élément de la liste, on cherche l’élément le plus petit parmi les éléments

restants, c.-à-d. à partir du deuxième. On recommence l’algorithme en ne prenant plus

en considération les éléments déjà triés jusqu’à ce qu’on arrive à la fin de la liste. Le

tableau trié doit être écrit sur l’écran. On introduira le type liste, défini comme suit :

type liste = record items : array[1..1000] of integer ; count: integer ; end ;

et on utilisera une procédure echange(var t:liste;i,j:integer) qui échange

les éléments d’indices i et j d’un tableau de t type liste. Exercice 40

18

On construit une suite de nombres entiers de la manière suivante :

• on choisit un nombre de départ 1

a parmi les entiers de 1 à 99 ;

• on obtient 1n

a en multipliant le chiffre des unités de

na par 5 et en ajoutant au

résultat le chiffre des dizaines de n

a .

• on arrête le procédé dès que 1 1 2

{ , , ..., }n n

a a a a , c.-à-d. on tombe sur un élément

déjà obtenu auparavant. Le dernier terme de la suite est alors n

a .

Ecrire un programme, qui pour un entier de départ 1

a donné, écrit à l’écran tous les

termes de la suite ainsi définie et compte le nombre de termes de cette suite.

(1) Que se passe-t-il si on part a) d’un multiple de 7 ? b) d’un entier 50 et non

multiple de 7 ?

(2) Pour quel entier de départ obtient-on la suite a) la plus courte b) la plus longue ?

19

Exercice 41 Soit T un tableau d'entiers de taille N, contenant uniquement des 0 et des 1, placés au

hasard. (On peut imaginer par exemple que c’est une suite de résultats du lancer d’une

pièce de monnaie. Une série dans T est une suite d'éléments consécutifs et égaux de T.

Ecrire un programme qui cherche la plus longue série dans un tableau donné T, l'indice

de son premier élément et sa longueur.

Exercice 42

(1) Ecrire un programme qui permet de simuler le tirage au sort de k boules dans

une urne contenant a boules noires et b boules blanches. On distinguera les deux

cas : tirages avec ou sans remise.

(2) Ecrire un programme qui permet de simuler le tirage au sort d’une main de k

cartes (sans remise) dans une jeu contenant 52 cartes.

Exercice 43 Réaliser une petite calculatrice qui permet de faire des opérations sur des fractions. Le

programme permettra a) de simplifier des fractions et b) d’effectuer plusieurs opérations

élémentaires (addition, soustraction, multiplication et division) sur les fractions, l’une

à la suite de l’autre, comme dans l’exemple d’exécution ci-dessous. On ne demande pas

que la calculatrice respecte les règles de priorité. On utilisera le type fraction défini

par :

type fraction = record n,d:integer; end;

20

Exercice 44 Ecrire un programme qui permet d’effectuer des opérations sur les ensembles d’entiers,

comportant au plus 100 éléments. On utilisera les définitions suivantes :

const max=100; type ensemble = record nom:string ;

elem:array[1..max] of integer; card:integer

end;

Le programme permettra à l’utilisateur d’entrer un par un les éléments de deux

ensembles A et B, puis on pourra calculer au choix A B , A B et \A B . Les

ensembles résultats seront présentés sans éléments doubles : une procédure reduction

permettra de les éliminer. Par exemple : {0,1,1, 2} deviendra {0,1, 2} . Le programme

permettra également de comparer les deux ensembles A et B : il décidera si A B , si

A B ou si B A . On structurera le programme en procédures et fonctions

adéquates.

Exercice 45 Ecrire un programme qui permet d’effectuer les opérations usuelles sur les polynômes :

a) addition et soustraction, b) multiplication, c) évaluation en un réel donné par

l’algorithme de Horner d) dérivation. Pour chaque opération, on écrira une procédure

adéquate. En outre, une procédure saisie et une procédure affichage permettront

de lire et d’écrire à l’écran les coefficients et le degré d’un polynôme.

On utilisera les définitions suivantes :

const max=1000; type poly = record nom :string ; c:array[0..max] of extended; d:integer end;

où c représente le tableau avec les coefficients du polynôme, c.-à-d. [ ]c n est le coefficient

de nx , et d est le degré du polynôme.

Exercice 46 Pour analyser les résultats des élèves d’un lycée dans les 4 branches mathématiques,

allemand français et anglais, on introduit les types suivant :

type etudiant = record nom,prenom:string; notes:array[1..4] of integer;

moyenne:extended

21

end; lycee = record items :array[1..1000] of etudiant ; count :integer ; end;

On pourra implémenter les noms des branches sous forme d’un tableau, à déclarer

comme constante :

const branches:array[1..4] of string

= ('mathematiques','allemand','francais','anglais');

Par exemple : toto.notes[1] ≔ 35 ;

toto.notes[2] ≔ 36 ;

toto.notes[3] ≔ 37 ;

toto.notes[4] ≔ 38 ;

signifie que l’étudiant toto a eu 35 en mathematiques, 36 en allemand, 37 en français

et 38 en anglais.

Le programme à réaliser comportera le menu suivant :

1 : Saisie 2 : Affichage par ordre alphabetique 3 : Tri par branche ou par moyenne 4 : Recherche d’etudiants 5 : Quitter

L’utilisateur, en choisissant le numéro correspondant pourra donc saisir les différents

champs relatifs aux étudiants (1), afficher sur l’écran les étudiants et leurs résultats

soit par ordre alphabétique (2), soit en les classant suivant la note d’une branche

donnée ou suivant la moyenne générale (3), ou bien chercher tous les étudiants vérifiant

une certaine condition (4). Cette condition sera entrée par l’utilisateur sous l’une des

formes suivantes : prenom>titi ou nom=toto ou moyenne>40 ou informatique=30

… Donc : champ =,>,< valeur sans espace.

(Au lieu d’écrire une procédure saisie, on pourra aussi remplir aléatoirement le

tableau avec les étudiants et leurs résultats, pour mieux pouvoir tester le programme.)

Exercice 47 Ecrire un programme qui permet de représenter graphiquement un chemin aléatoire

reliant le coin supérieur gauche au coin inférieur droit d’une grille rectangulaire, dont

le nombre de lignes et de colonnes pourra être choisi par l’utilisateur. Le chemin doit

22

avoir la longueur minimale, c.-à-d. on pourra uniquement se promener d’une position

vers la droite ou d’une position vers le bas dans la grille.

On utilisera les types : type grille = record items:array[1..100,1..100] of integer; rowCount,colCount:integer end; chemin = record items:array[1..200] of integer; count:integer; end; La difficulté consiste à choisir un chemin au hasard : pour cela, on remarque que pour

l’exemple d’exécution ci-dessus, parmi les (10-1)+(20-1)=28 transitions à faire (vers la

droite ou vers le bas), il suffit de choisir les 10-1=9 endroits ou on descend. Le chemin

obtenu dans l’exemple d’exécution peut donc être représenté par la liste :

(1,0,0,1,0,0,0,0,0,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,1,0,1)

Chaque 1 représente une position où on descend, chaque 0 représente une position où

on se déplace vers la droite.

23

Exercice 48 Ecrire un programme qui demande à l’utilisateur d’entrer

d’abord le nombre d’élèves d’une classe, puis d’entrer une à

une les notes en mathématiques de ces élèves (entiers

compris entre 01 et 60). Les notes sont stockées dans une

liste n de type

notes = array[1..100]of integer ;

(On pourra aussi écrire une procédure qui remplit

automatiquement le tableau avec des notes choisies au

hasard pour accélérer le processus de saisie …)

On demande ensuite de remplir une liste f de type

frequences = array[1..60]of integer ;

avec les fréquences de ces notes. Donc par exemple

frequences[43] est le nombre d’élèves qui ont obtenu

43 points. Les fréquences groupées (intervalles [1,9[,

[10,20[,[20,30[, … [50,60]), seront affichées à l’écran à l’aide

d’un diagramme.

Exercice 49 (Opérations sur les matrices) Ecrire un programme qui permet de calculer la somme et le

produit de 2 matrices à coefficients réels, de dimensions quelconques. On utilisera le

type matrice défini par :

type matrice = record name : string ; items : array[1..100,1..100] of extended; rowCount,colCount : integer ; end;

Le programme comportera :

a) deux procédures saisie et affichage, permettant respectivement à l’utilisateur

d’entrer et d’afficher les éléments d’une matrice, ligne par ligne ;

b) deux fonctions somme et produit, retournant respectivement la somme et le

produit de deux matrices;

Lorsque la somme ou le produit ne sont pas définis, un message d’erreur sera affiché

par le programme.

24

Exercice 50 (Serpent vietnamien)

Voici un problème de maths repéré par le Guardian

donné à des enfants de 8 ans au Vietnam.

Les 9 cases sont à remplir avec des chiffres de 1 à 9 (qu'il

ne faut utiliser qu'une fois chacun). En ajoutant,

multipliant, soustrayant et divisant au fur et à mesure

(en suivant l’ordre des opérations – multiplications et

divisions en priorité), on doit arriver à 66.

Ecrire un programme qui trouve et affiche toutes les solutions. Essayer de simplifier

l’équation et de limiter la recherche en éliminant certaines possibilités dès le départ !

Exercice 51 (Tic-tac-toe) Ecrire un programme qui permet à deux humains (1 et 2) de faire un match de Tic–

tac-toe. Un match est composé de plusieurs parties, dont le nombre est fixé à l’avance.

Les joueurs commencent alternativement à jouer en premier. Les règles du jeu sont

connues ou peuvent être consultées sur Wikipedia :

https://fr.wikipedia.org/wiki/Tic-tac-toe.

On utilisera les types suivants :

type board = array[1..9] of integer; scores = array[1..2] of integer;

Une variable b de type board détermine complètement le jeu. On posera b[i]:=0 si

la case numéro i est vide, b[i]:=1 ou b[i]:=2 suivant que le joueur 1 ou le joueur

2 y joue. Les joueurs jouent en introduisant à tour de rôle le numéro de la case qu’ils

choisissent. Pour simplifier l’introduction des coups, on utilisera la disposition du

clavier numérique : 7 | 8 | 9

---|---|--- 4 | 5 | 6

---|---|--- 1 | 2 | 3

25

Par exemple lorsque le joueur 1 (avec les X) commence

à jouer la case numéro 5 et le joueur 2 (avec les O)

répond en choisissant la case numéro 4, on obtient la

position ci-contre :

A la fin de chaque partie, les scores, stockés dans une

variable globale sco de type scores seront actualisés

et écrits à l’écran ; le score du joueur 1 est sc[1], celui

du joueur 2 est sc[2].

A la fin du match, les scores finaux et le vainqueur

seront affichés :

On écrira des fonctions et procédures afin de rendre le code lisible.