Notions générales

Retrouvez toutes les fiches de cours téléchargeables au format pdf en cliquant sur les liens suivants :

• Fiche n° 1 : Algorithme en langage naturel
• Fiche n° 2 : Les variables
• Fiche n° 2 bis : Les listes
• Fiche n° 3 : Les fonctions
• Fiche n° 3 bis : Mathématiques et programmation
• Fiche n° 4 : Les instructions conditionnelles
• Fiche n° 5 : Les boucles bornées
• Fiche n° 6 : Les boucles non bornées

1

Affectation de variables ★☆☆

→ Voir fiche n° 2 : Les variables

On considère le programme suivant.

1. Quelle est la valeur des variables $a$, $b$ et $c$ à la fin du programme ?


2. Compléter le programme pour vérifier ces valeurs.

a = 1
b = 1
c = 1
a = b + c
while b < 5:
  a = a + 1
  c = 2*c
  b = b + 1
b = 3*b

2

Branchement conditionnel ★★☆

→ Voir fiche n° 4 : Les instructions conditionnelles

Le mois de février contient 28 jours, sauf les années bissextiles. Toutes les années qui sont des multiples de 4 sont des années bissextiles mais les années qui se terminent par 00 ne sont pas bissextiles à moins qu’elles soient multiples de 400.
Ainsi, l’année 1976 était bissextile, l’année 1979 ne l’était pas, l’année 2000 était bissextile mais l’année 1900 ne l’était pas.
Compléter le programme suivant de manière à ce qu’il affiche la chaîne de caractères « bissextile » si le nombre entier annee représente une année bissextile.

annee = 2002
if annee%4 == 0:
  ...
else:
  ...

3

Boucles ★★☆

→ Voir fiche n° 5 : Les boucles bornées
→ Voir fiche n° 6 : Les boucles non-bornées

Un professeur demande à ses élèves de réaliser un programme affichant tous les nombres entiers de $0$ à $100$. Ryem se souvient de la manière de programmer une boucle for et propose le programme suivant.

1. Quelles améliorations et corrections peut‑on proposer à Ryem pour que son programme fonctionne et soit le plus court possible ?

for i in range(0, 100):
  print(i)

2. Dans la suite du travail demandé par le professeur, Ryem doit reprendre le même exercice mais en utilisant une boucle while. Il propose le programme suivant, en s’inspirant de ce qu’il a fait avec la boucle for. Lorsque Ryem lance son programme, il obtient le message d’erreur « name i is not defined ». Expliquer cette erreur puis la corriger dans le programme de Ryem.


3. Lorsque Ryem lance le programme en ayant initialisé i, il constate que le programme n’affiche que des $0$ et semble ne pas s’arrêter. Modifier le programme pour résoudre ce problème et afficher les nombres entiers entre $0$ et $100$.

while i < 101:
  print(i)

4

Volume d'une sphère ★☆☆

→ Voir fiche n° 3 : Les fonctions

1. Quelle instruction faut-il écrire au début d’un programme pour pouvoir utiliser la constante $\pi$ dans ce programme ?


2. Rappeler la formule pour calculer le volume d’une sphère de rayon $\text{R}$.


3. Rappeler le mot‑clé utilisé par Python pour permettre d’introduire la définition d’une fonction.


4. Écrire une fonction volume_sphere qui prend en paramètre un nombre réel positif $\text{R}$ et qui renvoie le volume de la sphère de rayon $\text{R}$.

5

Algorithme de tri ★★★

→ Voir fiche n° 2 bis : Les listes
→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 5 : Les boucles bornées

On considère une liste définie par extension par l’instruction maliste = [1, 7, 3, 5, 1, 2, 8].

Expérimentation :
1. Que fait l’instruction maliste.remove(7) sur la variable maliste ?


2. Que fait l’instruction maliste.remove(1) sur la variable maliste ?

maliste = [1, 7, 3, 5, 1, 2, 8]

Application :
La fonction tri_selection suivante prend en paramètre une liste de nombres et renvoie une nouvelle liste contenant les mêmes éléments triés par ordre croissant. Cette fonction choisit l’élément le plus petit de la liste, grâce à la fonction minimum, l’ajoute à la nouvelle liste puis le supprime de l’ancienne liste.

1. Compléter la fonction tri_selection.

2. Modifier l’une des deux fonctions, ou les deux, pour que la fonction tri_selection renvoie la liste triée par ordre décroissant.



3. Proposer deux situations mathématiques dans lesquelles le fait que la liste soit triée est utile.

def minimum(liste):
  mini = liste[0]
  for i in range(len(liste)):
    if liste[i] < mini:
      mini = liste[i]
  return mini

def tri_selection(liste):
  liste_triee = ...
    for i in range(len(liste)):
      a = minimum(liste)
      liste.remove(a)
      ...

  return lise_triee

6

Le théorème de Fermat-Wiles ★★☆

→ Voir fiche n° 5 : Les boucles bornées

Le théorème de Fermat-Wiles affirme que, pour tout entier naturel $n > 2$, il ne peut pas exister trois nombres entiers $x$, $y$ et $z$ tels que $x^n + y^n = z^n$. On souhaite, dans cet exercice, conjecturer cette affirmation pour $n=3$.

1. Compléter les lignes 1 et 2 pour que le programme ci-après teste toutes les possibilités pour $x$ et $y$ dans l’intervalle $[1;1000]$.

2. Dans le cas de ce programme, quelle valeur maximale pourra prendre la variable $z$ ? En déduire la ligne 3 du programme.


3. Tester le programme et conclure.

Ce théorème a été conjecturé par le Français Pierre Fermat au 17ème siècle et démontré seulement en 1997 par le Britannique Andrew Wiles.

for x in range(1, ...):
  for y in range(1, ...):
    for z in range(1, ...):
      if z**3 == x**3 + y**3:
        print(x, y, z)

7

Triangles rectangles presque isocèles ★★☆

→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 2 bis : Les listes
→ Voir fiche n° 4 : Les instructions conditionnelles

On appelle triangle rectangle presque isocèle un triangle rectangle dont les côtés sont des nombres entiers et dont les côtés de l’angle droit sont des nombres entiers consécutifs.

1. Donner un exemple de triangle rectangle presque isocèle.


2. Compléter le programme suivant pour qu’il trouve tous les triangles rectangles presques isocèles dont la longueur du plus petit côté est inférieure à $10000$.

3. On considère un triangle rectangle tel que :

• la longueur du plus petit côté est donnée par un terme de la suite $(u_n)$ définie par récurrence par $u_0=0$, $u_1=3$ et par $u_{n+1}=6u_n-u_{n-1}$ ;
• la longueur d'un côté de l'angle droit est $u_{n+1}+1$.
  

On admet que ce triangle est presque isocèle.
À l’aide de cette remarque, proposer un programme permettant de calculer plus rapidement les côtés de triangles rectangles presques isocèles.

from math import *

for i in range(1000):
  a = sqrt(i**2 + (i + 1)**2)
  if … :
    print(i, i + 1, int(a))

8

Suites extraites ★☆☆

→ Voir fiche n° 2 bis : Les listes
→ Voir fiche n° 5 : Les boucles bornées

Les premiers termes d’une suite $(u_n)_{n \geqslant 1}$ sont donnés dans une liste.

1. Expliquer ce que permet de faire la fonction listes_extraites ci-dessous.


2. Construire une fonction en Python qui prend en entrée les variables liste_impair et liste_pair renvoyées par la fonction ci-dessous et qui renvoie la liste donnée en paramètre dans la fonction listes_extraites.

def listes_extraites(liste):
  taille = len(liste)
  liste_pair = []
  liste_impair = []
  for element in range(taille):
    if element%2 == 0:
      liste_impair.append(liste[element])
    else:
      liste_pair.append(liste[element])
  return (liste_impair, liste_pair)

9

Anagrammes ★★☆

→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 5 : Les boucles bornées

1. Écrire une fonction Python qui donne une liste de tous les nombres entiers naturels de $5$ chiffres composés uniquement des chiffres $1$, $2$ ou $3$.

2. Écrire une fonction Python qui donne une liste de tous les nombres entiers naturels de $5$ chiffres composés uniquement des chiffres $1$, $2$ ou $4$.

10

Algorithme CORDIC ★★★

→ Voir fiche n° 1 : Algorithme en langage naturel
→ Voir fiche n° 5 : Les boucles bornées
→ Voir fiche n° 6 : Les boucles non bornées

Lors des débuts de l’informatique, la puissance des ordinateurs était très limitée. C’est dans ce contexte que l’algorithme CORDIC a été proposé pour permettre le calcul du logarithme d’un nombre strictement positif en utilisant au minimum les faibles ressources des ordinateurs. L’algorithme CORDIC stocke en mémoire certaines valeurs particulières du logarithme et se sert de ces valeurs pour calculer les valeurs souhaitées par l’utilisateur.

1. Remplir le tableau suivant.


2. Soit $x$ un nombre réel dans l’intervalle $[1\,;10]$. L’algorithme CORDIC est le suivant.

$\begin{array}{|l|l|} \hline \text { 1. } & y \leftarrow \text{ln}(10) \\ \text { 2. } & \text{Tableau} \leftarrow \text{Tableau de la question 1.} \\ \text { 3. } & \text {Pour } i \text{ allant de } 0\text{ à }10 \text{ : } \\ \text { 4. } &     z \leftarrow 1+10^{-i} \\ \text { 5. } &     \text {Tant que } x \times z \leqslant 10 \text{ : } \\ \text { 6. } &         x \leftarrow x \times z \\ \text { 7. } &         y \leftarrow y - \text{Tableau}[z] \\ \text { 8. } & \text { Renvoyer } y \\ \hline \end{array}$

Programmer une fonction cordic_base permettant d’implémenter cet algorithme puis la tester (on pourra simuler l’appel au tableau par l’utilisation de la fonction log). Comparer les valeurs obtenues avec celle données par la calculatrice.

3. a. Soit $t \in ]0 \,; + \infty [$. Montrer qu’il existe $\text{N} \in \Z$ et $t_0 \in [1\,; 10]$ tels que $\text{ln}(t) = \text{N} \text{ln}(10)+\text{ln}(t_0)$.


b. En déduire une méthode pour calculer le logarithme d’un nombre réel strictement positif quelconque à l’aide de l’algorithme de CORDIC.


4. Écrire une fonction cordic_général permettant de calculer le logarithme d’un nombre réel strictement positif quelconque. On pourra utiliser la fonction cordic_base.

11

Debugger une fonction ★☆☆

→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 4 : Les instructions conditionnelles
→ Voir fiche n° 5 : Les boucles bornées

Dans son cours de mathématiques, Josy a découvert la conjecture selon laquelle, pour tout entier $n$, on a $\displaystyle \sum_{k=0}^n k^3= \left( \sum_{k=0}^n k \right)^2$. Pour tester cette affirmation, elle a écrit la fonction suivante qui prend en paramètre un nombre entier n et qui renvoie True ou False selon que la conjecture est vérifiée ou non pour n. Malheureusement cette fonction ne fonctionne pas.

1. Expliquer pourquoi la fonction de Josy présente une erreur à la ligne 7.


2. Le programme de Josy ne fonctionne toujours pas. Expliquer pourquoi.

def conjecture(n):
somme = 0
sommecubes = 0
for k in range(n + 1):
  somme = somme + k
  sommecubes = sommecubes + k**3
carresomme = somme
if carresomme == sommecubes:
  True
else:
  False

12

Carré magique ★★☆

→ Voir fiche n° 1 : Algorithme en langage naturel
→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 2 bis : Les listes
→ Voir fiche n° 4 : Les instructions conditionnelles
→ Voir fiche n° 5 : Les boucles bornées

On dit qu’un carré est magique si, et seulement si, les sommes des termes sur chaque ligne, chaque colonne et chaque diagonale sont égaux. Pour tester si un carré ayant $n+1$ lignes et $n+1$ colonnes est magique, on propose l’algorithme suivant.

$\begin{array}{|l|l|} \hline \text { 1. } & somme \leftarrow 0 \\ \text { 2. } & \textbf{pour } i \text{ allant de } 0 \text{ à } n \textbf{ faire }\\ \text { 3. } &          somme \leftarrow somme+tableau[i][i]\\ \text { 4. } & \textbf{fin}\\ \text { 5. } & somme2 \leftarrow 0\\ \text { 6. } & \textbf{pour } i \text{ allant de } 0 \text{ à } n \textbf{ faire }\\ \text { 7. } &          somme2 \leftarrow somme2+tableau[i][n-i]\\ \text { 8. } &\textbf{fin}\\ \text { 9. } & \textbf{si } somme2 \ne somme \textbf{ alors}\\ \text { 10. } &          \text{Renvoie Faux} \\ \text { 11. } & \textbf{fin} \\ \text { 12. } & \textbf{pour } i \text{ allant de } 0 \text{ à } n \textbf{ faire } \\ \text { 13. } &          somme3 \leftarrow 0 \\ \text { 14. } &          \textbf{pour } j \text{ allant de } 0 \text{ à } n \textbf{ faire }\\ \text { 15. } &                   somme3 \leftarrow somme3+tableau[i][j]\\ \text { 16. } &          \textbf{fin}\\ \text { 17. } &          \textbf{si } somme3 \ne somme \textbf{ alors}\\ \text { 18. } &                    \text{Renvoie Faux}\\ \text { 19. } &          \textbf{fin}\\ \text { 20. } & \textbf{fin}\\ \text { 20. } & \textbf{pour } i \text{ allant de } 0 \text{ à } n \textbf{ faire }\\ \text { 22. } &          somme4 \leftarrow 0 \\ \text { 23. } &         \textbf{pour } j \text{ allant de } 0 \text{ à } n \textbf{ faire }\\ \text { 24. } &                  somme4 \leftarrow somme4+tableau[j][i]\\ \text { 25. } &          \textbf{fin}\\ \text { 26. } &         \textbf{si } somme4 \ne somme \textbf{ alors}\\ \text { 27. } &                    \text{Renvoie Faux}\\ \text { 28. } &         \textbf{fin}\\ \text { 29. } &\textbf{fin}\\ \text { 30. } &\textbf{sinon}\\ \text { 31. } &         \text{Renvoie Vrai}\\ \text { 32. } &\textbf{fin}\\ \hline \end{array}$

1. Programmer cet algorithme en Python pour tester si un tableau de 3 lignes et 3 colonnes est un carré magique.

2. Généraliser ce programme à un tableau de $n$ lignes et $n$ colonnes.