Exercices

Consignes

• Ne pas de faire aider par des IA ou genAI

Série 1

1. Ecrire un script Python qui demande à l’utilisateur de saisir un nombre entier et affiche si ce nombre est pair ou impair. 💡 Astuce: utiliser n = int(input("Saisir un entier : "))
2. Ecrire un script Python qui demande à l'utilisateur de saisir un entier n et affiche la somme des n premiers entiers (somme des entiers de 0 jusqu'à n inclus).
3. Ecrire un script Python qui demande à l’utilisateur de saisir un nombre entier et affiche tous les diviseurs de ce nombre.
4. Ecrire un script Python qui génère deux nombres aléatoires x et y avec 0 <= x < 10 et x <= y < 100. (astuce: importer random et appeler x = random.randint(0, 10)).
5. Ecrire un programme Python qui génère deux nombres aléatoires x et y avec 0 <= x < 10 et x <= y < 100. Le programme affiche ensuite le résultat de la division entière entre y et x et le reste de la division. (penser à gérer le cas où x = 0).

6. Ecrire un programme qui affiche autant de caractères que possible d'une chaîne de caractères sous forme de suite pyramidale. (astuce: on peut faire un for in sur une chaîne de caractères for char in chaine).

   • Exemple pour la chaîne "abcdefghijklmnopqrstuvwxyz" * 10

   a 
   bc 
   def 
   ghij 
   klmno 
   pqrstu 
   vwxyzab 
   cdefghij 
   klmnopqrs 
   tuvwxyzabc 
   defghijklmn 
   opqrstuvwxyz 
   abcdefghijklm 
   nopqrstuvwxyza 
   bcdefghijklmnop 
   qrstuvwxyzabcdef 
   ghijklmnopqrstuvw 
   xyzabcdefghijklmno 
   pqrstuvwxyzabcdefgh 
   ijklmnopqrstuvwxyzab 
   cdefghijklmnopqrstuvw 
   xyzabcdefghijklmnopqrs
   

   • Réponse incorrecte pour la "abcdefghijklmnopqrstuvwxyz"

   Incorrect
   a 
   bc 
   def 
   ghij 
   klmno 
   pqrstu 
   vwxyz
   
   Correct
   a 
   bc 
   def 
   ghij 
   klmno 
   pqrstu 
   

7. Écrire une fonction count_letters(texte) ayant pour argument une chaîne de caractères texte et qui renvoie un dictionnaire qui contient la fréquence de toutes les lettres de la chaîne entrée. Par exemple: count_letters("hello") renvoie {"h": 1, "e": 1, "l": 2, "o": 1}.

8. Soit des rectangles définis avec des dictionnaires dont les clés sont "x", "y", "largeur", "hauteur".
   • Ecrire une fonction is_intersecting(rectangle1, rectangle2) qui retourne True s'il y a intersection entre les deux rectangles.
   • Ecrire une fonction get_intersection(rectangle1, rectangle2) qui retourne le rectangle intersection s'il existe, sinon None.
9. Ecrire une fonction fx_square(x) qui retourne le résultat de x * x.
   • Ecrire une fonction fx_square_list(n) qui retourne une liste de n éléments. La valeur d'un élément d'indice i est fx_square(i).
   • Utiliser la librairie matplotlib pour dessiner un graphique dont les abscisses sont les entiers allant de 0 à n et les ordonnées sont les éléments retournés par fx_square_list(n).
10. Définir une fonction fx_square_list2(points) qui prend en argument une liste d'entiers ordonnées par ordre croissant et retourne une nouvelle liste dont la valeur du i ème élément est points[i] * points[i].
    • Tracer le graphique de f(x) = x * x pour x compris entre -100 à 100.
11. Faire le graphique de -100 à 100 des fonctions suivantes: exp(x), 1/x, log(x) + (1/(x puissance3))

Corrigés série 1

Exos de 1 à 5

n = int(input("Saisir un entier : "))

print(n, "est", "pair" if n % 2 == 0 else "impair")
print(("pair", "impair")[n % 2])

somme_n = 0
for i in range(n + 1):
    somme_n += i

print("Somme des", n, "premiers entiers", somme_n)

Exos pyramide, count_letters et intersection

print([1, 2, 3] * 3)
print("hello" * 2)
print(len([1, 2, 3]), len([1, 2, 3] * 3), len("hello"))


# abcdefghij
# ligne 0 -> a on prend la sous-chaine (0, 1)
# ligne 1 -> bc (1, 3)
# ligne 2 -> def (3, 6)
# ligne 3 -> ghij (6, 10)
# ligne l -> (indice courant dans la chaine, indice courant + l + 1)
# indice courant s'incrémente à chaque fois de l + 1


def print_pyramide(input):
    i = 0
    current_line = 0
    while i + current_line + 1 < len(input):
        print(input[i : i + current_line + 1])
        i += current_line + 1
        current_line += 1


print_pyramide("abcdefghij")
print_pyramide("abcdefghijklmnopqrstuvwxyz")
print_pyramide("abcdefghijklmnopqrstuvwxyz" * 10)


def count_letters1(input):
    dict = {}
    for letter in input:
        if letter in dict:
            dict[letter] += 1
        else:
            dict[letter] = 1
    return dict


def count_letters2(input):
    dict = {}
    for letter in input:
        dict[letter] = dict.get(letter, 0) + 1
    return dict


def count_letters3(input):
    dict = {}
    for letter in input:
        dict[letter] = dict[letter] + 1 if letter in dict else 1
    return dict


print(count_letters1("hello"))
print(count_letters2("hello"))
print(count_letters3("hello"))


def is_intersect_1D(x1, l1, x2, l2):
    # Dans d'autres langages, il aurait fallu écrire (On ne peut pas combiner les inégalités)
    # x1 < x2 && x2 < x1 + l1 || x2 < x1 && x1 < x2 + l2
    return x1 <= x2 <= x1 + l1 or x2 <= x1 <= x2 + l2


print(is_intersect_1D(0, 10, 3, 1))
print(is_intersect_1D(2, 5, 10, 4))
print(is_intersect_1D(-2, 5, 10, 4))
print(is_intersect_1D(0, 10, -10, 20))
print(is_intersect_1D(100, 1, -5, 1000))
print(is_intersect_1D(100, 1, -5, 106))
print(is_intersect_1D(100, 1, -5, 99))


def is_intersect_2D(rec1, rec2):
    return is_intersect_1D(
        rec1["x"], rec1["width"], rec2["x"], rec2["width"]
    ) and is_intersect_1D(rec1["y"], rec1["height"], rec2["y"], rec2["height"])


rec1 = {"x": 10, "y": 30, "width": 100, "height": 200}
rec2 = {"x": -5, "y": 20, "width": 50, "height": 100}
rec3 = {"x": 15, "y": 15, "width": 5, "height": 5}
rec4 = {"x": 15, "y": 15, "width": 5, "height": 400}
print("testing intersect 2D")
print("rec1, rec2", is_intersect_2D(rec1, rec2))
print("rec1, rec3", is_intersect_2D(rec1, rec3))
print("rec1, rec4", is_intersect_2D(rec1, rec4))
print("rec2, rec3", is_intersect_2D(rec2, rec3))

plot

import matplotlib.pyplot as plt


def fx_square(x):
    return x**2


def fx_square_list(n):
    items = []
    for i in range(n):
        items.append(fx_square(i))
    return items


def plot_f(n):
    plt.plot(range(n), fx_square_list(n))
    plt.show()


n = 88
print(fx_square_list(n))
plot_f(n)


# exemple de liste points: [-3, 0, 1, 4, 5]
# Exemple de sortie attendue [9, 0, 1, 16, 25]


def fx_square_list2(points):
    values = []
    for point in points:
        values.append(point**2)
    return values


points = range(-100, 100)
values = fx_square_list2(points)
plt.plot(points, values)
plt.show()

Série 2

Résoudre les exercices suivants avec les compréhensions.

1. Créer une liste des 10 premiers nombres pairs
2. Créer un dictionnaire contentant 10 clés allant de 0 à 9. La valeur de chaque clé est un texte indiquant la parité du nombre. (exemple: {0: "paire", 1: "impaire", etc.})
3. Créer un dictionnaire contentant 10 clé allant de 0 à 9 convertie en string. La valeur de chaque clé est une texte indiquant la parité du nombre. (exemple: {"0": "paire", "1": "impaire", etc.})
4. Créer un dictionnaire qui filtre le dictionnaire précédent en ne gardant que les nombres impairs
5. Créer un tuple qui contient les 20 premiers nombres pairs.
6. Soit une liste d'étudiants ou chaque étudiannt est défini par un dictionnaire de ce type etudiant = {"name": "sasha", "birth_year" = 2000}.
   • Créer un ensemble des noms des étudiants.
   • Créer un tuple contenant les années de naissance de chaque étudiant.
7. A partir d'un tuple de symboles ("♥️", "♠️", "♣️", "♦️") et de la liste de rangs ["As", "Roi", "Reine", "Valet"] + [*range(2, 11)]. Créer un jeu de cartes sous forme d'une liste de tuples qui est le produit cartésien entre les symboles et le rang.

Solutions

# 1
print([x for x in range(0, 20, 2)])
print([x for x in range(0, 20) if x % 2 == 0])

# 2
print({x: "even" if x % 2 == 0 else "odd" for x in range(10)})


def get_parity(x):
    if x % 2 == 0:
        return "even"
    else:
        return "odd"


print({x: get_parity(x) for x in range(10)})

# 3
print({str(x): "even" if x % 2 == 0 else "odd" for x in range(10)})
print({f"{x}": "even" if x % 2 == 0 else "odd" for x in range(10)})

# 4
numbers = {f"{x}": "even" if x % 2 == 0 else "odd" for x in range(10)}
print({key: value for key, value in numbers.items() if int(key) % 2 == 0})

# 5
print((x for x in range(0, 40, 2)))

# cartes
symbols = ("♥️", "♠️", "♣️", "♦️")
ranks = ["As", "Roi", "Reine", "Valet"] + [*range(2, 11)]

cards = [(symbol, rank) for symbol in symbols for rank in ranks]
print(cards)

Source

• Exercices corrigés d'algorithmique Python - Les bases
• Exercices du site développez
• Sorting Algorithms Animations
• Sites pour apprendre en s’amusant