Python en Mathématiques - Niveau 2

Algorithmes de référence sur les listes

Somme des éléments

Écrire une fonction en Python nommée somme() et qui respecte la spécification suivante :

Paramètres une liste L contenant des entiers
Valeur renvoyée un entier, la somme des éléments de la liste L
  • Un algorithme
  • Une solution
  • Une autre solution
  • On initialise la somme à zéro.
  • On parcourt chacun des éléments de la liste L.
  • On incrémente la somme de chaque élément parcouru.

Parcours par les éléments


def somme(L):
    s = 0
    for element in L:
        s = s+element
    return s
		

Parcours par les éléments


def somme(L):
    s = 0
    for i in range(len(L)):
        s = s+L[i]
    return s
		

Moyenne des éléments

Écrire une fonction en Python nommée moyenne() et qui respecte la spécification suivante :

Paramètres une liste L contenant des entiers
Valeur renvoyée un entier, la moyenne des éléments de la liste L
  • Un algorithme
  • Une solution
  • Une autre solution

On calcule la somme des éléments, puis on renvoie la moyenne.

Parcours par les éléments


def moyenne(L):
    s = 0
    for element in L:
        s = s+element
    return s/len(L)
		

Parcours par les éléments


def moyenne(L):
    s = 0
    for i in range(len(L)):
        s = s+L[i]
    return s/len(L)
		

Somme de deux listes

  1. Écrire une fonction en Python nommée somme_de() et qui respecte la spécification suivante :
    Paramètres deux listes L1 et L2 contenant le même nombre d'entiers
    Valeur renvoyée une liste dont chacun des éléments est la somme des éléments correspondants dans L1 et L2

    Un exemple :

    >>> L1 = [1, 4, 2, 4, 7]
    
    >>> L2 = [5, 2, 1, 8, 5]
    
    >>> somme_de(L1, L2)
    [6, 6, 3, 12, 12]
    
  2. Modifier le code de cette fonction pour qu'elle puisse renvoyer la « liste-somme » même si les deux listes saisies en paramètre n'ont pas le même nombre d'éléments. Les éléments surnuméraires sont conservés, c'est-à-dire considérés comme étant additionnés avec 0. Par exemple :
    >>> L1 = [1, 4, 2, 4, 7, 4, 2]
    
    >>> L2 = [5, 2, 1, 8, 5]
    
    >>> L3 = somme_de(L1, L2)
    
    >>> L3
    [6, 6, 3, 12, 12, 4, 2]
    
    >>> somme_de(L2, L3)
    [11, 8, 4, 20, 17, 4, 2]
    
  • Question 1°/
  • Question 2°/

def somme_de(L1, L2):
    M = []
    for i in range(len(L1)):
        M.append(L1[i]+L2[i])
    return M
		

def somme_de(L1, L2):
    if len(L1) < len(L2):
        n = len(L1)
    else:
        n = len(L2)
    M = []
    for i in range(n):
        M.append(L1[i]+L2[i])
    for i in range(n, len(L1)):
        M.append(L1[i])
    for i in range(n, len(L2)):
        M.append(L2[i])
    return M
		

Seuil

Écrire une fonction en Python nommée seuil() et qui respecte la spécification suivante :

Paramètres Une liste L contenant des entiers,
un entier s
Valeur renvoyée une liste contenant les éléments de L supérieurs ou égaux à s

Un exemple :

>>> L = [1, 4, 2, 4, 7]

>>> seuil(L, 2)
[4, 2, 4, 7]
  • Une solution

def seuil(L, s):
    M = []
    for element in L:
        if element >= s:
			M.append(element)
    return M
		

Extremum

Écrire une fonction en Python nommée minimum() et qui respecte la spécification suivante :

Paramètres Une liste L contenant des entiers
Valeur renvoyée le plus petit entier contenu dans L

Un exemple :

>>> L = [1, 4, 2, 4, 7]

>>> minimum(L)
1
  • Un algorithme
  • Une solution

Avant le parcours, le minimum est initialisé comme étant le premier élément de la liste.

Puis on parcourt la liste et on remplace le minimum provisoire par l'élément parcouru si celui-ci s'avère plus petit que le minimum provisoire.


def minimum(L):
    mini = L[0]
    for element in L:
        if element < mini:
			mini = element
    return mini
		

On peut faire de même en parcourant les indices :


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

Effacer par paire !

  • Points du programme abordés
  • Support élève
  • Calcul de 1+2+...+n
  • Générer une liste (en extension, par ajouts successifs ou en compréhension)
  • Manipuler des éléments d’une liste (ajouter, supprimer...) et leurs indices
  • Parcourir une liste
  • Itérer sur les éléments d’une liste

Cet exercice est disponible dans ce fichier html.

Il a été généré par ce fichier jupyter notebook à l'aide d' anaconda.

la situation

Aurore écrit sur un tableau tous les entiers de 1 à 2019.
Puis elle en sélectionne deux au hasard ($a$ et $b$), les efface et écrit à la place le nombre $\left| b - a\right|$.

Elle recommence l'opération jusqu'à n'avoir plus qu'un seul entier au tableau.
Le dernier nombre écrit au tableau est 3.

On aimerait montrer qu'Aurore s'est trompée dans ses opérations.

Partie 1

  1. Écrire une fonction Python nommée somme(), prenant en entrée une liste d'entiers et renvoyant en sortie la somme des éléments de la liste.
  2. Utiliser cette fonction pour déterminer la somme des entiers écrits initialement au tableau.
  3. Vérifier ce calcul à l'aide d'une formule appropriée.
  • Question 1°/
  • Questions 2°/ et 3°/

def somme(liste):
    s = 0
    for x in liste:
        s = s+x
    return s
		

On vérifie que la somme 1+2+...+2019 a pour valeur 2 039 190.

2°/ Par utilisation du programme :

>>> somme([i for i in range(1, 2020)])
2039190

3°/ Par calcul : formule usuelle de la somme de termes en progression arithmétique.

Partie 2

  1. Écrire une fonction Python nommée etape(), prenant en entrée une liste d'entiers. La fonction devra simuler une étape du processus décrit en introduction :
    • créer une nouvelle liste L ayant même contenu que la liste initiale, sauf deux éléments a et b supprimés (choisis au hasard).
    • ajouter la valeur absolue de la différence de a et b à L.
    • renvoyer L.
  2. En déduire une fonction Python nommée plusieurs_parties(), qui simule plusieurs « parties » du jeu d'Aurore.
    Quelle conjecture peut-on émettre sur le nombre qui reste seul au tableau en fin de processus ?
  3. Exprimer la somme S' obtenue après une étape en fonction de la somme S avant cette étape.
    Pour cela, on s'interdira d'utiliser la fonction valeur absolue : on envisagera deux cas.
  4. Pouvez-vous maintenant garantir qu'Aurore a commis une erreur de calcul ?
  • Question 1°/
  • Question 2°/
  • Question 3°/
  • Question 4°/

Il existe bien des façons de répondre à la demande en Python.

En voici une :


from random import randint

def etape(liste):
    # un indice au hasard:
    i = randint(0, len(liste)-1)
    # un second indice au hasard, distinct du premier
    j = i
    while j == i:
        j = randint(0, len(liste)-1)

    a = liste[i]
    b = liste[j]
    L = [liste[k] for k in range(len(liste)) if k!=i and k!=j]
    L.append(abs(b-a))
    return L
		

En voici une autre :


from random import randint

def etape(liste):
    L = [x for x in liste]
    a = L.pop(randint(0, len(L)-1))
    b = L.pop(randint(0, len(L)-1))
    L.append(abs(b-a))
    return L
		

On lance des parties avec le code ci-dessous.
Une cinquantaine de résultats obtenus semble suggérer qu'une fin de partie est toujours paire.


		
		
  • Si a > b, alors S' = S - (a+b) + (a-b), c'est-à-dire S' = S -2b.
  • Sinon S' = S -2a.

Dans tous les cas la parité de S est un invariant : le dernier nombre obtenu ne peut être que pair et ne saurait être 3.