ICC 23-24 Série 6 - correction

s06-correction.py

from typing import Dict
from time import time

'''
Exercice 1: Pangramme - Utilisation des ensembles
'''
fr: str = "Portez ce vieux whisky au juge blond qui fume"
en: str = "The quick brown fox jumps over the lazy dog"

def lower_str(s: str) -> str:
    '''
    Cette fonction prend une chaîne de caractères en entrée, et retourne cette même chaîne entièrement en minuscule.
    :param s: La chaîne de caractères à passer en minuscule
    :return:  La chaîne de caractères entièrement en minuscule.
    '''
    output = ""
    for char in s: # On parcourt les caractères de la liste
        output += char.lower()  # Et on applique la méthode .lower() sur chaque caractère
    return output

def is_pangram(s: str) -> bool:
    '''
    Cette fonction parcours la chaîne de caractères s, puis ajoute chaque nouvelle lettre à un ensemble
    On vérifie à la fin si l'ensemble est de taille 26, contenant ainsi les 26 lettres de l'alphabet
    :param s: La chaîne de caractères pour laquelle on souhaite savoir si c'est un pangramme ou non.
    :return: True si s est un pangramme, False sinon
    '''
    letters = set()
    for char in s:
        # Cette ligne permet de s'assurer que l'on ajoute que les lettres de l'alphabet
        if char in 'abcdefghijklmnopqrstuvwxyz': 
            letters.add(char)
    return len(letters) == 26


print(is_pangram(lower_str(fr)))
print(is_pangram(lower_str(en)))

'''
Exercice 2: Ticket de caisse du supermarché - Utilisation des dictionnaires
'''

products: Dict[str, float] = {
    "Pommes": 3.30,
    "Bananes": 3.25,
    "Fraises": 6.95,
    "Tomates": 2.90,
    "Poivrons rouges": 3.50
}

def shopping_cart(products: Dict[str, float]) -> Dict[str, float]:
    '''
    Cette fonction demande à l'utilisateur de saisir, pour chaque produit présent dans le dictionnaire `products`, la 
    quantité acheté
    :param products: Un dictionnaire dont les clés sont les noms des produits et les valeurs les prix au kilogramme
    :return: Un dictionnaire qui représente un panier d'achat, et pour lequel les clés sont les noms des produits et 
                les valeurs la quantité achetée.
    '''
    cart: Dict[str, float] = {}
    for key in products.keys():
        quantity: float = float(input(f"Produit: {key}. Combien de kg? "))
        cart[key] = quantity
    return cart


def compute_total(products: Dict[str, float], cart: Dict[str, float]) -> float:
    '''
    Cette fonction calcule le prix total d'un panier en parcourant les produits présents dans le panier, en récupérant la quantité prise et en récupérant le prix au kilogramme grâce au dictionnaire `products`.
    :param products: Le dictionnaire faisant le lien entre les produits et les prix au kilogramme.
    :param cart: Le dictionnaire représentant le panier d'achat
    :return: Le prix total du panier
    '''
    total_price: float = 0
    # Ici, il est suffisant de récupérer les clés du dictionnaire, clés qui vont d'ailleurs servir à récupérer des 
    # valeurs dans les deux dictionnaires.
    for product in cart.keys():
        total_price += (cart[product] * products[product])
    return total_price

cart = shopping_cart(products)
print(compute_total(products, cart))

'''
Exercice 3: Suite de Fibonacci - Version récursive et mémoïsation
'''

def rec_fibonacci(n: int) -> int:
    '''
    Version récursive de la fonction calculant les termes de la suite de Fibonacci.
    :param n: Le rang du terme à calculer
    :return: La valeur du terme de rang n dans la suite de Fibonacci
    '''
    if n == 0:
        return 0
    if n == 1:
        return 1
    return rec_fibonacci(n-1) + rec_fibonacci(n-2)


def memo_fibonacci(n: int, previous_terms: Dict[int, int]) -> int:
    '''
    Version récursive avec mémoïsation de la fonction calculant les termes de la suite de Fibonacci.
    :param n: Le rang du terme à calculer
    :previous_terms: Un dictionnaire qui stocke au fur et à mesure les valeurs calculées
    :return: La valeur du terme de rang n dans la suite de Fibonacci
    '''
    if n == 0:
        return 0
    if n == 1:
        return 1
    # Les différences se trouvent ici:
    # Si le terme F(n) n'a jamais été calculé auparavant,
    if n not in previous_terms.keys():
        # Alors on le calcule grâce aux termes précédents, et on stocke cette valeur dans le dictionnaire
        previous_terms[n] = memo_fibonacci(n-1, previous_terms) + memo_fibonacci(n-2, previous_terms)
    # Il ne faut pas oublier de retourne cette nouvelle valeur calculée (comme cela est fait dans l'appel récursif 
    # simple)
    return previous_terms[n]


start = time()
print(rec_fibonacci(39))
stop = time()
print(f"Calculated in {stop - start} seconds.")

start = time()
print(memo_fibonacci(39, {}))
stop = time()
print(f"Calculated in {stop - start} seconds.")