duranton.net

1. Exercice :

Écrire une fonction Python ajouter_deux qui prend un nombre en entrée et renvoie ce nombre augmenté de 2.

def ajouter_deux(nombre): return ..........

Tests :

# Tests

Affichage :

Console:

>>>

2. Exercice :

Complète la fonction calculer_surface_disque(rayon) qui prend en entrée le rayon d’un disque et retourne sa surface.

💡 Rappel : la surface d’un disque de rayon r se calcule avec la formule :

$$ \text{Surface} = \pi \times r^2 $$

Tu peux utiliser math.pi pour représenter la valeur de π.

import math def calculer_surface_disque(rayon): return .... * .... * .... # π * r * r # Exemple d'appel print(calculer_surface_disque(1))

Tests :

# Doit retourner environ 3.14159
print(calculer_surface_disque(1))

# Doit retourner 0
print(calculer_surface_disque(0))

# Doit retourner environ 28.27433
print(calculer_surface_disque(3))

Affichage :

Console:

>>>

3. Exercice :

Complétez un programme Python qui affiche les nombres de 1 à 100 en utilisant une boucle for.

for i in range(....): print(i)

Tests :

# Tests

Affichage :

Console:

>>>

4. Exercice :

Complétez un programme Python qui affiche les nombres de 25 à 134 en utilisant une boucle for.

for i in range(....): print(i)

Tests :

# Tests

Affichage :

Console:

>>>

5. Exercice :

Complétez la boucle précédente pour afficher les nombres impairs de 1 à 101.

for nombre in range(..........): print(nombre)

Tests :

# Tests

Affichage :

Console:

>>>

6. Exercice :

Complétez un programme Python qui affiche les nombres de 10 à 0 compris par ordre décroissant en utilisant une boucle for.

for i in range(....): print(i)

Tests :

# Tests

Affichage :

Console:

>>>

7. Exercice :

Complétez une fonction Python appelée calculer_carre qui prend un nombre en entrée et renvoie son carré.

def calculer_carre(nombre): return .....

Tests :

# Tests

Affichage :

Console:

>>>

8. Exercice :

Complétez la fonction compte_a qui prend comme argument un string texte et qui renvoie le nombre de caractères 'a' de ce string.

def compte_a(texte): compteur=..... for caractere in texte: if caractere == ........... : compteur= return compteur

Tests :

# Tests

Affichage :

Console:

>>>

9. Exercice :

Complétez une fonction Python nommée est_majeur qui prend l'âge d'une personne en entrée et renvoie True si elle est majeure (18 ans ou plus), sinon renvoie False.

def est_majeur(age): if ....... : return ...... else: ........

Tests :

# Tests

Affichage :

Console:

>>>

10. Exercice :

Complétez la fonction nombre_de_majuscules(chaine) qui prend en paramètre une chaine de caractères et qui renvoie le nombre de majuscules présentes dans cette chaine.

def nombre_de_majuscules(chaine): majuscules="ABCDEFGHIJKLMNOPQRSTUVWXYZ" nombre_total=..... for carac in ....... : if ............. : ............. return .........

Tests :

# Tests

Affichage :

Console:

>>>

11. Exercice :

Écris une fonction somme_de_0_a_n(n) qui retourne la somme des entiers de 0 à n inclus.

⭐ Exemple : somme_de_0_a_n(5) doit renvoyer 15 (car 0+1+2+3+4+5 = 15).

def somme_de_0_a_n(n): total = ..... for i in range(....): total = total + .... return total # Exemple d'appel print(somme_de_0_a_n(5))

Tests :

# Doit retourner 0
somme_de_0_a_n(0)

# Doit retourner 15
somme_de_0_a_n(5)

# Doit retourner 55
somme_de_0_a_n(10)

Affichage :

Console:

>>>

12. Exercice :

Écris une fonction doubler_elements(liste) qui prend en entrée une liste de nombres et retourne une nouvelle liste où chaque élément est multiplié par 2.

⭐ Exemple : doubler_elements([5, 3, 8]) doit renvoyer [10, 6, 16].

def doubler_elements(liste): resultat = [] for element in ....: resultat.append(....) return resultat # Exemple d'appel print(doubler_elements([5, 3, 8]))

Tests :

# Doit retourner [10, 6, 16]
print(doubler_elements([5, 3, 8]))

# Doit retourner [0, -2, 8]
print(doubler_elements([0, -1, 4]))

# Doit retourner []
print(doubler_elements([]))

Affichage :

Console:

>>>

13. Exercice :

Écris une fonction multiples_de_5(n) qui retourne une liste contenant tous les multiples de 5 compris entre 0 et n inclus.

⭐ Exemple : multiples_de_5(20) doit renvoyer [0, 5, 10, 15, 20].

def multiples_de_5(n): resultat = [] nb = 0 while ....................... : ............... ............... return resultat # Exemple d'appel print(multiples_de_5(20))

Tests :

# Doit retourner [0, 5, 10, 15, 20]
multiples_de_5(20)

# Doit retourner [0]
multiples_de_5(0)

# Doit retourner [0, 5]
multiples_de_5(7)

Affichage :

Console:

>>>

14. Exercice :

Écris une fonction puissances_de_2(n) qui retourne une liste contenant les valeurs de 2^0 jusqu’à 2^n.

Utilise une boucle for avec range(0, n+1) et calcule chaque puissance avec l’opérateur **.

⭐ Exemple : puissances_de_2(5) doit renvoyer [1, 2, 4, 8, 16, 32].

def puissances_de_2(n): resultats = [] for exposant in range(....): resultats.append(....) return resultats # Exemple d'appel print(puissances_de_2(5))

Tests :

# Doit retourner [1]
print(puissances_de_2(0))

# Doit retourner [1, 2, 4, 8]
print(puissances_de_2(3))

# Doit retourner [1, 2, 4, 8, 16, 32]
print(puissances_de_2(5))

Affichage :

Console:

>>>

15. Exercice :

Écris une fonction carres_jusqua_n(n) qui prend en entrée un entier positif n et retourne une liste contenant tous les carrés parfaits inférieurs ou égaux à n.

Utilise une boucle while pour construire progressivement la liste.

⭐ Exemple :

carres_jusqua_n(10) doit renvoyer [1, 4, 9];
carres_jusqua_n(102) doit renvoyer [1, 4, 9, 16, 25, 36, 49, 64, 81, 100].

def carres_jusqua_n(n): i = 1 resultats = [] while i**2 <= ....: ...................... ...................... return resultats # Exemple d'appel print(carres_jusqua_n(10))

Tests :

# Doit retourner [1]
print(carres_jusqua_n(1))

# Doit retourner [1, 4, 9]
print(carres_jusqua_n(10))

# Doit retourner [1, 4, 9, 16]
print(carres_jusqua_n(20))

# Doit retourner [1, 4, 9, 16, 25]
print(carres_jusqua_n(30))

Affichage :

Console:

>>>

16. Exercice :

Écris une fonction table_multi(n) qui prend en paramètre un entier n et affiche sa table de multiplication de 1 à 10.

⭐ Exemple : pour n = 3, la fonction doit afficher :

3*1=3
3*2=6
3*3=9
...
3*10=30

def table_multi(n): for i in range(1, 11): produit = .... print(str(n) + "*" + str(i) + "=" + str(....)) # Exemple d'appel table_multi(3)

Tests :

# Pour n=3, doit afficher :
# 3*1=3
# 3*2=6
# ...
# 3*10=30
table_multi(3)

# Pour n=5, doit afficher :
# 5*1=5
# 5*2=10
# ...
# 5*10=50
table_multi(5)

Affichage :

Console:

>>>

17. Exercice :

Complète la fonction compter_caractere(chaine, carac) qui prend en entrée une chaîne de caractères chaine et un caractère carac. Elle doit retourner le nombre de fois où carac apparaît dans chaine.

⭐ Exemple : compter_caractere("programmation", "m") doit renvoyer 2.

def compter_caractere(chaine, caractere_cherche): somme = 0 for c in ....: if c == ....: .... return somme # Exemple d'appel print(compter_caractere("programmation", "m"))

Tests :

# Doit retourner 2
print(compter_caractere("programmation", "m"))

# Doit retourner 3
print(compter_caractere("banana", "a"))

# Doit retourner 0
print(compter_caractere("python", "z"))

Affichage :

Console:

>>>

18. Exercice :

Écris une fonction affiche_carre(n) qui affiche un carré de caractères # de taille n.

⭐ Exemple :


>>> affiche_carre(5)
#####
#####
#####
#####
#####

>>> affiche_carre(3)
###
###
###

def affiche_carre(n): for i in range(....): print(....) # Exemple d'appel affiche_carre(3)

Tests :

# Pour n=3, doit afficher :
# ###
# ###
# ###
affiche_carre(3)

# Pour n=5, doit afficher :
# #####
# #####
# #####
# #####
# #####
affiche_carre(5)

Affichage :

Console:

>>>

19. Exercice :

On rappelle que l’opérateur % renvoie le reste de la division entière :

7 % 2 = 1 car 7 = 3 × 2 + 1
8 % 2 = 0 car 8 = 4 × 2 + 0

Ainsi, un nombre est pair si nombre % 2 == 0, et impair sinon.

Complète une fonction est_pair(nombre) qui prend un nombre entier en entrée et renvoie True s’il est pair, sinon False.
Améliore cette fonction en écrivant est_pair_opti(nombre) en une seule ligne.

def est_pair(nombre): if .... % 2 == 0: return True else: return .... def est_pair_opti(nombre): return .... # version optimisée en une ligne # Exemple d'appel print(est_pair(4)) # True print(est_pair_opti(5)) # False

Tests :

# Doit retourner True
print(est_pair(4))

# Doit retourner False
print(est_pair(7))

# Doit retourner True
print(est_pair_opti(10))

# Doit retourner False
print(est_pair_opti(11))

Affichage :

Console:

>>>

20. Exercice :

Complétez une fonction Python nommée compter_voyelles qui prend une chaîne de caractères en entrée et renvoie le nombre de voyelles qu'elle contient.

def compter_voyelles(chaine):
    voyelles = "aeiouyAEIOUY"
    nombre_voyelles = 0
    for caractere in chaine:
        if ......................:
            ............................
    return ...................................

21. Exercice :

En mathématiques, la factorielle d'un nombre entier positif $ n $ est le produit de tous les nombres entiers positifs inférieurs ou égaux à $ n $. Elle est notée $ n! $ (lire « $ n $ factorielle »).

La factorielle d'un entier $ n $ est définie comme suit :

Pour $ n = 0 $, $ 0! = 1 $.
Pour $ n > 0 $, $ n! = n \times (n-1) \times (n-2) \times \cdots \times 1 $.

Exemples :

Voici quelques exemples de calculs de factorielle :

$ 0! = 1 $
$ 1! = 1 $
$ 2! = 2 \times 1 = 2 $
$ 3! = 3 \times 2 \times 1 = 6 $
$ 4! = 4 \times 3 \times 2 \times 1 = 24 $
$ 5! = 5 \times 4 \times 3 \times 2 \times 1 = 120 $

Écrivez une fonction Python appelée calculer_factorielle qui prend un nombre en entrée et renvoie sa factorielle à l'aide d'une boucle for.

def calculer_factorielle(nombre):
    sortie=1
    for i in range(......):
        ........
    return sortie

22. Exercice :

Déclarez une fonction Python nommée est_divisible qui prend deux nombres en entrée, nombre et diviseur, et renvoie True si nombre est divisible par diviseur, sinon renvoie False.

def est_divisible(nombre, diviseur):
    if .......... :
        ...........
    ............
        ..........

23. Exercice :

Écrivez une fonction Python appelée affiche_diviseurs qui prend un nombre entier positif en entrée et affiche les nombres qui le divisent.

24. Exercice :

Complétez fonction Python appelée pgcd qui prend en paramètres deux integers strictement positifs et renvoie leur PGCD sous la forme d'un integer.

def pgcd(a,b):
    plus_grand_diviseur_commun=1
    for ............................. : #pour les nombres entiers de 1 jusqu'au minimum entre a et b.
        if ................................ : #si ce nombre entier divise a et b
            ................................... #on a trouvé un diviseur en commun plus grand
    return plus_grand_diviseur_commun

25. Exercice :

Écrivez une fonction Python appelée convertir_temps qui prend un nombre de minutes en entrée et renvoie une chaîne de caractères représentant le temps en heures et minutes (par exemple, "2h 30min").

def convertir_temps(minutes):
    heures = .............
    minutes_restantes = ..............
    return ...................

26. Exercice :

Complétez une fonction Python appelée est_premier qui prend un nombre en entrée et renvoie True s'il est premier, sinon renvoie False.

def est_premier(nombre):
    if nombre <= 1:
        return ........
    for i in range(.........):
        if nombre % i == .....:
            return ........
    return ............

27. Exercice :

Complétez une fonction Python appelée calculer_moyenne_ponderee qui prend deux listes en entrée : une liste de valeurs et une liste de poids correspondants, et renvoie la moyenne pondérée.

def calculer_moyenne_ponderee(valeurs, poids):
    somme = 0
    total_coefficients=0
    for i in range(............):
        somme+=..................
        total_coefficients+=...........
    return ........

28. Exercice :

Complétez une fonction Python appelée doublons_liste qui prend une liste en entrée et renvoie une nouvelle liste contenant uniquement les éléments qui apparaissent plus d'une fois dans la liste.

def doublons_liste(liste):
    liste_elements_vus=[]
    liste_doublons=[]
    for element in liste :
        if element in liste_doublons:
            pass
        elif element in ........... :
            ............
        else:
            ............
    return ...........

29. Exercice : (sujet 34 - 2023)

Programmer la fonction moyenne prenant en paramètre un tableau d'entiers tab (de type list) qui renvoie la moyenne de ses éléments si le tableau est non vide. Proposer une façon de traiter le cas où le tableau passé en paramètre est vide.

Dans cet exercice, on s’interdira d’utiliser la fonction Python sum.

Exemples :

>>> moyenne([5, 3, 8])
5.333333333333333
>>> moyenne([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
5.5
>>> moyenne([])
# Comportement différent suivant le traitement proposé.

30. Exercice : (sujet 10 - 2023)

Écrire la fonction maxliste, prenant en paramètre un tableau non vide de nombres tab (de type list) et renvoyant le plus grand élément de ce tableau.

Exemples :

>>> maxliste([98, 12, 104, 23, 131, 9])
131
>>> maxliste([-27, 24, -3, 15])
24

31. Exercice : (sujet 31 - 2023)

Écrire une fonction python appelée nb_repetitions qui prend en paramètres un élément elt et une liste tab et renvoie le nombre de fois où l’élément apparaît dans la liste.

Exemples :

>>> nb_repetitions(5, [2, 5, 3, 5, 6, 9, 5])
3
>>> nb_repetitions('A', [ 'B', 'A', 'B', 'A', 'R'])
2
>>> nb_repetitions(12, [1, '! ', 7, 21, 36, 44])
0

32. Exercice : (sujet 1 - 2023)

Programmer la fonction verifie qui prend en paramètre un tableau de valeurs numériques non vide et qui renvoie True si ce tableau est trié dans l’ordre croissant, False sinon.

Exemples :

>>> verifie([0, 5, 8, 8, 9])
True
>>> verifie([8, 12, 4])
False
>>> verifie([-1, 4])
True
>>> verifie([5])
True

33. Exercice : (sujet 44 - 2023)

Programmer une fonction renverse, prenant en paramètre une chaîne de caractères non vide, mot, et qui renvoie une chaîne de caractères en inversant ceux de la chaîne mot.

Exemple :

>>> renverse("informatique")
"euqitamrofni"

34. Exercice : (sujet 6 - 2023)

Programmer la fonction recherche, prenant en paramètre un tableau non vide tab (de type list) d'entiers et un entier n, et qui renvoie l'indice de la dernière occurrence de l'élément cherché. Si l'élément n'est pas présent, la fonction renvoie la longueur du tableau.

Exemples :

>>> recherche([5, 3], 1)
2
>>> recherche([2, 4], 2)
0
>>> recherche([2, 3, 5, 2, 4], 2)
3

35. Exercice : (sujet 38 - 2023)

On considère des mots à trous : ce sont des chaînes de caractères contenant uniquement des majuscules et des caractères '*'. Par exemple 'INFO*MA*IQUE', '***I***E**' et '*S*' sont des mots à trous.

Programmer une fonction correspond qui :

prend en paramètres deux chaînes de caractères mot et mot_a_trous où mot_a_trous est un mot à trous comme indiqué ci-dessus,
renvoie:
- True si on peut obtenir mot en remplaçant convenablement les caractères '*' de mot_a_trous.
- False sinon.

Exemples :

>>> correspond('INFORMATIQUE', 'INFO*MA*IQUE')
True
>>> correspond('AUTOMATIQUE', 'INFO*MA*IQUE')
False
>>> correspond('STOP', 'S*')
False
>>> correspond('AUTO', '*UT*')
True

36. Exercice :

Complétez une fonction Python appelée compter_voyelles_consonnes qui prend une chaîne de caractères en entrée et renvoie un dictionnaire contenant le nombre de voyelles et de consonnes dans la chaîne.


def compter_voyelles_consonnes(chaine):
    voyelles = "aeiouyAEIOUY"
    consonnes = "bcdfghjklmnpqrstvwxzBCDFGHJKLMNPQRSTVWXZ"
    compteurs = {'voyelles': ....., 'consonnes': ......}
    for caractere in chaine:
        if ..... in ..........:
            .....................    # on ajoute 1 au compteur des voyelles
        elif ....................:
            .......................
    return compteurs

37. Exercice : (sujet 23 - 2023)

On considère des tables (des tableaux de dictionnaires) qui contiennent des enregistrements relatifs à des animaux hébergés dans un refuge. Les attributs des enregistrements sont 'nom', 'espece', 'age', 'enclos'. Voici un exemple d'une telle table :

animaux = [ {'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2},
    {'nom':'Titine', 'espece':'chat', 'age':2, 'enclos':5},
    {'nom':'Tom', 'espece':'chat', 'age':7, 'enclos':4},
    {'nom':'Belle', 'espece':'chien', 'age':6, 'enclos':3},
    {'nom':'Mirza', 'espece':'chat', 'age':6, 'enclos':5}]

Programmer une fonction selection_enclos qui :

prend en paramètres :
- une table table_animaux contenant des enregistrements relatifs à des animaux (comme dans l'exemple ci-dessus),
- un numéro d'enclos num_enclos ;
renvoie une table contenant les enregistrements de table_animaux dont l'attribut 'enclos' est num_enclos.

Exemples avec la table animaux ci-dessus :

>>> selection_enclos(animaux, 5)
[{'nom':'Titine', 'espece':'chat',
'age':2, 'enclos':5},
{'nom':'Mirza', 'espece':'chat',
'age':6, 'enclos':5}]
>>> selection_enclos(animaux, 2)
[{'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2}]
>>> selection_enclos(animaux, 7)
[]

38. Exercice : (sujet 25 - 2023)

Écrire une fonction enumere qui prend en paramètre une liste L et renvoie un dictionnaire d dont les clés sont les éléments de L avec pour valeur associée la liste des indices de l’élément dans la liste L.

Exemple :

>>> enumere([1, 1, 2, 3, 2, 1])
{1: [0, 1, 5], 2: [2, 4], 3: [3]}

39. Exercice : (sujet 13 - 2023)

Programmer la fonction recherche, prenant comme paramètres une variable a de type numérique (float ou int) et un tableau tab (de type list) et qui renvoie le nombre d'occurrences de a dans tab.

Exemples :

>>> recherche(5, [])
0
>>> recherche(5, [-2, 3, 4, 8])
0
>>> recherche(5, [-2, 3, 1, 5, 3, 7, 4])
1
>>> recherche(5, [-2, 5, 3, 5, 4, 5])
3

40. Exercice : (sujet 41 - 2023)

Écrire une fonction recherche(caractere, chaine) qui prend en paramètres caractere, un unique caractère (c’est-à-dire une chaîne de caractère de longueur 1), et chaine, une chaîne de caractères. Cette fonction renvoie le nombre d’occurrences de caractere dans chaine, c’est-à-dire le nombre de fois où caractere apparaît dans chaine.

Exemples :

>>> recherche('e', "sciences")
2
>>> recherche('i', "mississippi")
4
>>> recherche('a', "mississippi")
0

41. Exercice : (sujet 27 - 2023)

Écrire une fonction recherche_min qui prend en paramètre un tableau, non vide, de nombres non trié tab, et qui renvoie l'indice de la première occurrence du minimum de ce tableau. Les tableaux seront représentés sous forme de listes Python.

Exemples :

>>> recherche_min([5])
0
>>> recherche_min([2, 4, 1])
2
>>> recherche_min([5, 3, 2, 2, 4])
2

42. Exercice : (sujet 15 - 2023)

On a relevé les valeurs moyennes annuelles des températures à Paris pour la période allant de 2013 à 2019. Les résultats ont été récupérés sous la forme de deux listes : l’une pour les températures, l’autre pour les années :

t_moy = [14.9, 13.3, 13.1, 12.5, 13.0, 13.6, 13.7]
annees = [2013, 2014, 2015, 2016, 2017, 2018, 2019]

Écrire la fonction mini qui prend en paramètres un tableau releve des relevés et un tableau date des dates et qui renvoie la plus petite valeur relevée au cours de la période et l’année correspondante. On suppose que la température minimale est atteinte une seule fois.

Exemple :

>>> mini(t_moy, annees)
(12.5, 2016)

43. Exercice : (sujet 22 - 2023)

On rappelle que :

le nombre $a^n $ est le nombre $ a \times a \times ... \times a $, où le facteur $a$ apparaît $n$ fois,
en langage Python, l'instruction t[-1] permet d'accéder au dernier élément du tableau t.

Dans cet exercice, l'opérateur ** et la fonction pow ne sont pas autorisés.

Programmer en langage Python une fonction liste_puissances qui prend en paramètre un nombre entier a, un entier strictement positif n et qui renvoie la liste de ses puissances [a1, a2, ... , an ].

Programmer également une fonction liste_puissances_borne qui prend en paramètre un nombre entier a supérieur ou égal à 2 et un entier borne, et qui renvoie la liste de ses puissances, à l’exclusion de $ a^0 $ , strictement inférieures à borne.

Exemples :

>>> liste_puissances(3, 5)
[3, 9, 27, 81, 243]
>>> liste_puissances(-2, 4)
[-2, 4, -8, 16]
>>> liste_puissances_borne(2, 16)
[2, 4, 8]
>>> liste_puissances_borne(2, 17)
[2, 4, 8, 16]
>>> liste_puissances_borne(5, 5)
[]

44. Exercice : (sujet 21 - 2023)

Le codage par différence (delta encoding en anglais) permet de compresser un tableau de données en indiquant pour chaque donnée, sa différence avec la précédente (plutôt que la donnée elle-même). On se retrouve alors avec un tableau de données plus petit, nécessitant donc moins de place en mémoire. Cette méthode se révèle efficace lorsque les valeurs consécutives sont proches.

Programmer la fonction delta(liste) qui prend en paramètre un tableau non vide de nombres entiers et qui renvoie un tableau contenant les valeurs entières compressées à l’aide de cette technique.

Exemples :

>>> delta([1000, 800, 802, 1000, 1003])
[1000, -200, 2, 198, 3]
>>> delta([42])
[42]

45. Exercice : (sujet 40 - 2023)

Pour cet exercice :

On appelle « mot » une chaîne de caractères composée de caractères choisis parmi les 26 lettres minuscules ou majuscules de l'alphabet,
On appelle « phrase » une chaîne de caractères :
- composée d’un ou de plusieurs « mots » séparés entre eux par un seul caractère espace ' ',
- se finissant :
  - soit par un point '.' qui est alors collé au dernier mot,
  - soit par un point d'exclamation '!' ou d'interrogation '?' qui est alors séparé du dernier mot par un seul caractère espace ' '.

Voici deux exemples :

'Cet exercice est simple.'
'Le point d exclamation est separe !'

Après avoir remarqué le lien entre le nombre de mots et le nombres de caractères espace dans une phrase, programmer une fonction nombre_de_mots qui prend en paramètre une phrase et renvoie le nombre de mots présents dans celle-ci.

Exemples :

>>> nombre_de_mots('Cet exercice est simple.')
4
>>> nombre_de_mots('Le point d exclamation est separe !')
6
>>> nombre_de_mots('Combien de mots y a t il dans cette phrase ?')
10
>>> nombre_de_mots('Fin.')
1

46. Exercice : (sujet 20 - 2023)

Écrire une fonction ajoute_dictionnaires qui prend en paramètres deux dictionnaires d1 et d2 dont les clés sont des nombres et renvoie le dictionnaire d défini de la façon suivante :

Les clés de d sont celles de d1 et d2 réunies.
Si une clé est présente dans les deux dictionnaires d1 et d2, sa valeur associée dans le dictionnaire d est la somme de ses valeurs dans les dictionnaires d1 et d2.
Si une clé n’est présente que dans un des deux dictionnaires, sa valeur associée dans le dictionnaire d est la même que sa valeur dans le dictionnaire où elle est présente.

Exemples :

>>> ajoute_dictionnaires({1: 5, 2: 7}, {2: 9, 3: 11})
{1: 5, 2: 16, 3: 11}
>>> ajoute_dictionnaires({}, {2: 9, 3: 11})
{2: 9, 3: 11}
>>> ajoute_dictionnaires({1: 5, 2: 7}, {})
{1: 5, 2: 7}

47. Exercice : (sujet 16 - 2023)

Un professeur de NSI décide de gérer les résultats de sa classe sous la forme d’un dictionnaire :

les clefs sont les noms des élèves ;
les valeurs sont des dictionnaires dont les clefs sont les types d’épreuves sous forme de chaîne de caractères et les valeurs sont les notes obtenues associées à leurs coefficients dans une liste.

Avec :

resultats = {'Dupont': {
    'DS1': [15.5, 4],
    'DM1': [14.5, 1],
    'DS2': [13, 4],
    'PROJET1': [16, 3],
    'DS3': [14, 4]
    },
    'Durand': {
    'DS1': [6 , 4],
    'DM1': [14.5, 1],
    'DS2': [8, 4],
    'PROJET1': [9, 3],
    'IE1': [7, 2],
    'DS3': [8, 4],
    'DS4':[15, 4]
    }
    }

L’élève dont le nom est Durand a ainsi obtenu au DS2 la note de 8 avec un coefficient 4.

Le professeur crée une fonction moyenne qui prend en paramètre le nom d’un de ses élèves et renvoie sa moyenne arrondie au dixième.

Compléter le code ci-dessous :

def moyenne(nom, dico_result):
    if nom in ...:
        notes = dico_result[nom]
        total_points = ...
        total_coefficients = ...
        for ...  in notes.values():
            note, coefficient = valeurs
            total_points = total_points + ... * coefficient
            total_coefficients = ... + coefficient
        return round( ... / total_coefficients, 1 )
    else:
        return -1

48. Exercice : (sujet 3 - 2023)

Dans cet exercice, les nombres sont des entiers ou des flottants.

Écrire une fonction moyenne renvoyant la moyenne pondérée d’une liste non vide, passée en paramètre, de tuples à deux éléments de la forme (valeur,coefficient) où valeur et coefficient sont des nombres positifs ou nuls.

Si la somme des coefficients est nulle, la fonction renvoie None, si la somme des coefficients est non nulle, la fonction renvoie, sous forme de flottant, la moyenne des valeurs affectées de leur coefficient.

Exemples :

>>> moyenne([(8, 2), (12, 0), (13.5, 1), (5, 0.5)])
9.142857142857142
>>> moyenne([(3, 0), (5, 0)])
None

49. Exercice : (sujet 4 - 2023)

Écrire une fonction a_doublon qui prend en paramètre une liste triée de nombres et renvoie True si la liste contient au moins deux nombres identiques, False sinon.

Exemples :

>>> a_doublon([])
False
>>> a_doublon([1])
False
>>> a_doublon([1, 2, 4, 6, 6])
True
>>> a_doublon([2, 5, 7, 7, 7, 9])
True
>>> a_doublon([0, 2, 3])
False

50. Exercice : (sujet 8 - 2023)

Sur le réseau social TipTop, on s’intéresse au nombre de « like » des abonnés. Les données sont stockées dans des dictionnaires où les clés sont les pseudos et les valeurs correspondantes sont les nombres de « like » comme ci-dessous :

{'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50}

Ecrire une fonction max_dico qui :

prend en paramètre un dictionnaire dico non vide dont les clés sont des chaînes de caractères et les valeurs associées sont des entiers positifs ou nuls ;
renvoie un tuple dont :
- la première valeur est une clé du dictionnaire associée à la valeur maximale ;
- la seconde valeur est la valeur maximale présente dans le dictionnaire.

Exemples :

>>> max_dico({'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50})
('Ada', 201)
>>> max_dico({'Alan': 222, 'Ada': 201, 'Eve': 220, 'Tim': 50})
('Alan', 222)

51. Exercice : (sujet 39 - 2023)

On considère la fonction pantheon prenant en paramètres eleves et notes deux tableaux de même longueur, le premier contenant le nom des élèves et le second, des entiers positifs désignant leur note à un contrôle de sorte que eleves[i] a obtenu la note notes[i].

Cette fonction renvoie le couple constitué de la note maximale attribuée et des noms des élèves ayant obtenu cette note regroupés dans un tableau. Ainsi, l’instruction pantheon(['a', 'b', 'c', 'd'], [15,18,12,18]) renvoie le couple (18, ['b', 'd']).

def pantheon(eleves, notes):
    note_maxi = 0
    meilleurs_eleves =  ...

    for i in range(...) :
        if notes[i] == ... :
            meilleurs_eleves.append(...)
        elif notes[i] > note_maxi:
            note_maxi = ...
            meilleurs_eleves = [...]

    return (note_maxi,meilleurs_eleves)

eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
notes_nsi = [30, 40, 80, 60, 58, 80, 75, 80, 60, 24]

Compléter ce code.

Exemples :

>>> eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
>>> notes_nsi = [30, 40, 80, 60, 58, 80, 75, 80, 60, 24]
>>> pantheon(eleves_nsi, notes_nsi)
(80, ['c', 'f', 'h'])
>>> pantheon([],[])
(0, [])

52. Exercice : (sujet 22 - 2023)

On affecte à chaque lettre de l’alphabet un code selon les tableaux ci-dessous :

A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26

Pour un mot donné, on détermine d’une part son code alphabétique concaténé, obtenu par la juxtaposition des codes de chacun de ses caractères, et d’autre part, son code additionné, qui est la somme des codes de chacun de ses caractères. Par ailleurs, on dit que ce mot est « parfait » si le code additionné divise le code concaténé.

Exemples :

Pour le mot "Paul", le code concaténé est la chaîne 1612112, soit l'entier 1612112.

Son code additionné est l'entier 50 car $16+1+21+12=50$

50 ne divise pas l'entier 1612112; par conséquent, le mot "Paul" n'est pas parfait.
Pour le mot "Alain", le code concaténé est la chaîne 1121914, soit l'entier 1121914.

Le code additionné est l'entier 37 car $1+12+1+9+14=37$.

37 divise l'entier 1121914; par conséquent, le mot "Alain" est parfait.

Compléter la fonction est_parfait fournie à la page suivante qui prend comme paramètre une chaîne de caractères mot (en lettres majuscules) et qui renvoie le code alphabétique concaténé, le code additionné de mot, ainsi qu’un booléen qui indique si mot est parfait ou pas.

dico = {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6,
    "G": 7, "H": 8, "I": 9, "J": 10, "K": 11, "L": 12,
    "M": 13, "N": 14, "O": 15, "P": 16, "Q": 17,
    "R": 18, "S": 19, "T": 20, "U": 21, "V": 22,
    "W": 23, "X": 24, "Y": 25, "Z": 26}


def est_parfait(mot):
# mot est une chaine de caracteres (en lettres majuscules)
code_concatene = ""
code_additionne = ...
for c in mot:
    code_concatene = code_concatene + ...
    code_additionne = ...
code_concatene = int(code_concatene)
if ... :
    mot_est_parfait = True
else:
    mot_est_parfait = False
return code_additionne, code_concatene, mot_est_parfait

Exemples :

>>> est_parfait("PAUL")
(50, 1612112, False)
>>> est_parfait("ALAIN")
(37, 1121914, True)

53. Exercice : (sujet 26 - 2023)

Recopier et compléter sous Python la fonction suivante en respectant la spécification. On ne recopiera pas les commentaires.

def dichotomie(tab, x):
    """
    tab : tableau d’entiers trié dans l’ordre croissant
    x   : nombre entier
    La fonction renvoie True si tab contient x et False sinon
    """
    debut = 0
    fin = len(tab) - 1
    while debut <= fin:
        m = ...
        if x == tab[m]:
            return ...
        if x > tab[m]:
            debut = m + 1
        else:
             fin = ...
    return ...

Exemples :

>>> dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33], 28)
True
>>> dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33], 27)
False

54. Exercice : (sujet 6 - 2023)

On souhaite programmer une fonction donnant la distance la plus courte entre un point de départ et une liste de points. Les points sont tous à coordonnées entières.

Les points sont donnés sous la forme d'un tuple de deux entiers.

La liste des points à traiter est donc un tableau, non vide, de tuples.

On rappelle que la distance entre deux points du plan de coordonnées $(x ; y)$ et $(x' ; y')$ est donnée par la formule :

$$ d = \sqrt{(x-x')^2 + (y-y')^2} $$

On importe pour cela la fonction racine carrée (sqrt) du module math de Python.

Compléter le code des fonctions distance et plus_courte_distance pour qu'elles répondent à leurs spécifications.

from math import sqrt # import de la fonction racine carrée
def distance(point1, point2):
    """ Calcule et renvoie la distance entre deux points. """
    return sqrt((...)**2 + (...)**2)


def plus_courte_distance(tab, depart):
    """ Renvoie le point du tableau tab se trouvant à la plus
        courte distance du point depart."""
    point = tab[0]
    min_dist = ...
    for i in range (1, ...):
        if distance(tab[i], depart)...:
            point = ...
            min_dist = ...
    return point

Exemples :

>>> distance((1, 0), (5, 3))
5.0
>>> distance((1, 0), (0, 1))
1.4142135623730951
>>> plus_courte_distance([(7, 9), (2, 5), (5, 2)], (0, 0))
(2, 5)
>>> plus_courte_distance([(7, 9), (2, 5), (5, 2)], (5, 2))
(5, 2)

55. Exercice : (sujet 14 - 2023)

On considère la fonction insere ci-dessous qui prend en arguments un entier a et un tableau tab d'entiers triés par ordre croissant. Cette fonction crée et renvoie un nouveau tableau à partir de celui fourni en paramètre en y insérant la valeur a de sorte que le tableau renvoyé soit encore trié par ordre croissant. Les tableaux seront représentés sous la forme de listes Python.

Compléter le code ci-dessous :

def insere(a, tab):
    """ Insère l'élément a (int) dans le tableau tab (list)
        trié par ordre croissant à sa place et renvoie le
        nouveau tableau. """
    l = list(tab) #l contient les memes elements que tab
    l.append(a)
    i = ...
    while a < ... and i >= 0: 
      l[i+1] = ...
      l[i] = a
      i = ...
    return l

Exemples :

>>> insere(3, [1, 2, 4, 5])
[1, 2, 3, 4, 5]
>>> insere(30, [1, 2, 7, 12, 14, 25])
[1, 2, 7, 12, 14, 25, 30]
>>> insere(1, [2, 3, 4])
[1, 2, 3, 4]
>>> insere(1, [])
[1]

56. Exercice : (sujet 4 - 2023)

Écrire une fonction a_doublon qui prend en paramètre une liste triée de nombres et renvoie True si la liste contient au moins deux nombres identiques, False sinon.

Exemples :

>>> a_doublon([])
False
>>> a_doublon([1])
False
>>> a_doublon([1, 2, 4, 6, 6])
True
>>> a_doublon([2, 5, 7, 7, 7, 9])
True
>>> a_doublon([0, 2, 3])
False

57. Exercice : (sujet 8 - 2023)

Sur le réseau social TipTop, on s’intéresse au nombre de « like » des abonnés. Les données sont stockées dans des dictionnaires où les clés sont les pseudos et les valeurs correspondantes sont les nombres de « like » comme ci-dessous :

{'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50}

Ecrire une fonction max_dico qui :

prend en paramètre un dictionnaire dico non vide dont les clés sont des chaînes de caractères et les valeurs associées sont des entiers positifs ou nuls ;
renvoie un tuple dont :
- la première valeur est une clé du dictionnaire associée à la valeur maximale ;
- la seconde valeur est la valeur maximale présente dans le dictionnaire.

Exemples :

>>> max_dico({'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50})
('Ada', 201)
>>> max_dico({'Alan': 222, 'Ada': 201, 'Eve': 220, 'Tim': 50})
('Alan', 222)

58. Exercice : (sujet 9 - 2023)

Programmer la fonction multiplication prenant en paramètres deux nombres entiers relatifs n1 et n2, et qui renvoie le produit de ces deux nombres.

Les seules opérations autorisées sont l’addition et la soustraction.

Exemples :

>>> multiplication(3, 5)
15
>>> multiplication(-4, -8)
32
>>> multiplication(-2, 6)
-12
>>> multiplication(-2, 0)
0

59. Exercice : (sujet 11 - 2023)

On modélise la représentation binaire d'un entier non signé par un tableau d'entiers dont les éléments sont 0 ou 1.

Par exemple, le tableau [1, 0, 1, 0, 0, 1, 1] représente l'écriture binaire de l'entier dont l'écriture décimale est :

$$ 2^6 + 2^4 + 2^1+2^0 = 83 $$

A l'aide d'un parcours séquentiel, écrire la fonction convertir répondant aux spécifications suivantes :

def convertir(tab):
    """
    tab est un tableau d'entiers, dont les éléments sont 0 ou 1,
    et représentant un entier écrit en binaire.
    Renvoie l'écriture décimale de l'entier positif dont la
    représentation binaire est donnée par le tableau tab
    """

Exemples :

>>> convertir([1, 0, 1, 0, 0, 1, 1])
83
>>> convertir([1, 0, 0, 0, 0, 0, 1, 0])
130

60. Exercice : (sujet 39 - 2023)

On considère la fonction pantheon prenant en paramètres eleves et notes deux tableaux de même longueur, le premier contenant le nom des élèves et le second, des entiers positifs désignant leur note à un contrôle de sorte que eleves[i] a obtenu la note notes[i].

Cette fonction renvoie le couple constitué de la note maximale attribuée et des noms des élèves ayant obtenu cette note regroupés dans un tableau. Ainsi, l’instruction pantheon(['a', 'b', 'c', 'd'], [15,18,12,18]) renvoie le couple (18, ['b', 'd']).

def pantheon(eleves, notes):
    note_maxi = 0
    meilleurs_eleves =  ...

    for i in range(...) :
        if notes[i] == ... :
            meilleurs_eleves.append(...)
        elif notes[i] > note_maxi:
            note_maxi = ...
            meilleurs_eleves = [...]

    return (note_maxi,meilleurs_eleves)

eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
notes_nsi = [30, 40, 80, 60, 58, 80, 75, 80, 60, 24]

Compléter ce code.

Exemples :

>>> eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
>>> notes_nsi = [30, 40, 80, 60, 58, 80, 75, 80, 60, 24]
>>> pantheon(eleves_nsi, notes_nsi)
(80, ['c', 'f', 'h'])
>>> pantheon([],[])
(0, [])

61. Exercice : (sujet 18 - 2023)

L’ordre des gènes sur un chromosome est représenté par un tableau ordre de n cases d’entiers distincts deux à deux et compris entre 1 et n.

Par exemple, ordre = [5, 4, 3, 6, 7, 2, 1, 8, 9] dans le cas n=9.

On dit qu’il y a un point de rupture dans ordre dans chacune des situations suivantes :

la première valeur de ordre n’est pas 1 ;
l’écart entre deux gènes consécutifs n’est pas égal à 1 ;
la dernière valeur de ordre n’est pas n.

Par exemple, si ordre = [5, 4, 3, 6, 7, 2, 1, 8, 9] avec n = 9, on a

un point de rupture au début car 5 est différent de 1
un point de rupture entre 3 et 6 (l’écart est de 3)
un point de rupture entre 7 et 2 (l’écart est de 5)
un point de rupture entre 1 et 8 (l’écart est de 7)

Il y a donc 4 points de rupture.

Compléter les fonctions Python est_un_ordre et nombre_points_rupture proposées à la page suivante pour que :

la fonction est_un_ordre renvoie True si le tableau passé en paramètre représente bien un ordre de gènes de chromosome et False sinon ;
la fonction nombre_points_rupture renvoie le nombre de points de rupture d’un tableau passé en paramètre représentant l’ordre de gènes d’un chromosome.

def est_un_ordre(tab):
    '''
    Renvoie True si tab est de longueur n et contient tous les entiers
    de 1 à n, False sinon
    '''
    for i in range(1,...):
        if ...:
            return False
    return True


def nombre_points_rupture(ordre):
    '''
    Renvoie le nombre de point de rupture de ordre qui reprÃ©sente un ordre
    de gènes de chromosome
    '''
    assert ... # ordre n'est pas un ordre de gÃ¨nes
    n = len(ordre)
    nb = 0
    if ordre[...] != 1: # le premier n'est pas 1
        nb = nb + 1
    i = 0
    while i < ...:
        if ... not in [-1, 1]: # l'Ã©cart n'est pas 1
            nb = nb + 1
        i = i + 1
    if ordre[...] != n: # le dernier n'est pas n
        nb = nb + 1
    return nb

Exemples :

>>> est_un_ordre([1, 6, 2, 8, 3, 7])
False
>>> est_un_ordre([5, 4, 3, 6, 7, 2, 1, 8, 9])
True
>>> nombre_points_rupture([5, 4, 3, 6, 7, 2, 1, 8, 9])
4
>>> nombre_points_rupture([1, 2, 3, 4, 5])
0
>>> nombre_points_rupture([1, 6, 2, 8, 3, 7, 4, 5])
7
>>> nombre_points_rupture([2, 1, 3, 4])
2

62. Exercice : (sujet 19 - 2023)

Le codage de César transforme un message en changeant chaque lettre en la décalant dans l’alphabet.

Par exemple, avec un décalage de 3, le A se transforme en D, le B en E, ..., le X en A, le Y en B et le Z en C. Les autres caractères (espace ou caractères de ponctuation : ‘!’,’ ?’...) ne sont pas codés.

La fonction position_alphabet ci-dessous prend en paramètre un caractère lettre et renvoie la position de lettre dans la chaîne de caractères ALPHABET s’il s’y trouve.

La fonction cesar prend en paramètre une chaîne de caractères message et un nombre entier decalage et renvoie le nouveau message codé avec le codage de César utilisant le décalage decalage.

Compléter la fonction cesar :

ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def position_alphabet(lettre):
    return ord(lettre) - ord('A')
def cesar(message, decalage):
    resultat = ''
    for ... in message:
        if 'A' <= c and c <= 'Z':
            indice = ( ... ) % 26
            resultat = resultat + ALPHABET[indice]
        else:
            resultat = ...
    return resultat

Exemples :

>>> cesar('BONJOUR A TOUS. VIVE LA MATIERE NSI !', 4)
'FSRNSYV E XSYW. ZMZI PE QEXMIVI RWM !'
>>> cesar('GTSOTZW F YTZX. ANAJ QF RFYNJWJ SXN !', -5)
'BONJOUR A TOUS. VIVE LA MATIERE NSI !'

63. Exercice : (sujet 5 - 2023)

On considère une image en 256 niveaux de gris que l’on représente par une grille de nombres, c’est-à-dire une liste composée de sous-listes toutes de longueurs identiques.

La largeur de l’image est donc la longueur d’une sous-liste et la hauteur de l’image est le nombre de sous-listes.

Chaque sous-liste représente une ligne de l’image et chaque élément des sous-listes est un entier compris entre 0 et 255, représentant l’intensité lumineuse du pixel.

L négatif d’une image est l’image constituée des pixels x_n tels que x_n + x_i = 255 où x_i est le pixel correspondant de l’image initiale.

Compléter le programme proposé page suivante :

def nbLig(image):
    '''renvoie le nombre de lignes de l'image'''
    return ...

def nbCol(image):
    '''renvoie la largeur de l'image'''
    return ...

def negatif(image):
    '''renvoie le négatif de l'image sous la forme
        d'une liste de listes'''
    # on créé une image de 0 aux mêmes dimensions que le paramètre image
    L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))]
    for i in range(nbLig(image)):
        for j in range(...):
            L[i][j] = ...
    return L
    
def binaire(image, seuil):
    '''renvoie une image binarisée de l'image sous la forme
        d'une liste de listes contenant des 0 si la valeur
        du pixel est strictement inférieure au seuil
        et 1 sinon'''
    # on crée une image de 0 aux mêmes dimensions que le paramètre
    image
    L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))]
    for i in range(nbLig(image)):
        for j in range(...):
            if image[i][j] < ... :
                L[i][j] = ...
            else:
                L[i][j] = ...
    return L

Exemples:

>>> img=[[20, 34, 254, 145, 6], [23, 124, 237, 225, 69], [197, 174,207, 25, 87], [255, 0, 24, 197, 189]]
>>> nbLig(img)
4
>>> nbCol(img)
5
>>> negatif(img)
[[235, 221, 1, 110, 249], [232, 131, 18, 30, 186], [58, 81, 48, 230,168], [0, 255, 231, 58, 66]]
>>> binaire(img,120)
[[0, 0, 1, 1, 0], [0, 1, 1, 1, 0], [1, 1, 1, 0, 0], [1, 0, 0, 1, 1]]

64. Exercice : (sujet 11 - 2023)

La fonction tri_insertion suivante prend en argument une liste tab et trie cette liste en utilisant la méthode du tri par insertion. Compléter cette fonction pour qu'elle réponde à la spécification demandée.

On rappelle le principe du tri par insertion : on considère les éléments à trier un par un, le premier élément constituant, à lui tout seul, une liste triée de longueur 1. On range ensuite le second élément pour constituer une liste triée de longueur 2, puis on range le troisième élément pour avoir une liste triée de longueur 3 et ainsi de suite...

A chaque étape, le premier élément de la sous-liste non triée est placé dans la sous-liste des éléments déjà triés de sorte que cette sous-liste demeure triée.

Le principe du tri par insertion est donc d'insérer à la n-ième itération, le n-ième élément à la bonne place.

liste = [9, 5, 8, 4, 0, 2, 7, 1, 10, 3, 6]

def tri_insertion(tab):
    n = len(tab)
    for i in range(1, n):
        valeur_insertion = tab[...]
        # la variable j sert Ã  dÃ©terminer oÃ¹ placer la valeur Ã  ranger
        j = ...
        # tant qu'on a pas trouvÃ© la place de l'Ã©lÃ©ment Ã  insÃ©rer
        # on dÃ©cale les valeurs du tableau vers la droite
        while j > ... and valeur_insertion < tab[...]:
            tab[j] = tab[j-1]
            j = ...
        tab[j] = ...

Exemples :

>>> liste = [9, 5, 8, 4, 0, 2, 7, 1, 10, 3, 6]
>>> tri_insertion(liste)
>>> liste
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

65. Exercice : (sujet 13 - 2023)

La fonction rendu_monnaie prend en paramètres deux nombres entiers positifs somme_due et somme_versee. Elle procède au rendu de la monnaie de la différence somme_versee – somme_due pour des achats effectués avec le système monétaire de la zone Euro. On utilise pour cela un algorithme glouton qui commence par rendre le maximum de pièces ou billets de plus grandes valeurs et ainsi de suite. Par la suite, on assimilera les billets à des pièces.

La fonction rendu_monnaie renvoie un tableau de type list contenant les pièces qui composent le rendu.

Toutes les sommes sont exprimées en euros. Les valeurs possibles pour les pièces sont donc contenues dans le tableau pieces = [1, 2, 5, 10, 20, 50, 100, 200].

Ainsi, l’instruction rendu_monnaie(452, 500) renvoie le tableau [20,20,5,2,1].

En effet, la somme à rendre est de 48 euros soit 20 + 20 + 5 + 2 + 1.

Le code de la fonction rendu_monnaie est à compléter :

pieces = [1, 2, 5, 10, 20, 50, 100, 200]

def rendu_monnaie(somme_due, somme_versee):

    rendu = ...
    a_rendre = ...
    i = len(pieces) - 1
    while ... :
        if pieces[i] <= a_rendre :
            rendu.append(...)
            a_rendre = ...
        else :
            i = ...
    return rendu

Exemples :

>>> rendu_monnaie(700, 700)
[]
>>> rendu_monnaie(102, 500)
[200, 100, 50, 20, 20, 5, 2, 1]

66. Exercice : (sujet 22 - 2023)

On affecte à chaque lettre de l’alphabet un code selon les tableaux ci-dessous :

A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26

Pour un mot donné, on détermine d’une part son code alphabétique concaténé, obtenu par la juxtaposition des codes de chacun de ses caractères, et d’autre part, son code additionné, qui est la somme des codes de chacun de ses caractères. Par ailleurs, on dit que ce mot est « parfait » si le code additionné divise le code concaténé.

Exemples :

Pour le mot "Paul", le code concaténé est la chaîne 1612112, soit l'entier 1612112.

Son code additionné est l'entier 50 car $16+1+21+12=50$

50 ne divise pas l'entier 1612112; par conséquent, le mot "Paul" n'est pas parfait.
Pour le mot "Alain", le code concaténé est la chaîne 1121914, soit l'entier 1121914.

Le code additionné est l'entier 37 car $1+12+1+9+14=37$.

37 divise l'entier 1121914; par conséquent, le mot "Alain" est parfait.

Compléter la fonction est_parfait fournie à la page suivante qui prend comme argument une chaîne de caractères mot (en lettres majuscules) et qui renvoie le code alphabétique concaténé, le code additionné de mot, ainsi qu’un booléen qui indique si mot est parfait ou pas.

dico = {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6,
    "G": 7, "H": 8, "I": 9, "J": 10, "K": 11, "L": 12,
    "M": 13, "N": 14, "O": 15, "P": 16, "Q": 17,
    "R": 18, "S": 19, "T": 20, "U": 21, "V": 22,
    "W": 23, "X": 24, "Y": 25, "Z": 26}


def est_parfait(mot):
# mot est une chaine de caracteres (en lettres majuscules)
code_concatene = ""
code_additionne = ...
for c in mot:
    code_concatene = code_concatene + ...
    code_additionne = ...
code_concatene = int(code_concatene)
if ... :
    mot_est_parfait = True
else:
    mot_est_parfait = False
return code_additionne, code_concatene, mot_est_parfait

Exemples :

>>> est_parfait("PAUL")
(50, 1612112, False)
>>> est_parfait("ALAIN")
(37, 1121914, True)

67. Exercice : (sujet 26 - 2023)

Recopier et compléter sous Python la fonction suivante en respectant la spécification. On ne recopiera pas les commentaires.

def dichotomie(tab, x):
    """
    tab : tableau d’entiers trié dans l’ordre croissant
    x   : nombre entier
    La fonction renvoie True si tab contient x et False sinon
    """
    debut = 0
    fin = len(tab) - 1
    while debut <= fin:
        m = ...
        if x == tab[m]:
            return ...
        if x > tab[m]:
            debut = m + 1
        else:
             fin = ...
    return ...

Exemples :

>>> dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33], 28)
True
>>> dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33], 27)
False

68. Exercice : (sujet 7 - 2023)

Programmer la fonction fusion prenant en paramètres deux tableaux non vides tab1 et tab2 (de type list) d'entiers, chacun dans l’ordre croissant, et renvoyant un tableau trié dans l’ordre croissant et contenant l’ensemble des valeurs de tab1 et tab2.

Exemples :

>>> fusion([3, 5], [2, 5])
[2, 3, 5, 5]
>>> fusion([-2, 4], [-3, 5, 10])
[-3, -2, 4, 5, 10]
>>> fusion([4], [2, 6])
[2, 4, 6]

A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26

A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26

A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26

A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26

Exercices d'algorithmique.

Avant-propos :

1. Exercice :

2. Exercice :

3. Exercice :

4. Exercice :

5. Exercice :

6. Exercice :

7. Exercice :

8. Exercice :

9. Exercice :

10. Exercice :

11. Exercice :

12. Exercice :

13. Exercice :

14. Exercice :

15. Exercice :

16. Exercice :

17. Exercice :

18. Exercice :

19. Exercice :

20. Exercice :

21. Exercice :

22. Exercice :

23. Exercice :

24. Exercice :

25. Exercice :

26. Exercice :

27. Exercice :

28. Exercice :

29. Exercice : (sujet 34 - 2023)

30. Exercice : (sujet 10 - 2023)

31. Exercice : (sujet 31 - 2023)

32. Exercice : (sujet 1 - 2023)

33. Exercice : (sujet 44 - 2023)

34. Exercice : (sujet 6 - 2023)

35. Exercice : (sujet 38 - 2023)

36. Exercice :

37. Exercice : (sujet 23 - 2023)

38. Exercice : (sujet 25 - 2023)

39. Exercice : (sujet 13 - 2023)

40. Exercice : (sujet 41 - 2023)

41. Exercice : (sujet 27 - 2023)

42. Exercice : (sujet 15 - 2023)

43. Exercice : (sujet 22 - 2023)

44. Exercice : (sujet 21 - 2023)

45. Exercice : (sujet 40 - 2023)

46. Exercice : (sujet 20 - 2023)

47. Exercice : (sujet 16 - 2023)

48. Exercice : (sujet 3 - 2023)

49. Exercice : (sujet 4 - 2023)

50. Exercice : (sujet 8 - 2023)

51. Exercice : (sujet 39 - 2023)

52. Exercice : (sujet 22 - 2023)

53. Exercice : (sujet 26 - 2023)

54. Exercice : (sujet 6 - 2023)

55. Exercice : (sujet 14 - 2023)

56. Exercice : (sujet 4 - 2023)

57. Exercice : (sujet 8 - 2023)

58. Exercice : (sujet 9 - 2023)

59. Exercice : (sujet 11 - 2023)

60. Exercice : (sujet 39 - 2023)

61. Exercice : (sujet 18 - 2023)

62. Exercice : (sujet 19 - 2023)

63. Exercice : (sujet 5 - 2023)

64. Exercice : (sujet 11 - 2023)

65. Exercice : (sujet 13 - 2023)

66. Exercice : (sujet 22 - 2023)

67. Exercice : (sujet 26 - 2023)

68. Exercice : (sujet 7 - 2023)

A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26

A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26