Ch. 00 · Leçon 1
Série de Révision N°1 — Algorithme et Programmation
Ce que vous saurez faire
- →Réviser les opérateurs arithmétiques et logiques en Python et en analyse
- →Manipuler des chaînes de caractères (slicing, sous-chaine, longueur)
- →Écrire des algorithmes utilisant des structures itératives et conditionnelles
- →Manipuler les tableaux : recherche, maximum, permutation, tri par signe
- →Traduire un algorithme en code Python
id: 33-1595-serie-revision-algorithme-programmation-1 slug: 33-1595-serie-revision-algorithme-programmation-1 titre: Série de Révision N°1 — Algorithme et Programmation chapitre: 0 chapitre_titre: Révisions générales lecon: 1 niveau: 4eme-sci ordre: 1 prerequis:
- variables-types
- operateurs
- chaines-caracteres
- structures-controle
- tableaux duree_estimee_min: 120 mots_cles:
- revision
- chaines
- tableaux
- boucles
- conditions
- pgcd
- kaprekar
- premier
- cubique
- ascii langages:
- analyse
- pascal
- python objectifs:
- Réviser les opérateurs arithmétiques et logiques en Python et en analyse
- Manipuler des chaînes de caractères (slicing, sous-chaine, longueur)
- Écrire des algorithmes utilisant des structures itératives et conditionnelles
- 'Manipuler les tableaux : recherche, maximum, permutation, tri par signe'
- Traduire un algorithme en code Python status: published source_pdf: 33_1595.pdf source_pages:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14 kind: exercices
Cette série regroupe 23 exercices de révision couvrant les notions fondamentales d'algorithmique et de programmation : opérateurs, types, chaînes de caractères, structures conditionnelles et itératives, ainsi que les tableaux.
Partie 1 — Opérateurs, types et chaînes de caractères
Pour le code Python ci-dessous, écrire l'affichage adéquat pour les instructions print.
a = 18.5
b = 2
print(a // b)
print(a % b)
print(divmod(a, b))
print(float(b))
print(int(a))
print(a ** b)
print(pow(a, b))
Puis, en continuant :
print(round(a))
a += 1.5
b -= 3
print(a)
print(b)
print(abs(a))
print(abs(b))
c = -5.8
print(round(c))
Voir le corrigé
| Instruction | Résultat |
|---|---|
print(a // b) | 9.0 |
print(a % b) | 0.5 |
print(divmod(a, b)) | (9.0, 0.5) |
print(float(b)) | 2.0 |
print(int(a)) | 18 |
print(a ** b) | 342.25 |
print(pow(a, b)) | 342.25 |
print(round(a)) | 18 |
print(a) après a += 1.5 | 20.0 |
print(b) après b -= 3 | -1 |
print(abs(a)) | 20.0 |
print(abs(b)) | 1 |
print(round(c)) avec c = -5.8 | -6 |
On donne a = 5, b = 4, c = 2. Donner les valeurs de X, Y, Z ainsi que leurs types.
- X ← b - (a mod b div c * 6) / 2 + c
- Z ← (a ≤ a) ET (a = a) OU (a < a) ET (a ≠ a)
- Y ← arrondi(11.45 + a mod c / c)
Voir le corrigé
- X = 6.0 de type réel
- Z = Vrai de type Booléen
- Y = 12 de type entier
Soit la chaîne ch = 'Bac 2022'. Donner le résultat ainsi que la syntaxe algorithmique des instructions Python du tableau ci-dessous.
| Instruction Python | Résultat | Syntaxe Algorithmique |
|---|---|---|
Ch1 = ch[5] | ? | ? |
Ch2 = ch[1:6] | ? | ? |
Ch3 = ch[:6] | ? | ? |
Ch4 = ch[1:] | ? | ? |
Ch5 = ch[1:6:2] | ? | ? |
Ch6 = ch[:-1] | ? | ? |
Ch7 = ch[::] | ? | ? |
Ch8 = ch[::-1] | ? | ? |
Break de Savoir
Indice (positif) 0 1 2 3 4 5 6 7
ch = 'B' 'a' 'c' ' ' '2' '0' '2' '2'
Indice (négatif) -8 -7 -6 -5 -4 -3 -2 -1
print(ch[1:5])etprint(ch[-7:-3])donnent le même affichage :"ac 2"- L'instruction
ch[::-1]donne la chaîne inversée.
Voir le corrigé
| Instruction | Résultat | Syntaxe Algorithmique |
|---|---|---|
Ch1 = ch[5] | '0' | Ch1 ← ch[5] OU Ch1 ← sous-chaine(ch, 5, 6) |
Ch2 = ch[1:6] | 'ac 20' | Ch2 ← sous-chaine(ch, 1, 6) |
Ch3 = ch[:6] | 'Bac 20' | Ch3 ← sous-chaine(ch, 0, 6) |
Ch4 = ch[1:] | 'ac 2022' | Ch4 ← sous-chaine(ch, 1, long(ch)) |
Ch5 = ch[1:6:2] | 'a 0' | voir algorithme ci-dessous |
Ch6 = ch[:-1] | 'Bac 202' | Ch6 ← sous-chaine(ch, 0, long(ch)-1) |
Ch7 = ch[::] | 'Bac 2022' | Ch7 ← ch |
Ch8 = ch[::-1] | '2202 caB' | voir algorithme ci-dessous |
Pour Ch5 :
Ch_aux ← sous-chaine(ch, 1, 6)
i ← 0
ch5 ← ""
Répéter
ch5 ← ch5 + ch_aux[i]
i ← i + 2
jusqu'à i > long(ch_aux)
Pour Ch8 :
i ← long(ch)
ch8 ← ""
Répéter
i ← i - 1
ch8 ← ch8 + ch[i]
jusqu'à i < 0
Écrire un programme qui permet de modifier la chaîne 'ABIR' en 'AMIR'.
Voir le corrigé
TDO
| Objet | Type/Nature |
|---|---|
| ch | Chaine |
Algorithme Ex4
Debut
ch ← "ABIR"
ch[1] ← "M"
Ecrire(ch)
Fin
TDO
| Objet | Type/Nature |
|---|---|
| ch | Chaine |
Algorithme Ex4
Debut
ch ← "ABIR"
ch[1] ← "M"
Ecrire(ch)
Fin
TDO
| Objet | Type/Nature |
|---|---|
| ch | Chaine |
Algorithme Ex4
Debut
ch ← "ABIR"
ch ← sous-chaine(ch, 0, 1) + "M" + sous-chaine(ch, 2, 4)
Ecrire(ch)
Fin
Code Python (méthode 2 uniquement) :
ch = "ABIR"
ch = ch[:1] + "M" + ch[2:]
print(ch)
À partir des trois chaînes :
Ch1 = "partiger"Ch2 = "pourra"Ch3 = "régner"
Construire le proverbe : « partager pour régner » en faisant les modifications nécessaires sur Ch1 et Ch2 par 2 méthodes différentes.
Voir le corrigé
Algorithme Ex5
Debut
ch1 ← "partiger"
ch2 ← "pourra"
ch3 ← "régner"
ch1[4] ← "a"
ch2 ← efface(ch2, 4, 6)
ch ← ch1 + " " + ch2 + " " + ch3
Ecrire(ch)
Fin
Algorithme Ex5
Debut
ch1 ← "partiger"
ch2 ← "pourra"
ch3 ← "régner"
ch1[4] ← "a"
ch2 ← efface(ch2, 4, 6)
ch ← ch1 + " " + ch2 + " " + ch3
Ecrire(ch)
Fin
Algorithme Ex5
Debut
ch1 ← "partiger"
ch2 ← "pourra"
ch3 ← "régner"
ch1 ← sous-chaine(ch1, 0, 4) + "a" + sous-chaine(ch1, 5, 8)
ch2 ← sous-chaine(ch2, 0, 4)
ch ← ch1 + " " + ch2 + " " + ch3
Ecrire(ch)
Fin
Code Python :
ch1 = "partiger"
ch2 = "pourra"
ch3 = "régner"
ch1 = ch1[:4] + "a" + ch1[5:]
ch2 = ch2[:4]
ch = ch1 + " " + ch2 + " " + ch3
print(ch)
Effectuer l'algorithme et le code Python d'un programme qui permet de :
- Transformer la chaîne
"10/09/1921"en"10/09/2021". - Déterminer la longueur de la chaîne.
- Extraire l'année seulement dans une nouvelle chaîne.
- Convertir la chaîne année en un nombre entier.
Voir le corrigé
TDO
| Objet | Type/Nature |
|---|---|
| ch, annee | Chaines |
| L, an | Entiers |
Algorithme Ex6
Debut
ch ← "10/09/1921"
ch ← sous-chaine(ch, 0, 6) + "20" + sous-chaine(ch, 8, 10)
L ← long(ch)
annee ← sous-chaine(ch, 6, 10)
an ← valeur(annee)
Fin
TDO
| Objet | Type/Nature |
|---|---|
| ch, annee | Chaines |
| L, an | Entiers |
Algorithme Ex6
Debut
ch ← "10/09/1921"
ch ← sous-chaine(ch, 0, 6) + "20" + sous-chaine(ch, 8, 10)
L ← long(ch)
annee ← sous-chaine(ch, 6, 10)
an ← valeur(annee)
Fin
ch = "10/09/1921"
ch = ch[:6] + "20" + ch[8:]
L = len(ch)
annee = ch[6:]
an = int(annee)
Écrire un programme qui effectue le cryptage d'un mot donné en utilisant le principe suivant :
- Permuter le premier caractère du mot avec le dernier.
- Modifier l'élément milieu du mot par son ordre dans le code ASCII.
NB : On suppose que le mot est une chaîne de caractères dont la taille est supérieure à trois.
Exemple : si ch = "info", le programme affichera après le cryptage la chaîne "o110fi".
Voir le corrigé
TDO
| Objet | Type/Nature |
|---|---|
| ch, code | Chaines |
| L | Entier |
Algorithme Ex7
Debut
Repeter
ecrire("ch="), lire(ch)
L ← long(ch)
jusqu'à (L > 3)
ch ← ch[L-1] + sous-chaine(ch, 1, L-1) + ch[1]
code ← convch(ord(ch[(L-1) div 2]))
ch ← sous-chaine(ch, 0, (L-1) div 2) + code + sous-chaine(ch, (L-1) div 2 + 1, L)
Ecrire(ch)
Fin
Algorithme Ex7
Debut
Repeter
ecrire("ch="), lire(ch)
L ← long(ch)
jusqu'à (L > 3)
ch ← ch[L-1] + sous-chaine(ch, 1, L-1) + ch[1]
code ← convch(ord(ch[(L-1) div 2]))
ch ← sous-chaine(ch, 0, (L-1) div 2) + code + sous-chaine(ch, (L-1) div 2 + 1, L)
Ecrire(ch)
Fin
while True:
ch = input("ch=")
L = len(ch)
if L > 3:
break
ch = ch[-1] + ch[1:-1] + ch[0]
code = str(ord(ch[(L-1)//2]))
ch = ch[:(L-1)//2] + code + ch[((L-1)//2)+1:]
print(ch)
Soit le tableau de déclaration des objets (TDO) suivant :
| O | T/N |
|---|---|
| mot1, mot2, mot3, mot4 | chaînes de caractères |
| n, m | entiers |
Sachant que l'algorithme commence par les instructions :
mot1 ← 'informatique'
mot2 ← '3D'
Donner les instructions algorithmiques puis Python permettant de réaliser les traitements suivants :
- a- À partir de la variable mot1, mettre dans la variable mot3 le terme
"format". - b- À partir de mot3 et mot2, mettre dans la variable mot4 le terme
"format 3D". - c- Mettre dans n la longueur de la chaîne mot4.
- d- À partir de la variable mot2, mettre dans m la valeur 3.
Voir le corrigé
mot1 ← "informatique"
mot2 ← "3D"
a) mot3 ← sous-chaine(mot1, 2, 8)
b) mot4 ← mot3 + " " + mot2
c) n ← long(mot4)
d) m ← valeur(sous-chaine(mot2, 0, 1))
mot1 ← "informatique"
mot2 ← "3D"
a) mot3 ← sous-chaine(mot1, 2, 8)
b) mot4 ← mot3 + " " + mot2
c) n ← long(mot4)
d) m ← valeur(sous-chaine(mot2, 0, 1))
mot1 = "informatique"
mot2 = "3D"
mot3 = mot1[2:8]
mot4 = mot3 + " " + mot2
n = len(mot4)
m = int(mot2[:1])
Partie 2 — Entiers, conditions et boucles
Écrire un algorithme qui permet de déterminer et d'afficher un entier Z de quatre chiffres à partir de deux entiers X et Y strictement positifs et formés chacun de deux chiffres.
Les chiffres de l'entier Z sont disposés de telle sorte que les deux chiffres du milieu correspondent à l'entier Y cadrés par ceux de l'entier X.
Exemple : Si X=56 et Y=21 alors l'entier Z sera égal à 5216.
Voir le corrigé
TDO
| Objet | Type/Nature |
|---|---|
| x, y, z, u, m | Entiers |
Algorithme Ex9
Debut
Repeter
ecrire("x="), lire(x)
jusqu'à (10 ≤ x ≤ 99)
Repeter
ecrire("y="), lire(y)
jusqu'à (10 ≤ y ≤ 99)
m ← x div 10
u ← x mod 10
z ← m*1000 + y*10 + u
ecrire(z)
Fin
Algorithme Ex9
Debut
Repeter
ecrire("x="), lire(x)
jusqu'à (10 ≤ x ≤ 99)
Repeter
ecrire("y="), lire(y)
jusqu'à (10 ≤ y ≤ 99)
m ← x div 10
u ← x mod 10
z ← m*1000 + y*10 + u
ecrire(z)
Fin
while True:
x = int(input("x="))
if 10 <= x <= 99:
break
while True:
y = int(input("y="))
if 10 <= y <= 99:
break
m = x // 10
u = x % 10
z = m*1000 + y*10 + u
print(z)
Écrire l'algorithme qui permet de déterminer et d'afficher le successeur et le prédécesseur d'un entier m donné.
Voir le corrigé
TDO
| O | T/N |
|---|---|
| m | Entier |
Algorithme Ex10
Debut
ecrire("m="), lire(m)
ecrire("Le prédécesseur de ", m, " est : ", m-1)
ecrire("Le successeur de ", m, " est : ", m+1)
Fin
Algorithme Ex10
Debut
ecrire("m="), lire(m)
ecrire("Le prédécesseur de ", m, " est : ", m-1)
ecrire("Le successeur de ", m, " est : ", m+1)
Fin
m = int(input("m="))
print("Le prédécesseur de ", m, " est : ", m-1)
print("Le successeur de ", m, " est : ", m+1)
Écrire un algorithme qui permet de déterminer et d'afficher le successeur et le prédécesseur d'un caractère c donné.
Voir le corrigé
TDO
| O | T/N |
|---|---|
| c, p, s | caractères |
Algorithme Ex11
Debut
ecrire("c="), lire(c)
p ← chr(ord(c) - 1)
s ← chr(ord(c) + 1)
ecrire("Le prédécesseur de ", c, " est : ", p)
ecrire("Le successeur de ", c, " est : ", s)
Fin
Algorithme Ex11
Debut
ecrire("c="), lire(c)
p ← chr(ord(c) - 1)
s ← chr(ord(c) + 1)
ecrire("Le prédécesseur de ", c, " est : ", p)
ecrire("Le successeur de ", c, " est : ", s)
Fin
c = input("c=")
p = chr(ord(c) - 1)
s = chr(ord(c) + 1)
print("Le prédécesseur de ", c, " est : ", p)
print("Le successeur de ", c, " est : ", s)
Un entier naturel de 3 chiffres est dit cubique s'il est égal à la somme des cubes de ses trois chiffres.
Exemple : 153 est cubique car 153 = 1³ + 5³ + 3³
Établir l'algorithme d'un programme qui permet de vérifier si un nombre est cubique ou non.
Voir le corrigé
TDO
| O | T/N |
|---|---|
| n, c, d, u | Entiers |
Algorithme Ex12
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (100 ≤ n ≤ 999)
c ← n div 100
d ← (n mod 100) div 10
u ← n mod 10
si (n = c*c*c + d*d*d + u*u*u) alors
ecrire(n, " est cubique")
sinon
ecrire(n, " n'est pas cubique")
finsi
Fin
Algorithme Ex12
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (100 ≤ n ≤ 999)
c ← n div 100
d ← (n mod 100) div 10
u ← n mod 10
si (n = c*c*c + d*d*d + u*u*u) alors
ecrire(n, " est cubique")
sinon
ecrire(n, " n'est pas cubique")
finsi
Fin
while True:
n = int(input("n="))
if 100 <= n <= 999:
break
c = n // 100
d = (n % 100) // 10
u = n % 10
if n == c**3 + d**3 + u**3:
print(n, " est cubique")
else:
print(n, " n'est pas cubique")
Écrire l'algorithme d'un programme qui permet d'afficher si un entier est Kaprekar ou non. Pour vérifier si un entier positif K de n chiffres est un nombre de KAPREKAR ou non, on peut suivre la méthode suivante :
- Élever K au carré.
- Additionner l'entier formé par les n chiffres de droite du carré de K avec l'entier formé par le reste des chiffres du carré de K.
- Si la somme trouvée à l'étape 2 est égale à K alors le nombre est dit Kaprekar.
Exemples :
- Si K=9 alors n=1 et K²=81. On constate que 1+8 = 9 donc 9 est kaprekar.
- Si K=45 alors n=2 et K²=2025. On constate que 25+20 = 45 donc 45 est kaprekar.
- Si K=297 alors n=3 et K²=88209. On constate que 209+88 = 297 donc 297 est kaprekar.
Voir le corrigé
TDO
| O | T/N |
|---|---|
| k, n, k2, n2, p1, p2, s | Entiers |
| chk, chk2 | chaines |
Algorithme Ex13
Debut
Repeter
ecrire("k="), lire(k)
jusqu'à (k > 0)
chk ← convch(k)
n ← long(chk)
k2 ← k*k
chk2 ← convch(k2)
n2 ← long(chk2)
p1 ← valeur(sous-chaine(chk2, n2-n, n2))
p2 ← valeur(sous-chaine(chk2, 0, n2-n))
s ← p1 + p2
si s = k alors
ecrire(k, " est kaprekar")
sinon
ecrire(k, " n'est pas kaprekar")
finsi
Fin
Algorithme Ex13
Debut
Repeter
ecrire("k="), lire(k)
jusqu'à (k > 0)
chk ← convch(k)
n ← long(chk)
k2 ← k*k
chk2 ← convch(k2)
n2 ← long(chk2)
p1 ← valeur(sous-chaine(chk2, n2-n, n2))
p2 ← valeur(sous-chaine(chk2, 0, n2-n))
s ← p1 + p2
si s = k alors
ecrire(k, " est kaprekar")
sinon
ecrire(k, " n'est pas kaprekar")
finsi
Fin
while True:
k = int(input("k="))
if k > 0:
break
chk = str(k)
n = len(chk)
k2 = pow(k, 2)
chk2 = str(k2)
n2 = len(chk2)
s = int(chk2[n2-n:]) + int(chk2[:n2-n])
if s == k:
print(k, " est kaprekar")
else:
print(k, " n'est pas kaprekar")
Écrire un algorithme permettant de saisir un nombre N et d'afficher s'il est premier ou non.
NB : Un nombre premier est un entier positif qui n'a pas d'autres diviseurs positifs que lui-même et 1.
Exemples :
- 11 est un nombre premier car il n'a pas de diviseurs positifs autres que 1 et 11.
- 6 n'est pas un nombre premier car les diviseurs de 6 sont 1, 2, 3, 6 (il admet des diviseurs autres que 1 et 6).
Voir le corrigé
TDO
| O | T/N |
|---|---|
| n, i | Entiers |
Algorithme Ex14
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n > 0)
i ← 2
tantque (n mod i ≠ 0) et (i < n) faire
i ← i + 1
fintantque
si (i ≥ n) alors
ecrire(n, " est premier")
sinon
ecrire(n, " n'est pas premier")
finsi
Fin
Algorithme Ex14
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n > 0)
i ← 2
tantque (n mod i ≠ 0) et (i < n) faire
i ← i + 1
fintantque
si (i ≥ n) alors
ecrire(n, " est premier")
sinon
ecrire(n, " n'est pas premier")
finsi
Fin
while True:
n = int(input("n = "))
if n > 0:
break
i = 2
while (n % i != 0) and (i < n):
i += 1
if i >= n:
print(n, " est premier")
else:
print(n, " n'est pas premier")
Écrire l'algorithme permettant d'afficher tous les nombres premiers situés entre 1 et 100.
Voir le corrigé
TDO
| O | T/N |
|---|---|
| n, i | Entiers |
Algorithme Ex15
Debut
Pour n de 1 à 100 faire
i ← 2
tantque (n mod i ≠ 0) et (i < n) faire
i ← i + 1
fintantque
si (i ≥ n) alors
ecrire(n)
finsi
finpour
Fin
Algorithme Ex15
Debut
Pour n de 1 à 100 faire
i ← 2
tantque (n mod i ≠ 0) et (i < n) faire
i ← i + 1
fintantque
si (i ≥ n) alors
ecrire(n)
finsi
finpour
Fin
for n in range(1, 101):
i = 2
while (n % i != 0) and (i < n):
i += 1
if i >= n:
print(n)
On veut calculer la somme suivante : $S = \sum_{i=1}^{n} \dfrac{1}{i^2}$
Voir le corrigé
TDO
| O | T/N |
|---|---|
| n, i, s | Entiers (s : réel) |
Algorithme Ex16
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n > 0)
s ← 0
Pour i de 1 à n faire
s ← s + 1/(i*i)
finpour
ecrire(s)
Fin
Algorithme Ex16
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n > 0)
s ← 0
Pour i de 1 à n faire
s ← s + 1/(i*i)
finpour
ecrire(s)
Fin
while True:
n = int(input("n = "))
if n > 0:
break
s = 0
for i in range(1, n+1):
s += 1/i**2
print(s)
Écrire un programme qui permet de saisir un entier positif impair N et de calculer :
- S1 = 1 + 1/2 + 1/3 + 1/4 + ... + 1/N
- S2 = 1 - 1/2 + 1/3 - 1/4 + ... 1/N
- S3 = 1 + 1/3 + 1/5 + 1/7 + ... + 1/N
Voir le corrigé
TDO
| O | T/N |
|---|---|
| n, i | Entiers |
| s | Réel |
Algorithme Ex17
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n > 0)
s ← 0
Pour i de 1 à n faire
s ← s + 1/i
finpour
ecrire("S1 = ", s)
s ← 0
Pour i de 1 à n faire
si (i mod 2 ≠ 0) alors
s ← s + 1/i
sinon
s ← s - 1/i
finsi
finpour
ecrire("S2 = ", s)
s ← 0
Pour i de 1 à n faire
si (i mod 2 ≠ 0) alors
s ← s + 1/i
finsi
finpour
ecrire("S3 = ", s)
Fin
Algorithme Ex17
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n > 0)
s ← 0
Pour i de 1 à n faire
s ← s + 1/i
finpour
ecrire("S1 = ", s)
s ← 0
Pour i de 1 à n faire
si (i mod 2 ≠ 0) alors
s ← s + 1/i
sinon
s ← s - 1/i
finsi
finpour
ecrire("S2 = ", s)
s ← 0
Pour i de 1 à n faire
si (i mod 2 ≠ 0) alors
s ← s + 1/i
finsi
finpour
ecrire("S3 = ", s)
Fin
while True:
n = int(input("n = "))
if n > 0:
break
s = 0
for i in range(1, n+1):
s += 1/i
print("S1 = ", s)
s = 0
for i in range(1, n+1):
if i % 2 != 0:
s += 1/i
else:
s -= 1/i
print("S2 = ", s)
s = 0
for i in range(1, n+1):
if i % 2 != 0:
s += 1/i
print("S3 = ", s)
Écrire un programme qui permet de chercher le PGCD de deux entiers m et n en utilisant la méthode de différence.
Exemple :
PGCD(10,16) = PGCD(10,6)
= PGCD(4,6)
= PGCD(4,2)
= PGCD(2,2) → PGCD(10,16) = 2
Voir le corrigé
TDO
| O | T/N |
|---|---|
| n, m | Entiers |
Algorithme Ex18
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n > 0)
Repeter
ecrire("m="), lire(m)
jusqu'à (m > 0)
tantque (m ≠ n) faire
si (m > n) alors
m ← m - n
finsi
si (m < n) alors
n ← n - m
finsi
fintantque
ecrire("Le PGCD est : ", m)
Fin
Algorithme Ex18
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n > 0)
Repeter
ecrire("m="), lire(m)
jusqu'à (m > 0)
tantque (m ≠ n) faire
si (m > n) alors
m ← m - n
finsi
si (m < n) alors
n ← n - m
finsi
fintantque
ecrire("Le PGCD est : ", m)
Fin
while True:
n = int(input("n = "))
if n > 0:
break
while True:
m = int(input("m = "))
if m > 0:
break
while m != n:
if m > n:
m -= n
if m < n:
n -= m
print("Le PGCD est : ", n)
Partie 3 — Tableaux
Écrire un programme qui permet de déterminer le maximum d'un tableau de réels de dimension n (3 ≤ n ≤ 10).
Voir le corrigé
TDNT
| Type |
|---|
| Tab = tableau de 10 réels |
TDO
| O | T/N |
|---|---|
| n, i | Entiers |
| max | Réel |
| T | Tab |
Algorithme Ex19
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
Lire(T[i])
finpour
max ← T[0]
pour i de 1 à n-1 faire
si (max < T[i]) alors
max ← T[i]
finsi
finpour
ecrire("Maximum de T est : ", max)
Fin
Algorithme Ex19
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
Lire(T[i])
finpour
max ← T[0]
pour i de 1 à n-1 faire
si (max < T[i]) alors
max ← T[i]
finsi
finpour
ecrire("Maximum de T est : ", max)
Fin
while True:
n = int(input("n = "))
if 3 <= n <= 10:
break
T = [0] * n
for i in range(n):
T[i] = float(input('T[' + str(i+1) + ']='))
max = T[0]
for i in range(1, n):
if max < T[i]:
max = T[i]
print("Le maximum de T est : ", max)
Écrire un programme qui permet de faire une permutation entre le maximum et le minimum d'un tableau de réels T de dimension n (3 ≤ n ≤ 10).
Voir le corrigé
TDNT
| Type |
|---|
| Tab = tableau de 10 réels |
TDO
| O | T/N |
|---|---|
| n, i, max, min, aux | Entiers |
| T | Tab |
Algorithme Ex20
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
Lire(T[i])
finpour
max ← 0
min ← 0
pour i de 1 à n-1 faire
si (T[max] < T[i]) alors
max ← i
finsi
si (T[min] > T[i]) alors
min ← i
finsi
finpour
aux ← T[max]
T[max] ← T[min]
T[min] ← aux
pour i de 0 à n-1 faire
ecrire(T[i])
finpour
Fin
Algorithme Ex20
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
Lire(T[i])
finpour
max ← 0
min ← 0
pour i de 1 à n-1 faire
si (T[max] < T[i]) alors
max ← i
finsi
si (T[min] > T[i]) alors
min ← i
finsi
finpour
aux ← T[max]
T[max] ← T[min]
T[min] ← aux
pour i de 0 à n-1 faire
ecrire(T[i])
finpour
Fin
while True:
n = int(input("n = "))
if 3 <= n <= 10:
break
T = [0] * n
for i in range(n):
T[i] = float(input('T[' + str(i+1) + ']='))
max = 0
min = 0
for i in range(1, n):
if T[max] < T[i]:
max = i
if T[min] > T[i]:
min = i
aux = T[max]
T[max] = T[min]
T[min] = aux
for i in range(n):
print("T[", i+1, "] = ", T[i])
Écrire un programme qui cherche si une valeur v existe dans un tableau B. B est composé de n réels avec (3 ≤ n ≤ 10). v est une valeur réelle donnée. Le programme affichera un message de la forme : "v existe dans B" ou "v n'existe pas dans B".
Voir le corrigé
TDNT
| Type |
|---|
| Tab = tableau de 10 réels |
TDO
| O | T/N |
|---|---|
| n, i, v | Entiers (v : réel) |
| B | Tab |
Algorithme Ex21
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
Lire(B[i])
finpour
ecrire("Valeur à chercher : ")
lire(v)
i ← 0
tantque (B[i] ≠ v) et (i < n-1) faire
i ← i + 1
fintantque
si (B[i] = v) alors
ecrire(v, " existe dans B")
sinon
ecrire(v, " n'existe pas dans B")
finsi
Fin
Algorithme Ex21
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
Lire(B[i])
finpour
ecrire("Valeur à chercher : ")
lire(v)
i ← 0
tantque (B[i] ≠ v) et (i < n-1) faire
i ← i + 1
fintantque
si (B[i] = v) alors
ecrire(v, " existe dans B")
sinon
ecrire(v, " n'existe pas dans B")
finsi
Fin
while True:
n = int(input("n = "))
if 3 <= n <= 10:
break
B = [0] * n
for i in range(n):
B[i] = float(input('B[' + str(i+1) + ']='))
v = float(input("La valeur à chercher : "))
i = 0
while (B[i] != v) and (i < n-1):
i += 1
if B[i] == v:
print(v, " existe dans B")
else:
print(v, " n'existe pas dans B")
Écrire un programme qui saisit un tableau T de n entiers (3 ≤ n ≤ 10) compris entre 1 et 26 qui représentent les ordres alphabétiques. Le programme affichera le mot composé des lettres qui correspondent à ces ordres en majuscules.
Exemple : Pour n = 4 et T = [2, 9, 5, 14], le programme affiche : "Le mot associé est : BIEN".
Voir le corrigé
TDNT
| Type |
|---|
| Tab = tableau de 10 entiers |
TDO
| O | T/N |
|---|---|
| n, i | Entiers |
| T | Tab |
Algorithme Ex22
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
repeter
Lire(T[i])
Jusqu'à (T[i] ∈ [1..26])
finpour
pour i de 1 à n faire
ecrire(chr(T[i] + 64))
finpour
Fin
Algorithme Ex22
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
repeter
Lire(T[i])
Jusqu'à (T[i] ∈ [1..26])
finpour
pour i de 1 à n faire
ecrire(chr(T[i] + 64))
finpour
Fin
while True:
n = int(input("n = "))
if 3 <= n <= 10:
break
T = [0] * n
for i in range(n):
while True:
T[i] = int(input('T[' + str(i+1) + ']='))
if 1 <= T[i] <= 26:
break
for i in range(n):
print(chr(T[i] + 64), end="")
Écrire un programme qui permet de saisir N entiers non nuls d'un tableau T avec (3 ≤ n ≤ 10), de ranger les éléments négatifs dans un tableau TNEG et les éléments positifs dans un tableau TPOS et de les afficher.
Voir le corrigé
TDNT
| Type |
|---|
| Tab = tableau de 10 entiers |
TDO
| O | T/N |
|---|---|
| n, i, j, k | Entiers |
| T, TPOS, TNEG | Tab |
Algorithme Ex23
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
ecrire("T[", i, "]=")
Lire(T[i])
finpour
j ← 0
k ← 0
pour i de 1 à n faire
si (T[i] ≥ 0) alors
TPOS[j] ← T[i]
j ← j + 1
sinon
TNEG[k] ← T[i]
k ← k + 1
finsi
finpour
ecrire("**TPOS**")
pour i de 1 à j faire
ecrire(TPOS[i])
finpour
ecrire("**TNEG**")
pour i de 1 à k faire
ecrire(TNEG[i])
finpour
Fin
Algorithme Ex23
Debut
Repeter
ecrire("n="), lire(n)
jusqu'à (n ∈ [3..10])
pour i de 0 à n-1 faire
ecrire("T[", i, "]=")
Lire(T[i])
finpour
j ← 0
k ← 0
pour i de 1 à n faire
si (T[i] ≥ 0) alors
TPOS[j] ← T[i]
j ← j + 1
sinon
TNEG[k] ← T[i]
k ← k + 1
finsi
finpour
ecrire("**TPOS**")
pour i de 1 à j faire
ecrire(TPOS[i])
finpour
ecrire("**TNEG**")
pour i de 1 à k faire
ecrire(TNEG[i])
finpour
Fin
while True:
n = int(input("n = "))
if 3 <= n <= 10:
break
T = [0] * n
for i in range(n):
T[i] = int(input('T[' + str(i+1) + ']='))
TPOS = [0] * n
TNEG = [0] * n
j = 0
k = 0
for i in range(n):
if T[i] >= 0:
TPOS[j] = T[i]
j += 1
else:
TNEG[k] = T[i]
k += 1
print('**TPOS**')
for i in range(j):
print(TPOS[i], end="|")
print('\n**TNEG**')
for i in range(k):
print(TNEG[i], end="|")