Exercices d'algorithmique.

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

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 π.

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

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

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

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

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

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.

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.

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.

É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).

É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].

É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].

É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].

É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].

É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

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é.

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

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.

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

⭐ Exemple :

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

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

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.

1. Complète une fonction est_pair(nombre) qui prend un nombre entier en entrée et renvoie True s’il est pair, sinon False.

2. Améliore cette fonction en écrivant est_pair_court(nombre) en une seule ligne.

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. On considère comme voyelles : a, e, i, o, u, y ainsi que leurs variantes accentuées (ex. é, è, à, ï, etc.), en minuscules et majuscules. On comptera aussi æ/Æ et œ/Œ.

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 :

• \( 0! = 1 \)
• \( 1! = 1 \)
• \( 2! = 2 \)
• \( 3! = 6 \)
• \( 4! = 24 \)
• \( 5! = 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.

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.

Écrivez également une version plus concise appelée est_divisible_court qui réalise la même opération mais en une seule ligne avec un return.

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

Exemples :

pgcd(12,18) renvoie 6
pgcd(7,13) renvoie 1
pgcd(20,30) renvoie 10

É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.

Rappel : pour obtenir le nombre d'heures, vous pouvez utiliser la division entière // 60. Pour obtenir les minutes restantes, vous pouvez utiliser le reste de la division % 60.

Exemples :

convertir_temps(150) renvoie "2h 30min"
convertir_temps(45) renvoie "0h 45min"
convertir_temps(200) renvoie "3h 20min"

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.

Méthode :

• Un nombre inférieur ou égal à 1 n'est pas premier.
• On teste la divisibilité du nombre par tous les entiers de 2 jusqu'à nombre-1.
• Si on trouve un diviseur, le nombre n'est pas premier.
• Sinon, il est premier.

Exemples :

est_premier(7) renvoie True
est_premier(10) renvoie False
est_premier(2) renvoie True

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.

Rappel : la moyenne pondérée se calcule en multipliant chaque valeur par son poids, en additionnant le tout, puis en divisant par la somme des poids.

Exemples :

calculer_moyenne_ponderee([10, 15, 20], [1, 2, 1]) renvoie 15.0
calculer_moyenne_ponderee([12, 14], [3, 1]) renvoie 12.5

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.

Indice : on peut utiliser deux listes auxiliaires :

• liste_elements_vus pour stocker les éléments déjà rencontrés une première fois,
• liste_doublons pour stocker les éléments rencontrés plusieurs fois.

Exemples :

doublons_liste([1,2,3,2,4,1,5]) renvoie [2,1]
doublons_liste(["a","b","a","c","b","b"]) renvoie ["a","b"]

Écris une fonction occurrences(caractere, chaine) qui prend en paramètres :

• caractere : une chaîne de longueur 1,
• chaine : une chaîne de caractères,

et retourne le nombre de fois où caractere apparaît dans chaine.

⭐ Exemples :

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

Écris une fonction compte_occurrences(x, tab) qui prend en paramètres :

• x : une valeur,
• tab : une liste,

et retourne le nombre d’occurrences de x dans tab.

⚠️ Il est interdit d’utiliser la méthode count des listes Python.

⭐ Exemples :

>>> compte_occurrences(5, [])
0
>>> compte_occurrences(5, [-2, 3, 1, 5, 3, 7, 4])
1
>>> compte_occurrences('a', ['a','b','c','a','d','e','a'])
3

Écris une fonction maximum_tableau(tab) qui prend en paramètre une liste non vide de nombres tab et retourne le plus grand élément de cette liste.

⭐ Exemple :

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

Écris une fonction nb_repetitions(elt, tab) qui prend en paramètres :

• elt : un élément,
• tab : une liste d’éléments du même type,

et retourne le nombre de fois où elt apparaît dans tab.

⭐ 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

Écris une fonction verifie(tab) qui prend en paramètre une liste de valeurs numériques et retourne True si la liste est triée dans l’ordre croissant, False sinon.

Un tableau vide est considéré comme trié.

⭐ Exemples :

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

On considère des tables (des listes de dictionnaires) qui contiennent des enregistrements relatifs à des animaux hébergés dans un refuge. Les attributs de chaque enregistrement sont 'nom', 'espece', 'age', 'enclos'.

Exemple :

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}
]

Programme une fonction selection_enclos(table_animaux, num_enclos) qui :

• prend en paramètres une table table_animaux (liste de dictionnaires) et un numéro d’enclos num_enclos,
• renvoie une nouvelle table contenant uniquement les enregistrements dont l’attribut 'enclos' est égal à num_enclos.

⭐ Exemples :

>>> 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)
[]

Programme une fonction renverse(mot) qui prend en paramètre une chaîne de caractères mot et retourne cette chaîne en ordre inverse.

⭐ Exemples :

>>> renverse("")
""
>>> renverse("abc")
"cba"
>>> renverse("informatique")
"euqitamrofni"

Un palindrome se lit de la même façon de gauche à droite ou de droite à gauche.

Exemples de mots palindromes : bob, radar, non.

Exemples de nombres palindromes : 33, 121, 345543.

Complète les trois fonctions ci-dessous :

• inverse_chaine : inverse une chaîne de caractères et renvoie la chaîne inversée ;
• est_palindrome : renvoie True si la chaîne est un palindrome, False sinon ;
• est_nbre_palindrome : renvoie True si un nombre est palindrome, False sinon.

⭐ Exemples :

>>> inverse_chaine('bac')
'cab'
>>> est_palindrome('NSI')
False
>>> est_palindrome('ISN-NSI')
True
>>> est_nbre_palindrome(214312)
False
>>> est_nbre_palindrome(213312)
True

Écris une fonction recherche(elt, tab) qui prend en paramètres :

• elt : un nombre entier
• tab : une liste d’entiers

La fonction doit retourner l’indice de la première occurrence de elt dans tab si elt est présent, et None sinon.

⚠️ Il est interdit d’utiliser la méthode index() de Python : la solution doit parcourir la liste avec une boucle.

⭐ Exemples :

>>> recherche(1, [2, 3, 4])
None
>>> recherche(1, [10, 12, 1, 56])
2
>>> recherche(50, [1, 50, 1])
1
>>> recherche(15, [8, 9, 10, 15])
3

Écris une fonction recherche(elt, tab) qui prend en paramètres :

• elt : un entier,
• tab : une liste d’entiers,

et retourne l’indice de la dernière occurrence de elt dans tab si elt est présent, ou None sinon.

⭐ Exemples :

>>> recherche(1, [2, 3, 4])
None
>>> recherche(1, [10, 12, 1, 56])
2
>>> recherche(1, [1, 0, 42, 7])
0
>>> recherche(1, [1, 50, 1])
2
>>> recherche(1, [8, 1, 10, 1, 7, 1, 8])
5

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.

Programme une fonction correspond(mot, mot_a_trous) qui :

• prend en paramètres deux chaînes de caractères mot et mot_a_trous,
• renvoie True si on peut obtenir mot en remplaçant convenablement les caractères '*' de mot_a_trous,
• renvoie False sinon.

⭐ Exemples :

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

Écris une fonction enumere(tab) qui prend en paramètre une liste tab et renvoie un dictionnaire dont :

• les clés sont les éléments de tab,
• les valeurs sont les listes des indices où apparaissent ces éléments dans tab.

⭐ Exemples :

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

Le nombre d’occurrences d’un caractère dans une chaîne de caractères est le nombre d’apparitions de ce caractère dans la chaîne.

Exemples :

• le nombre d’occurrences du caractère 'o' dans 'bonjour' est 2 ;
• le nombre d’occurrences du caractère 'b' dans 'Bébé' est 1 ;
• le nombre d’occurrences du caractère 'B' dans 'Bébé' est 1 ;
• le nombre d’occurrences du caractère ' ' dans 'Hello world !' est 2.

On souhaite écrire une fonction nbr_occurrences(chaine) qui construit un dictionnaire dont :

• les clés sont les caractères de chaine,
• les valeurs sont le nombre d’occurrences de chaque caractère.

⭐ Exemple :

>>> nbr_occurrences("Hello world !")
{'H': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 2, 'w': 1, 'r': 1, 'd': 1, '!': 1}

L’ordre des clés dans le dictionnaire n’a pas d’importance.

L'opérateur « ou exclusif » entre deux bits renvoie 0 si les deux bits sont égaux et 1 s'ils sont différents. Il est symbolisé par le caractère \( \oplus \).

Ainsi :

• \( 0 \oplus 0 = 0 \)
• \( 0 \oplus 1 = 1 \)
• \( 1 \oplus 0 = 1 \)
• \( 1 \oplus 1 = 0 \)

On représente ici une suite de bits par un tableau contenant des 0 et des 1.

Exemples :

a = [1, 0, 1, 0, 1, 1, 0, 1]
b = [0, 1, 1, 1, 0, 1, 0, 0]
c = [1, 1, 0, 1]
d = [0, 0, 1, 1]

Écris la fonction ou_exclusif qui prend en paramètres deux tableaux de même longueur et qui renvoie un tableau où l’élément situé à la position i est le résultat de \( tab1[i] \oplus tab2[i] \).

Avec les exemples ci-dessus, cette fonction doit donner :

>>> ou_exclusif(a, b)
[1, 1, 0, 1, 1, 0, 0, 1]
>>> ou_exclusif(c, d)
[1, 1, 1, 0]

Le codage par différence (delta encoding en anglais) permet de compresser un tableau de données en indiquant pour chaque valeur sa différence avec la précédente (plutôt que la valeur elle-même). Cette méthode est efficace lorsque les valeurs consécutives sont proches.

Écris la fonction delta(liste) qui prend en paramètre une liste non vide d’entiers et renvoie la liste compressée avec cette technique.

⭐ Exemples :

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

On a relevé les valeurs moyennes annuelles des températures à Paris pour la période 2013–2019. Les résultats sont stockés dans 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]

Écris la fonction annee_temperature_minimale qui prend en paramètres ces deux listes et qui renvoie la plus petite température 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 :

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

On appelle « mot » une chaîne composée uniquement de lettres (minuscules ou majuscules).

On appelle « phrase » une chaîne qui :

• est composée d’un ou plusieurs mots séparés par un espace ' ',
• se termine :
  • soit par un point '.' collé au dernier mot,
  • soit par un point d’exclamation '!' ou d’interrogation '?' séparé du dernier mot par un espace.

Exemples de phrases :

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

Programme la fonction nombre_de_mots qui prend en paramètre une phrase et renvoie le nombre de mots qu’elle contient.

⭐ 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

Écris une fonction recherche_min qui prend en paramètre une liste tab non vide de nombres (non triés) et qui renvoie l’indice de la première occurrence du minimum de la liste.

⭐ Exemples :

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

Écris une fonction indices_maxi qui prend en paramètre une liste tab non vide de nombres entiers et qui renvoie un couple :

• le plus grand élément de la liste,
• la liste des indices où ce maximum apparaît dans tab.

⭐ Exemples :

>>> indices_maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
(9, [3, 8])
>>> indices_maxi([7])
(7, [0])

Écris 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

Écris une fonction ajoute_dictionnaires qui prend en paramètres deux dictionnaires d1 et d2 dont les clés sont des nombres, et qui renvoie un dictionnaire d défini ainsi :

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

⭐ 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}

On considère la fonction separe qui prend en argument un tableau tab dont les éléments sont des 0 et des 1 et qui sépare les 0 des 1 en plaçant les 0 en début de tableau et les 1 à la suite.

Exemples :

>>> separe([1, 0, 1, 0, 1, 0, 1, 0])
[0, 0, 0, 0, 1, 1, 1, 1]
>>> separe([1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0])
[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]

Description des étapes pour tab = [1, 0, 1, 0, 1, 0, 1, 0] :

• Étape 1 : on regarde la première case, qui contient un 1 : on l’échange avec la dernière case.

  tab = [0, 0, 1, 0, 1, 0, 1, 1]

• Étape 2 : la première case contient 0 : elle est bien placée, on avance à la case suivante.

  tab = [0, 0, 1, 0, 1, 0, 1, 1]

• Étape 3 : la seconde case contient 0 : elle est bien placée, on avance.

  tab = [0, 0, 1, 0, 1, 0, 1, 1]

• Étape 4 : la troisième case contient 1 : on l’échange avec l’avant-dernière case.

  tab = [0, 0, 1, 0, 1, 0, 1, 1]

• Et ainsi de suite …

  tab = [0, 0, 0, 0, 1, 1, 1, 1]

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 Python, t[-1] permet d’accéder au dernier élément d’une liste t.

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

Programme :

• une fonction liste_puissances(a, n) qui prend en paramètres un entier a et un entier strictement positif n, et qui renvoie la liste [a¹, a², …, aⁿ].
• une fonction liste_puissances_borne(a, borne) qui prend en paramètres un entier a ≥ 2 et un entier borne, et qui renvoie la liste des puissances de a, à 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)
[]

Écrire une fonction recherche_indices_classement qui prend en paramètres un entier elt et une liste d’entiers tab, et qui renvoie trois listes :

• la première liste contient les indices des valeurs de tab strictement inférieures à elt ;
• la deuxième liste contient les indices des valeurs de tab égales à elt ;
• la troisième liste contient les indices des valeurs de tab strictement supérieures à elt.

Exemples :

>>> recherche_indices_classement(3, [1, 3, 4, 2, 4, 6, 3, 0])
([0, 3, 7], [1, 6], [2, 4, 5])
>>> recherche_indices_classement(3, [1, 4, 2, 4, 6, 0])
([0, 2, 5], [], [1, 3, 4])
>>> recherche_indices_classement(3, [1, 1, 1, 1])
([0, 1, 2, 3], [], [])
>>> recherche_indices_classement(3, [])
([], [], [])

On rappelle que les tableaux sont représentés par des listes Python (list).

Le but de cet exercice est d’écrire une fonction ajoute qui prend en paramètres trois arguments indice, element et tab et renvoie un tableau tab_ins dans lequel les éléments sont ceux du tableau tab avec, en plus, l’élément element à l’indice indice.

On considère que les variables indice et element sont des entiers positifs et que les éléments de tab sont également des entiers.

En réalisant cette insertion, Les éléments du tableau tab dont les indices sont supérieurs ou égaux à indice apparaissent décalés vers la droite dans le tableau tab_ins.

Si indice est égal au nombre d’éléments du tableau tab, l’élément element est ajouté dans tab_ins après tous les éléments du tableau tab.

Exemples :

>>> ajoute(1, 4, [7, 8, 9])
[7, 4, 8, 9]
>>> ajoute(3, 4, [7, 8, 9])
[7, 8, 9, 4]
>>> ajoute(0, 4, [7, 8, 9])
[4, 7, 8, 9]

Complète puis teste le code ci-dessous :

On considère la fonction binaire ci-dessous. Cette fonction prend en paramètre un entier positif a en écriture décimale et renvoie son écriture binaire sous la forme d’une chaine de caractères.

L’algorithme utilise la méthode des divisions euclidiennes successives comme l’illustre l’exemple ci-après.

Compléter le code de la fonction binaire.

Exemples :

>>> binaire(83)
'1010011'
>>> binaire(127)
'1111111'
>>> binaire(0)
'0'

Une professeure 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.

Si l’élève n’a pas de notes, on considère que sa moyenne est nulle. Si le nom donné n’est pas dans les résultats, la fonction renvoie None.

On souhaite programmer une fonction indiquant le point le plus proche d’un point de départ dans un tableau de points non vide. Les points sont tous à coordonnées entières et sont donnés sous la forme d’un tuple de deux entiers. Le tableau des points à traiter est donc un tableau de tuples.

On rappelle que la distance \(d\) entre deux points du plan de coordonnées \((x; y)\) et \((x'; y')\) vérifie la formule :

\( d^2 = (x - x')^2 + (y - y')^2 \)

Compléter le code des fonctions distance_carre et point_le_plus_proche fournies ci-dessous pour qu’elles répondent à leurs spécifications.

Exemples:

>>> distance_carre((1, 0), (5, 3))
25
>>> distance_carre((1, 0), (0, 1))
2
>>> point_le_plus_proche((0, 0), [(7, 9), (2, 5), (5, 2)])
(2, 5)
>>> point_le_plus_proche((5, 2), [(7, 9), (2, 5), (5, 2)])
(5, 2)

On considère la fonction insere ci-dessous qui prend en argument un tableau tab d’entiers triés par ordre croissant et un entier a. Cette fonction crée et renvoie un nouveau 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 la fonction insere ci-dessous.

Exemples :

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

Dans cet exercice on cherche à calculer la moyenne pondérée d’un élève dans une matière donnée. Chaque note est associée à un coefficient qui la pondère.

Par exemple, si ses notes sont : 14 avec coefficient 3, 12 avec coefficient 1 et 16 avec coefficient 2, sa moyenne pondérée sera donnée par :

\( \dfrac{14 \times 3 + 12 \times 1 + 16 \times 2}{3+1+2} = 14,333...\)

Écrire une fonction moyenne :

• qui prend en paramètre une liste notes non vide de tuples à deux éléments entiers de la forme (note, coefficient) (int ou float) positifs ou nuls ;
• et qui renvoie la moyenne pondérée des notes de la liste sous forme de flottant si la somme des coefficients est non nulle, None sinon.

Exemple :

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

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}

Écrire 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)

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

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