Mathématiques Académie de Normandie

Table des matières

Retour au sommaire général

• A) Manipulations plus expertes
• 1. Fonction exponentielle et courbe d’Euler
• 2. Algorithme de Kaprekar
• 3. La traversée du pont

• B) Albums de vignettes et rareté ressentie : le problème du collectionneur
• 1. Écriture d’un algorithme en Python modélisant le problème
• 2. Taille de la collection variable
• 3. Nombre de collectionneurs variable

---

A) Manipulations plus expertes

retour

1. Fonction exponentielle et courbe d’Euler

script

def methode_euler(x,y,h,n) : X_liste=[x] Y_liste=[y] for i in range(n) : x = x+h y = y+y*h X_liste.append(x) Y_liste.append(y) return X_liste,Y_liste import matplotlib.pyplot as plt # Configuration des axes ax=plt.gca() ax.spines["bottom"].set_position("zero") # axe positionné à 0 ax.spines["left"].set_position("zero") # axe positionné à 0 ax.spines["right"].set_color("none") # pas de couleur à  droite ax.spines["top"].set_color("none") # pas de couleur en haut ax.xaxis.set_ticks_position("bottom") # Position des abscisses en dessous ax.yaxis.set_ticks_position("left") # Position des ordonnées à gauche plt.grid() # grille activée # Partie de la courbe pour x > 0 X_liste1,Y_liste1 = methode_euler(0,1,0.1,20) # Partie de la courbe pour x < 0 X_liste2,Y_liste2 = methode_euler(0,1,-0.1,20) # Concaténation des listes X_liste = X_liste1 + X_liste2 Y_liste = Y_liste1 + Y_liste2 # Tracé du graphique plt.plot(X_liste,Y_liste,"b.") # Affichage du graphique plt.show()

retour

2. Algorithme de Kaprekar

script de la version 1

def grand(n) : chiffre_unite = n % 10 chiffre_dizaine = (n % 100) // 10 chiffre_centaine = n // 100 maxi = max(chiffre_centaine,chiffre_dizaine,chiffre_unite) mini = min(chiffre_centaine,chiffre_dizaine,chiffre_unite) moyen = (chiffre_centaine+chiffre_dizaine+chiffre_unite)-(maxi+mini) s = maxi*100 + moyen*10 + mini return s def petit(n) : chiffre_unite = n % 10 chiffre_dizaine = (n % 100) // 10 chiffre_centaine = n // 100 maxi = max(chiffre_centaine,chiffre_dizaine,chiffre_unite) mini = min(chiffre_centaine,chiffre_dizaine,chiffre_unite) moyen = (chiffre_centaine+chiffre_dizaine+chiffre_unite)-(maxi+mini) s = mini*100 + moyen*10 + maxi return s def kaprekar(n) : u = n liste_valeurs = [u] while u != 495 : u = grand(u) - petit(u) liste_valeurs.append(u) return liste_valeurs

console

kaprekar(217)

script de la version 2

# Dans toutes ces fonctions : la première ligne ("assert") est optionnelle. # Elle sert à vérifier que le "n" entré est de type entier. def petit_chaine(n) : assert type(n) == int , "n n'est pas entier" chaine = str(n) # Conversion de n en chaine liste_triee = sorted(chaine) # Tri de la chaine ; le résultat est une liste chaine = "".join(liste_triee) # Concaténation de la liste en une chaine return int(chaine) # On retourne la chaine convertie en entier def inversion(n) : assert type(n) == int , "n n'est pas entier" chaine = str(n) # Conversion de n en chaine longueur = len(chaine) # Longueur de la chaine r = "" # Initialisation de la variable de retour (chaine) for k in range(longueur): # Reconstruction de la chaine r = r + chaine[longueur-1-k] # en partant du dernier caractère return int(r) # Variante pour seulement 3 chiffres à inverser def inversion_trois_chiffres(n): # n entier à 3 chiffres assert type(n) == int , "n n'est pas entier" N = str(n) L = [N[2],N[1],N[0]] return int("".join(L)) def kaprekar(n) : assert type(n) == int, "n n'est pas entier" u = n liste_valeurs = [u] while u != 495 : u = petit_chaine(u) u = inversion(u)-u liste_valeurs.append(u) return liste_valeurs

console

kaprekar(436)

script de la version 3

# Dans toutes ces fonctions : la première ligne ("assert") est optionnelle. # Elle sert à vérifier que le "n" entré est de type entier. def petit_par_minimum(n) : assert type(n) == int , "n n'est pas entier" liste = list(str(n)) # Conversion de n en chaine, puis en liste k = len(liste) # Longueur de la liste r = "" # Initialisation de la variable de retour (chaine) while k > 0 : # Tant que la liste n'est pas vide mini = min(liste) # Trouver le plus petit élément de la liste liste.remove(mini) # L'enlever r = r + mini # Le placer dans la chaine résultat k = k - 1 # La taille de la liste décroit return int(r) # On retourne la chaine convertie en entier # Variante sans calcul de la longueur de la liste def petit_par_minimum_variante(n) : # n entier à 3 chiffres assert type(n) == int, "n n'est pas entier" N1 = str(n) L1 = [N1[0],N1[1],N1[2]] L2 = [] while L1 != [] : element = min(L1) L1.remove(element) L2.append(element) return int("".join(L2)) def inversion(n) : assert type(n) == int , "n n'est pas entier" chaine = str(n) # Conversion de n en chaine longueur = len(chaine) # Longueur de la chaine r = "" # Initialisation de la variable de retour (chaine) for k in range(longueur) : # Reconstruction de la chaine r = r + chaine[longueur-1-k] # en partant du dernier caractère return int(r) # Variante pour seulement 3 chiffres à inverser def inversion_trois_chiffres(n) : # n entier à 3 chiffres N = str(n) L = [N[2],N[1],N[0]] return int("".join(L)) def kaprekar(n) : assert type(n) == int , "n n'est pas entier" u = n liste_valeurs = [u] while u != 495 : u = petit_par_minimum(u) u = inversion(u)-u liste_valeurs.append(u) return liste_valeurs

console

kaprekar(517)

retour

3. La traversée du pont

script

import matplotlib.pyplot as plt from random import * def traversee_une_fois() : # Réglages d'appoint de la fenêtre graphique ax = plt.gca() ax.spines["bottom"].set_position("zero") plt.grid(True) plt.plot([0,10],[-2,-2],"-b") # Trace des plt.plot([0,10],[2,2],"-b") # bords du pont plt.axis([0,10,-3,3]) # Initialisation des listes # des abscisses et ordonnées du marcheur X = [0] Y = [0] while X[-1] < 10 and abs(Y[-1]) <= 2 : de = randint(0,2) X.append(X[-1]+1) Y.append(Y[-1]+de-1) plt.plot(X,Y,"-or") plt.show() if abs(Y[-1]) <= 2 and X[-1] == 10 : s = 1 else : s = 0 return s def traversee_une_fois_sans_graphe() : X = [0] Y = [0] while X[-1] < 10 and abs(Y[-1]) <= 2 : de = randint(0,2) X.append(X[-1]+1) Y.append(Y[-1]+de-1) if abs(Y[-1]) <= 2 and X[-1] == 10 : s = 1 else : s = 0 return s def traversee_multiple(n): # n traversées effectif = 0 for compteur in range(n) : if traversee_une_fois_sans_graphe() == 1 : effectif = effectif + 1 return effectif / n def explore_chemin(n,y) : r = 0 if n == 0 : if abs(y) <= 2 : r = 1 else : r = 0 else : if abs(y) <= 2 : for p in [-1,0,1] : r = r + explore_chemin(n-1,y+p) return r

console

traversee_une_fois() traversee_multiple(10) explore_chemin(3,0)

retour

B) Albums de vignettes et rareté ressentie : le problème du collectionneur

retour

1. Écriture d’un algorithme en Python modélisant le problème

script

from random import * from math import * import matplotlib.pyplot as plt ###################################### # Ecriture d'un algorithme en Python modélisant le problème ###################################### def collection() : ALBUM = [] FREQ = [] for compteur in range(480) : ALBUM.append(0) while min(ALBUM) == 0 : ALBUM[randint(0,479)] += 1 for compteur in range(480) : FREQ.append(ALBUM[compteur]/sum(ALBUM)) p = 1/480 freq_mini = p-1.96*sqrt(p*(1-p)/sum(ALBUM)) freq_maxi = p+1.96*sqrt(p*(1-p)/sum(ALBUM)) return max(ALBUM),sum(ALBUM),freq_mini,freq_maxi,FREQ

console

collection()

retour

2. Taille de la collection variable

script à rajouter à la suite du script précédent

###################################### # Taille de la collection variable ###################################### def album(n) : # n taille de la collection ALBUM = [] for compteur in range(n) : ALBUM.append(0) while min(ALBUM) == 0 : ALBUM[randint(0,n-1)] += 1 return sum(ALBUM) def achats_moyen(n,e) : # n taille collection, e nombre d'essais nb_achats = 0 for compteur in range(e) : nb_achats = nb_achats + album(n) return nb_achats/e def album_graph() : X_liste = [] Y_liste = [] for compteur in range(1,480+1) : X_liste.append(compteur) Y_liste.append(achats_moyen(compteur,10)) plt.plot(X_liste,Y_liste,"b.") plt.show()

console

album_graph()

retour

3. Nombre de collectionneurs variable

script à rajouter à la suite du script précédent

###################################### # Nombre de collectionneurs variables ###################################### def album_echange(n,p) : # n taille collection, p collectionneurs ALBUM = [] for compteur in range(n) : ALBUM.append(0) while min(ALBUM) < p : ALBUM[randint(0,n-1)] += 1 return sum(ALBUM) def achats_moyen2(n,p,e) : # n taille collection, p collectionneurs, e nombre d'essais nb_achats = 0 for compteur in range(e) : nb_achats = nb_achats + album_echange(n,p) return (nb_achats/e)/p def album_graph2(n,p,e) : # n taille collection, p collectionneurs, e nombre d'essais X_liste = [] Y_liste = [] for compteur in range(1,p+1) : X_liste.append(compteur) Y_liste.append(achats_moyen2(n,compteur,e)) plt.plot(X_liste,Y_liste,"b.") plt.show()

console

album_graph2(200,20,100) album_graph2(480,2,10) # Si votre ordinateur le permet ...

retour