Séance 3 - Exercices de programmation Python

Exercice 1

#Q1
jours = 365.25
heures = 24
minutes = 60
secondes = 60

print(f"Le nombre de secondes dans une année est {jours * heures * minutes * secondes}.")

Le nombre de secondes dans une année est 31557600.0.

#Q2
c = 299792458
distance_terre_lune = 384400000
secondes_heure = 60*60

print(f"La lumière peut effectuer {(c * secondes_heure)/(2 * distance_terre_lune)} aller-retour de la Terre à la Lune en une heure.")

La lumière peut effectuer 1403.81483975026 aller-retour de la Terre à la Lune en une heure.

Exercice 2

#Q1
def est_multiple_de_196(n):
    return (n % 196 == 0)

print(f"392 multiple de 196? -> {est_multiple_de_196(392)}")
print(f"3 multiple de 196? -> {est_multiple_de_196(3)}")

392 multiple de 196? -> True
3 multiple de 196? -> False

#Q2
# Avec une boucle for :
liste_carres_parfaits = []
for i in range(100):
    liste_carres_parfaits.append(i**2)

# Même chose avec une définition de liste en compréhension :
liste_carres_parfaits = [i*i for i in range(100)]

print(f'Les 100 premiers carrés parfaits sont : {liste_carres_parfaits}.')

Les 100 premiers carrés parfaits sont : [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721, 3844, 3969, 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, 9216, 9409, 9604, 9801].

#Q3
nb_carre_parfait = 0
for carre_parfait in list_carre_parfait:
    if(est_multiple_de_196(carre_parfait)):
        nb_carre_parfait+=1
print(f"Le nombre de carrés parfaits multiples de 196 entre 0 et 10 000 est de {nb_carre_parfait}")

Le nombre de carrés parfaits multiples de 196 entre 0 et 10 000 est de 8

#Q4
def est_premier(n):
    if n <= 0:
        print(f'Attention, valeur négative : {n} !')
        return False
    for i in range(2, n):
        if(n % i == 0):
            # Si on trouve un diviseur, alors n n'est pas premier.
            return False
    # Si on ne trouve aucun diviseur, alors n est premier.
    # Attention à l'indentation, très importante ici !
    return True


print(f"{est_premier(4)=}")
print(f"{est_premier(13)=}")

est_premier(4)=False
est_premier(13)=True

#Q5
n = 1234567
while not est_premier(n):
        n += 1

print(f"Le plus petit nombre premier supérieur à 1234567 est {n}.")

Le plus petit nombre premier supérieur à 1234567 est 1234577.

# On importe le package math pour pouvoir utiliser la fonction racine carré (sqrt).
import math

# Pour répondre à la question dans un temps raisonnable, il faut améliorere note fonction est_premier.
# Voir https://fr.wikipedia.org/wiki/Test_de_primalit%C3%A9
def est_premier(n):
    # Il suffit de chercher des diviseurs inférieurs à la racine carrée de n.
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True

n = 10**10
while not est_premier(n):
        n += 1

print(f"Le plus petit nombre premier supérieur à 10**10 est {n}.")

Le plus petit nombre premier supérieur à 10**10 est 10000000019.

Exercice 3

# Q1

# Pour la partie entière -> voir https://en.wikipedia.org/wiki/Floor_and_ceiling_functions
# On utilise donc la fonction floor du package math -> voir https://docs.python.org/fr/3/library/math.html#math.floor
# Avec une boucle for :
ma_suite = []
for i in range(10**5):
    ma_suite.append(math.floor(1e9*math.sin(i**2)))

# Avec une définition de liste en compréhension :
ma_suite = [math.floor(1e9*math.sin(i**2)) for i in range(10**5)]

print(f'Les 20 premiers éléments de cette suite sont : {ma_suite[:20]}')

Les 20 premiers éléments de cette suite sont : [0, 841470984, -756802496, 412118485, -287903317, -132351751, -991778854, -953752653, 920026038, -629887995, -506365642, 998815224, -491021594, -601999868, 939530055, -930094879, -999208035, -26521021, -404065220, 279386554]

# Q2

# Pour trouver l'élement le plus grand, on peut simplement utiliser la fonction max.
print(f"Le plus grand élément de cette liste est {max(ma_suite)}.")

Le plus grand élément de cette liste est 999999998.

# Q3
# La moyenne est la somme des éléments divisée par le nombre d'éléments.
print(f"La moyenne de cette liste {sum(ma_suite)/len(ma_suite)}.")

La moyenne de cette liste 1511835.23634.

# Q4
# Pour trouver la médiane, il faut trier la liste, puis faire la moyenne des deux éléments centraux.
liste_triee = sorted(ma_suite)  # Tri de la liste par ordre croissant.
milieu = len(liste_triee)//2 - 1  # Attention : pour une liste de taille 10, les indices au milieu sont 4 et 5.
mediane = (liste_triee[milieu] + liste_triee[milieu + 1]) / 2
print(f"La médiane de cette liste est {mediane}.")

La médiane de cette liste est 1065289.5.

# Q5

# Pour calculer le nombre d'éléments uniques on utilise le type 'set' (ensemble) de python. 
# En effet, lorsque l'on convertit une liste en ensemble, les éléments en double sont supprimés.
print(f"Il ya {len(set(ma_suite))} éléments uniques dans cette liste.")

Il ya 99988 éléments uniques dans cette liste.

# Q6

# Pour trouver le plus petit élément x de la liste qui est présent plusieurs fois, on cherche le premier élément qui est présent en double.
# Cela fonctionne à condition que la liste soit bien triée par ordre croissant.
# Il y a d'autres méthodes pour obtenir le même résultat.

def get_double(tab):
    for i in range(len(tab)-1):
        if(tab[i] == tab[i+1]):
            return tab[i]
   
liste_triee = sorted(ma_suite)
min_val = get_double(liste_triee)

print(f"Le plus petit élément x de la liste qui est présent plusieurs fois est {min_val}.")

Le plus petit élément x de la liste qui est présent plusieurs fois est -999999962.

# Q7

# Encore une fois, plusieurs méthodes sont possibles, en voici une utilisant une boucle for :
indices = []
for i in range(len(ma_suite)):
    if ma_suite[i] == min_val:
        indices.append(i)
        
print(f"Cet élément se trouve aux indices suivants dans la liste : {indices}.")

Cet élément se trouve aux indices suivants dans la liste : [66744, 78002].

Exercice 4

# Q1

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt    # Pour afficher des images.
plt.ion()      # Commande d'affichage immédiat (mode "interactif").

<contextlib.ExitStack at 0x1b3ca0f8850>

# Q2

img = np.array(Image.open("image_enigme.png"))  # Ici, l'image est dans le même répertoire que le notebook, adapter le chemin si ce n'est pas le cas.
matplotlib.pyplot.imshow(img)  # Afficher l'image.

<matplotlib.image.AxesImage at 0x1b39da0cf40>

# Q3
# On définit une fonction pour effectuer la transformation de l'image
def transformation(x, m):
    return m * (x % m)

# La bonne valeur de m est 16, voici comment la trouver :
fig = plt.figure(figsize=(4,4))
for m in range(1, 17):
    img_temp = transformation(img, m)
    Image.fromarray(img_temp).save(f'transformation_{m}.png')  # Pour sauvegarder les images.
    # Pour les afficher :
    fig.add_subplot(4, 4, m)  
    plt.imshow(img_temp)

Pour $m=16$, on obtient une image de chats.

# Q4
animaux = np.array(Image.open("transformation_16.png"))
fig = plt.figure(figsize=(5,5))
for i in range(75, 100):
    img_temp = np.array(animaux[::129, ::i])
    Image.fromarray(img_temp).save(f'text_{i}.png')  # Pour sauvegarder les images.
    # Pour les afficher :
    fig.add_subplot(5, 5, i-74)
    plt.imshow(img_temp)

Pour $i=82$, on obtient l'image cachée "Bravo".

# Q5
bravo = np.array(Image.open("text_82.png"))

# Je vous laisse comprendre la ligne suivante par vous-même.
# Ses principaux ingrédients à comprendre individuellement sont:
# La fonction join, la fonction str, et une définition de liste en compréhension.
binary_code = "".join(["0" if (bravo[i, i, 0] % 32 == 0) else "1" for i in range(21)])
print(f"{binary_code=}, clé = {int(binary_code, 2)}")

binary_code='111110111111101111111', clé = 2064255