✔ Compétence : Utiliser des variables de type Liste
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 2 bis : Les listes

Le programme ci-après définit trois listes. Pour chacune d'elle :

1. Énumérer tous les éléments de la liste à la fin de l'exécution du programme.
2. Modifier la définition pour qu'elle contienne la liste des nombres pairs de 0 à 20.

liste1 = [1, 2, 3, 4, 5, 6, 8, 13, 15, 46, 11]
liste2 = [7*i for i in range(12)]
liste3 = []

for i in range(20):
  liste3.append(i*i)

print(liste1)
print(liste2)
print(liste3)

✔ Compétence : Utiliser des variables de type Liste et de type Chaîne de caractères
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 2 bis : Les listes

1. Compléter le programme suivant pour qu'il affiche la chaîne de caractère "BIEN".
2. Modifier le programme pour qu'il affiche "OLEY".

l1 = ["B", "O", "N"]
l2 = ["B", "I", "L", "L"]
l3 = ["B", "E", "N"]
l4 = ["B", "U", "N", "N", "Y"]

a1 = l1#A compléter
a2 = l2#A compléter
a3 = l3#A compléter
a4 = l4#A compléter


print(a1 + a2 + a3 + a4)

✔ Compétence : Utiliser des variables de type Liste
✔ Compétence : Utiliser une fonction
✔ Compétence : Utiliser une instruction conditionnelle
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 2 bis : Les listes

→

Voir fiche n° 3 : Les fonctions

→

Voir fiche n° 4 : Les instructions conditionnelles

→

Voir fiche n° 5 : Les boucles bornées

Écrire une fonction supprime_doublons() qui prend une liste de nombres en argument et qui renvoie une liste contenant tous les éléments de la liste de départ une et une seule fois.

serie_statistique = [2, 3, 7, 9, 2, 2, 4, 5, 3]

def supprime_doublons(liste):
  #A compléter

print(supprime_doublons(serie_statistique))

✔ Compétence : Utiliser une instruction conditionnelle
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 4 : Les instructions conditionnelles

→

Voir fiche n° 5 : Les boucles bornées

On se place dans un repère orthonormé (\text{O} ; \text{I}, \text{J}). L'une des méthodes pour obtenir une approximation de \pi consiste à choisir au hasard un grand nombre de points ayant une abscisse et une ordonnée dans l'intervalle [0 \: ;1]. La proportion de ceux qui sont à l'intérieur du quart de cercle de centre \text{O} et de rayon 1 est une approximation de \dfrac{\pi}{4}.

1. Compléter le programme ci-après.
2. Tester le programme à plusieurs reprises. L'approximation obtenue est-elle fiable ?

from random import*

compte = 0

for i in range (100000):
  x = random()
  y = random()
  distance = #A compléter
  if #A compléter
    compte = compte + 1

proportion = compte/100000
pi = 4*proportion
print(pi)

✔ Compétence : Utiliser une variable de type Liste
✔ Compétence : Utiliser une fonction
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 2 bis : Les listes

→

Voir fiche n° 3 : Les fonctions

→

Voir fiche n° 4 : Les instructions conditionnelles

→

Voir fiche n° 5 : Les boucles bornées

La factorielle d'une nombre entier positif, notée n! est définie par : 0!=1 et n! = (n-1)! \times n.

1. Écrire une fonction factorielle() qui prend en argument un nombre entier positif n et qui renvoie n!.
2. Écrire une fonction liste_factorielle() qui prend en argument un nombre entier positif n et qui renvoie une liste contenant la factorielle de tous les nombres entiers positifs strictement plus petits que n.

def factorielle(n):
  #A compléter

def liste_factorielle(n):
  #A compléter

print(liste_factorielle(6))

✔ Compétence : Utiliser des variables de type Liste et de type Chaîne de caractères
✔ Compétence : Utiliser une instruction conditionnelle
✔ Compétence : Utiliser une boucle bornée
→

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 considère la chaîne de caractères "monprinceviendra".

1. Écrire un programme qui affiche deux listes : voyelles et consonnes dans lesquelles on retrouvera respectivement les voyelles et les consonnes de la chaîne de caractères.
2. Écrire un programme qui détermine le nombre de voyelles contenues dans la chaîne de caractères "alea jacta est".

✔ Compétence : Utiliser des instructions conditionnelles
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 4 : Les instructions conditionnelles

→

Voir fiche n° 5 : Les boucles bornées

On se place dans un repère orthonormé (\text{O} ; \text{I}, \text{J}).
À l'aide d'une méthode de Monte Carlos comme dans l'

exercice numéro 4

, écrire un programme permettant de calculer une approximation de l'aire située entre la parabole d'équation y=x^2, l'axe des abscisses et les droites d'équations x=0 et x=1.

✔ Compétence : Utiliser des variables de type Liste
✔ Compétence : Utiliser des fonctions
✔ Compétence : Utiliser des instructions conditionnelles
✔ Compétence : Utiliser une boucle bornée
→

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 triangle rectangle est presque isocèle lorsque la longueur de ses côtés est un nombre entier et que les longueurs des deux côtés de l'angle droit sont des nombres entiers consécutifs.

1. Montrer qu'un triangle dont les côtés mesurent 3 ; 4 et 5 est presque isocèle.

2. Compléter le programme ci-après pour trouver tous les triangles rectangles presque isocèles dont le plus petit côté est inférieur ou égal à 1\,000\,000. Stocker les réponses dans la liste presque_rectangle.
3. Pour chacun des éléments de la liste (sauf le dernier), afficher le quotient de cet élément par le suivant. Que remarque-t-on ?

from math import sqrt

presque_rectangle = []

for i in #A compléter
  carre_hypothenuse = i*i + (i + 1)*(i + 1)
  if #A compléter
    presque_rectangle.append(i)

print(presque_rectangle)

✔ Compétence : Utiliser des variables de type Liste
✔ Compétence : Utiliser des fonctions
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 2 bis : Les listes

→

Voir fiche n° 3 : Les fonctions

→

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

La fonction ci-après crée et renvoie automatiquement une liste de 20 nombres entiers entre 0 et 100.

1. Tester le programme.
2. Compléter le programme pour qu'il affiche deux listes : l'une contenant les nombres impairs de la liste créée et l'autre contenant les nombres pairs.

from random import randint

def liste_reference():
  liste = []
  for i in range(20):
    liste.append(randint(0, 100))
  return liste

#A compléter

print(liste_reference())

✔ Compétence : Utiliser des variables de type Liste
✔ Compétence : Utiliser des fonctions
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 2 bis : Les listes

→

Voir fiche n° 3 : Les fonctions

→

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

En utilisant le même programme que l'exercice précédent, créer cette fois-ci deux listes pour trier les nombres inférieurs ou égaux à 50 et ceux strictement supérieur à 50.

✔ Compétence : Utiliser des variables de type Liste
✔ Compétence : Utiliser des fonctions
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 2 bis : Les listes

→

Voir fiche n° 3 : Les fonctions

→

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

Soient a, b, c et d quatre réels tels que a \neq 0. Pour résoudre une équation de degré 3 de la forme ax^3+bx^2+cx+d=0, on utilise le discriminant \Delta=18abcd-4b^3d+b^2c^2-4ac^3-27a^2d^2.

• Si \Delta>0 l'équation admet trois solutions réelles distinctes.
• Si \Delta=0 l'équation admet une racine double ou triple.
• Si \Delta\lt0 l'équation admet 1 solution réelle.

Écrire un programme qui donne le nombre de solutions d'une équation de degré 3 lorsque les coefficients a, b, c et d sont connus. On pourra prendre exemple sur l'

exercice 1

de la partie Algèbre.

✔ Compétence : Utiliser des variables de type Liste
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

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

Le théorème des quatre carrés affirme que tout nombre entier peut s'écrire comme la somme de quatre carrés de nombres entiers. Ainsi 20=1^2+3^2+3^2+1^2. On constate qu'on ne demande pas à ce que les quatre nombres soient tous distincts.

1. Soit n \in \mathbb{N}.
Compléter le programme ci-après pour qu'il affiche une liste de quatre nombres entiers positifs dont la somme des carrés est égale à n.
2. Ce programme présente un défaut : il affiche plusieurs fois la même réponse. Modifier le programme pour résoudre ce défaut.

nombre = 50

for i in range(nombre):
  for j in range(nombre):
    for k in range(nombre):
      for h in range(nombre):
        if #A compléter

✔ Compétence : Utiliser des variables de type Liste
✔ Compétence : Utiliser des fonctions
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 2 bis : Les listes

→

Voir fiche n° 3 : Les fonctions

→

Voir fiche n° 5 : Les boucles bornées

Martin a lu dans un livre de mathématiques que, pour tout nombres entiers naturel n, la somme des cubes des n premiers nombres entiers naturel est égal au carré de la somme de ces n premiers nombres entiers naturels.

1. Compléter les fonctions cube() et carre() ci-après qui renvoient respectivement le cube et le carré du nombre qui leur est donné en paramètre.
2. Compléter la fonction somme() qui renvoie la somme de la liste donnée en paramètre.
3. En utilisant les fonctions cube(), carre() et somme(), écrire un programme qui permet de tester, pour une valeur de n donnée, l'affirmation du livre de Martin.

def cube(k):
	#A compléter

def carre(l):
	#A compléter

def somme(liste):
	#A compléter


n = 10

#A compléter

✔ Compétence : Utiliser des fonctions
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 3 : Les fonctions

→

Voir fiche n° 5 : Les boucles bornées

Au lycée, Elena a constaté que 5^2 = 4^2 + 3^2. Mais il constate également que 5^3>4^3+3^3 et que 5^4>4^4+3^4. Elena se demande alors si cette propriété est générale. Elena se pose donc la question de savoir si 5^n>4^n+3^n pour tout n>2.
Aider Elena à tester sa conjecture ?

✔ Compétence : Utiliser des variables de type Liste
✔ Compétence : Utiliser des fonctions
✔ Compétence : Utiliser des instructions conditionnelles
✔ Compétence : Utiliser une boucle bornée
→

Voir fiche n° 2 : Les variables

→ Voir fiche n° 2 bis : Les listes
→

Voir fiche n° 3 : Les fonctions

→

Voir fiche n° 4 : Les instructions conditionnelles

→

Voir fiche n° 5 : Les boucles bornées

Soit n \in \mathbb{N}.
On dit que n est un nombre parfait lorsqu'il est égal à la somme de ses diviseurs stricts (en excluant n).

1. a. Faire la liste des diviseurs de 6.

b. En déduire que 6 est un nombre parfait.

Compléter le programme ci-après pour qu'il affiche une liste de quatre nombres entiers positifs dont la somme des carrés est égale à n.
2. Montrer que 28 est un nombre parfait.

3. Compléter la fonction diviseurs() ci-après qui prend un nombre entier positif et renvoie la liste de ses diviseurs stricts.
4. Compléter la fonction parfait() qui prend un nombre entier positif en argument et renvoie 1 s'il est parfait et 0 sinon.
5. Compléter le programme pour qu'il fasse la liste des nombres parfaits inférieurs à 1\,000.

def diviseur(n):
  # A compléter


def parfait(n):
  # A compléter

# A compléter

✔ Compétence : Utiliser des fonctions
✔ Compétence : Utiliser des boucles
→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 3 : Les fonctions

→

Voir fiche n° 5 : Les boucles bornées

→

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

On considère la suite (u_n) définie pour tout n \in \mathbb{N} par u_n=\dfrac{4\times (-1)^n}{2n+1}.

1. Écrire une fonction terme() qui prend en argument un nombre entier naturel n et qui renvoie u_n.
2. Compléter le programme pour qu'il calcule la somme des 2\,000 premiers termes de cette suite. Vers quelle valeur remarquable cette somme semble-t-elle converger ?
3. À l'aide de l'instruction pi du module math, trouver la plus petite valeur de N \in \mathbb{N} telle que \vert u_N - \pi \vert \lt 0{,}001.

✔ Compétence : Utiliser des fonctions
✔ Compétence : Utiliser des instructions conditionnelles
✔ Compétence : Utiliser des boucles
→

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

→

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

Une puce est placée à l'origine d'une droite graduée. Elle se déplace, à chaque saut, d'une longueur de 1 vers la droite ou vers la gauche. La probabilité d'aller vers la gauche est p \in [0\, ; 1]. On cherche à savoir au bout de combien de sauts la puce atteint -4 ou 4.

1. Compléter la fonction marche() ci-après qui renvoie le nombre de sauts nécessaires à la puce pour atteindre -4 ou 4, p étant donné en paramètre de la fonction.
2. Répéter 10\,000 fois l'expérience et stocker dans une liste le nombre de sauts de chacune des expériences.
3. Afficher le nombre de saut moyen.
4. Représenter dans un diagramme en bâtons ces nombres de sauts.

from random import random
from matplotlib.pyplot import *


def marche(probabilite):
  #A compléter
  return temps


#A compléter

hist(durees, bins = 60)