Fonction de comparaison de signe¶

Ecrire une fonction meme_signe(a, b) qui renvoie True si les nombres a et b sont de même signe, et False dans le cas inverse. On considérera que 0 est aussi bien positif que négatif. Exemples de comportements :

42 17 -> True
42 0 -> True
-42 17 -> False
42 -17 -> False
-42 -17 -> True
-42 0 -> True
0 -42 -> True

Fonctions Celsius <-> Fahrenheit¶

1. La formule de conversion de degrés Fahrenheit vers des degrés Celsius est \(c=\frac{5}{9}(f-32)\).
   1. Écrire une fonction f2c(f) qui prend en paramètre une température \(f\) (en degrés Fahrenheit) et qui renvoie sa conversion \(c\) (en degrés Celsius).
   2. Combien font \(451^\circ F\) et \(0 ^\circ F\) en \(^\circ C\) ?
2. La formule de conversion de degrés Celsius vers des degrés Fahrenheit est \(f=\frac{9}{5}c+32\).
   1. Écrire une fonction c2f(c) qui prend en paramètre une température \(c\) (en degrés Celsius) et qui renvoie sa conversion \(f\) (en degrés Fahrenheit)
   2. Combien font \(42^\circ C\) et \(-273,15 ^\circ C\) en \(^\circ F\) ?
3. Pour trois valeurs x que vous choisirez librement, vérifiez que c2f(f2c(x)) et f2c(c2f(x)) sont proches de x.

Conversions de devises¶

1. Au taux de change, 1 dollar vaut 0,83 euros. Ecrire une fonction dollarVersEuro de conversion de dollar en euro.
2. Au taux de change, 1 euro vaut 91 roubles. Ecrire une fonction euroVersRouble de conversion d’euro en rouble.
3. Ecrire une fonction dollarVersrouble de conversion de dollar en rouble utilisant les deux fonctions précédentes.

Nombre d’entiers positifs¶

Dans cet exercice, on dira qu’un entier \(N\) est positif si \(N\geq 0\).

Ecrire un code qui partant de deux entiers a et b avec \(\mathtt{a\leq b}\) détermine le nombre d’entiers positifs entre \(\mathtt{a}\) et \(\mathtt{b}\) (les bornes \(\mathtt{a}\) et \(\mathtt{b}\) étant incluses). Voici quelques exemples de valeurs de selon les valeurs de a et b :

3 10 -> 8
3 3 -> 1
0 5 -> 6
0 0 -> 1
-5 -2 -> 0
-5 0 -> 1
-5 3 -> 4
-10000000000 10000000000 -> 10000000001

Explication pour a=-5 et b=3 : les entiers positifs entre -5 et 3 sont : 0, 1, 2 et 3, il y en a donc 4.

On écrira une fonction nbPositifs(a, b).

Votre code doit être capable de traiter instantanément des entiers de l’ordre de plusieurs milliards.

Fonction pour tester une année bissextile¶

Écrire une fonction estBissextile qui prend en paramètre un entier a et retourne True si l’année a est bissextile (False sinon). Pour rappel, une année a est bissextile si le booléen suivant

(a%4==0 and a%100!=0) or a%400==0

vaut True.

Date valide¶

On donne une liste [jour, mois] de deux entiers strictement positifs et on demande d’écrire une fonction estDateValide(j, m) qui dise si la date jour/mois définit une date valide du calendrier. La fonction doit renvoyer un booléen, par exemple :

On supposera que le mois de février a 28 jours.

On pourra créer une liste JOURS_MOIS telle que JOURS_MOIS[m] est le nombre de jours du m-ème mois (supposé entre 1 et 12).

Autre possibilité : utiliser une condition testant si le mois est en 31, 30 ou 28 jours.

Calculer son âge¶

Ecrire une fonction ecart(naissance, aujourdhui) qui partant de la date de naissance de Mady et de la date d’aujourd’hui détermine l’âge de Mady. Une date est donnée par une liste de la forme [j, m, a] où j désigne le jour, m le mois et a l’année. La liste donnant la date de naissance sera appelée naissance et la date du jour sera nommée aujourdhui.

Par exemple, supposons que naissance = [14, 11, 2005]. Si aujourdhui =  [5, 1, 2025] alors age = 19.

Implémenter la fonction max¶

Écrire une fonction maxi qui renvoie le maximum de deux nombres a et b passés en paramètre.

Implémenter la fonction valeur absolue¶

Écrire une fonction val_abs qui retourne la valeur absolue d’un nombre x passé en paramètre.

Fonction copysign¶

Ecrire le code d’une fonction copy_sign(x, y) qui prend en paramètres deux nombres réels et renvoie un nombre qui est positif si \(\mathtt{y\geq 0}\) et dont la valeur absolue est celle de x et l’opposé de la valeur absolue si \(\mathtt{y<0}\). Cette fonction est presque identique à la fonction copysign du module math de Python. Voici, sur quelques exemples, le comportement attendu de copy_sign :

(10, 42) → 10
(10, -42) → -10.0
(-10, 42) → 10.0
(-10, -42) → -10.0
(10, 0) → 10.0
(-10, 0) → 10.0
(0, 42) → 0.0
(0, -42) → 0.0

Distance entre deux nombres¶

Ecrire une fonction distance(a, b) qui calcule la distance entre deux nombres a et b. Par exemple, distance(3, 5) vaudra distance(5, 3) qui vaudra 2.

Fonction ensureRange¶

On donne trois nombres a, b et x. On demande d’écrire une fonction ensureRange(a, b, x) valant l’élément le plus proche de x situé dans l’intervalle d’extrémités a et b. Voici quelques exemples de comportements :

0, 5, 2.42 -> 2.42
5, 0, 2.42 -> 2.42
0, 5, 5 -> 5
5, 0, 5 -> 5
0, 5, 6.5 -> 5
5, 0, 6.5 -> 5
0, 5, -1 -> 0
5, 0, -1 -> 0
0, 0, 5 -> 0
0, 0, -1 -> 0
0, 0, 0 -> 0

Cette fonction est implémentée sous différents langages par une fonction nommée constrain (p5js) ou ensureRange (Pascal, Delphi) ou parfois valBetween en Javascript.

Le plus proche et entre -1 et 1¶

Ecrire une fonction plusProche(x) qui à partir d’un nombre x renvoie x si \(\mathtt{-1\leq x\leq 1}\), renvoie \(\mathtt{-1}\) si \(\mathtt{x < -1}\) et renvoie \(\mathtt{1}\) si \(\mathtt{x > 1}\). Autrement dit, le nombre renvoyé est le nombre de l’intervalle \(\mathtt{[-1, 1]}\) le plus proche de \(\mathtt{x}\).

Le plus proche parmi deux nombres¶

Ecrire une fonction plus_proche(a, b, x) qui renvoie parmi les nombres a ou b celui dont x est le plus proche. Si les deux nombres conviennent, la fonction renverra le plus petit des deux.

Exemples d’exécution de plus_proche(a, b, x) :

plusproche(40, 45, 42) = 40
plusproche(40, 43, 42) = 43
plusproche(40, 44, 42) = 40
plusproche(42, 42, 42) = 42
plusproche(38, 40, 42) = 40
plusproche(45, 49, 42) = 45

Inclusion d’intervalles¶

Dans cet exercice, l’intervalle des entiers \(\mathtt{x}\) compris, au sens large, entre deux entiers \(\mathtt{a}\) et \(\mathtt{b}\) sera représenté par la liste [a, b]. Par exemple, la liste L=[14, 18] représente les entiers 14, 15, 16, 17 et 18.

Ecrire une fonction inclus qui accepte comme paramètres deux intervalles A et B représentés chacun par une liste de 2 entiers et qui retourne True si l’intervalle A est inclus dans l’intervalle B, et False sinon. Exemples de comportement de la fonction :

[2, 3] inclus dans [1, 5] ? True
[0, 3] inclus dans [1, 5] ? False
[0, 6] inclus dans [1, 5] ? False

Segment découpé en parties de même longueur¶

Cet exercice n’est pas un exercice de dessin.

Ecrire une fonction decouper(a, b, n) qui affiche les valeurs où s’effectuent les découpages en \(n\) segments de même longueur d’un segment donné d’extrémités deux entiers \(a\) et \(b\) avec \(a\leq b\). Par exemple, decouper(10,12,8) doit afficher :

10
10.25
10.5
10.75
11.0
11.25
11.5
11.75
12.0

On observera qu’il y a \(n+1\) extrémités à donner et on pourra introduire une variable \(h\) pour la longueur de chaque segment.

Équation du second degré (version fonction)¶

On rappelle ci-dessous un code de résolution et d’affichage des solutions d’une équation du second degré \(ax^2+bx+c=0\) mais n’utilisant ni fonction ni liste :

a = 6
b = -5
c = 1
delta = b*b -4*a*c
if delta >0:
    print("2 solutions distinctes :")
    print("x1 =", (-b - delta**0.5)/(2.*a))
    print("x2 =", (-b + delta**0.5)/(2.*a))
elif delta == 0:
    print("une seule solution")
    print("x =", (-b)/(2.*a))
else:
    print("Aucune solution")

Vous devez adapter ce code pour les questions ci-dessous.

1. Ecrire une fonction resoudre_2nd_degre(a, b, c) qui résout dans l’ensemble des nombres réels l’équation du second degré. La fonction prend en paramètre \(\mathtt{a, b, c}\) les coefficients supposés entiers de l’équation \(\mathtt{ax^2+bx+c=0}\) et renvoie une liste de solutions, éventuellement vide.

2. Ecrire une fonction d’affichage afficher_solutions(a, b, c) des solutions. La fonction affichage doit utiliser la fonction précédente.

   Voici un exemple de comportements du code à écrire :

   a = 6 b = -5 c = 1 :
   
   2 solutions distinctes :
   x1 = 0.3333333333333333
   x2 = 0.5
   ----------------------------------------------
   a = 4 b = -12 c = 9 :
   
   une seule solution
   x = 1.5
   ----------------------------------------------
   a = 6 b = 7 c = 7 :
   
   Aucune solution
   ----------------------------------------------
   

Fonction de calcul du volume du ballon de rugby¶

Consulter l’article de wikipedia donnant le volume d’un ellipsoïde de révolution. Ne pas hésiter à faire un petit croquis en marquant le nom des variables qui interviennent dans la formule.

Ecrire une fonction volumeRugby(H, L) qui détermine le volume d’un ballon de rugby de hauteur H et de largeur L. On écrira explicitement la formule utilisée par Wikipedia, avec ses variables p et q et après avoir fait le lien avec les variables H et L.

On importera pi avec le module math.

Appliquer à un ballon standard de tailles \(H = 29 \text{cm}\) et \(L= 19 \text{cm}\), de volume environ 5,5 litres (rappel : 1 litre = \(\mathtt{1 dm^3}\) donc convertir les mesures en décimètres avant appel).

Volume d’un tétraèdre (version fonctions)¶

1. Ecrire une fonction volume(AB, BC, CA, DA, DB, DC) qui renvoie le volume du tétraèdre ABCD en fonction des longueurs de ses six côtés. On utilisera pour cela une des formules données par Wikipedia, celle dont le dénominateur est 12.

   Appliquer au tétraèdre ABCD de dimensions : AB=8, BC=5, CA=6, DA=4, DB=7 et DC=3. On trouvera un volume de 5.59 à 1/1000 près.

2. La formule de Héron donne l’aire d’un triangle lorsqu’on connaît la longueur de ses 3 côtés. Ecrire une fonction qui donne l’aire du triangle en fonction des ses côtés. On utilisera la variable auxiliaire accompagnant la formule.

3. Le rayon de la sphère inscrite à un tétraèdre est donné par la formule \(r=3V/\mathcal{A}\) où \(V\) est le volume du tétraèdre et \(\mathcal{A}\) la somme des aires des 4 faces. Appliquer au tétraèdre ABCD de dimensions : AB=8, BC=5, CA=6, DA=4, DB=7 et DC=3. On trouvera \(\mathtt{r= 0.411}\) à 1/1000 près. On ne demande pas d’écrire une fonction.

   Cette question est une réponse au problème SPOJ : Sphere in a tetrahedron

Triangle direct¶

On dit qu’un triangle \(\mathtt{ABC}\) est direct ou encore orienté dans le sens direct si lorsqu’on parcourt les sommets dans l’ordre \(\mathtt{A}\), puis \(\mathtt{B}\) suivi de \(\mathtt{C}\) et enfin \(\mathtt{A}\), on a tourné dans le sens inverse des aiguilles d’une montre. Par exemple, le triangle \(\mathtt{ABC}\) ci-dessous est un triangle direct :

On rappele que si \(\mathtt{M}\) est le point de coordonnées \(\mathtt{(x_M, y_M)}\) et si \(\mathtt{N}\) est le point de coordonnées \(\mathtt{(x_N, y_N)}\) alors les coordonnées du vecteur \(\overrightarrow{\mathtt{M}\mathtt{N}}\) sont :

\(\mathtt{(x_N-x_M, y_N-y_M)}\)

On donne trois points \(\mathtt{A}\), \(\mathtt{B}\) et \(\mathtt{C}\) et on demande d’écrire une fonction estDirect(A, B, C) qui dise si oui ou non, le triangle \(\mathtt{ABC}\) est un triangle direct. Pour cela,

• on calcule les coordonnées \(\mathtt{(x_1, y_1)}\) du vecteur \(\mathtt{\overrightarrow{CA}}\)

• on calcule les coordonnées \(\mathtt{(x_2, y_2)}\) du vecteur \(\mathtt{\overrightarrow{CB}}\)

• on détermine le signe de \(\mathtt{d=x_1y_2-x_2y_1}\) :

  • si \(\mathtt{d>0}\) le triangle \(\mathtt{ABC}\) est direct ;
  • si \(\mathtt{d<0}\) le triangle \(\mathtt{ABC}\) n’est pas direct.

Plus précisément, on fournit les coordonnées des trois sommets \(\mathtt{A}\), \(\mathtt{B}\) et \(\mathtt{C}\) pour chacun sous la forme d’une liste de deux nombres. L’appel estDirect(A, B, C) vaut True si le triangle \(\mathtt{ABC}\) est direct et False sinon.

Appliquer au triangle \(\mathtt{ABC}\) où

• A = [60, 70]
• B = [30, 24]
• C = [100, 50]

Écart-type d’une liste¶

Si on dispose d’une liste de \(\mathtt{n}\) nombres \(\mathtt{x_1}\), \(\mathtt{x_2}\), etc, \(\mathtt{x_n}\), on définit l” écart type de la liste comme le nombre suivant :

\(\mathtt{\ds\sqrt{\frac{(x_1-m)^2+\dots + (x_n-m)^2}{n}}}\)

où \(\mathtt{m=\ds\frac{x_1+\dots + x_n}{n}}\) est la moyenne de la liste.

Pour tester les questions, on pourra utiliser la liste L ci-dessous

L = [17, 11, 19, 13, 7, 7, 14, 0, 9, 16]

1. Ecrire une fonction moy(L) qui calcule la moyenne des nombres de la liste L. Dans le cas de la liste donnée en exemple, on trouvera une moyenne de 11,3
2. Ecrire une fonction decal(L, v) qui renvoie la liste dont les éléments sont les \(\mathtt{(z - v)^2}\) où z parcourt les éléments de L.
3. En utilisant les questions précédentes, écrire une fonction sigma(L) qui renvoie l’écart-type de L. Dans le cas de la liste donnée en exemple, on trouvera un écart-type valant environ 5,42

Somme des inverses des entiers¶

1. Ecrire une fonction harmonique(n) qui calcule la somme de tous les inverses des entiers entre 1 et \(n\), autrement dit, la somme \(1+\frac 12+\frac 13+\cdots+\frac 1n\).

   Voici quelques exemples du comportement de la fonction :

   1 -> 1.0
   2 -> 1.5
   3 -> 1.8333333333333333
   10 -> 2.9289682539682538
   2015 -> 8.18583825771582
   

2. Ecrire une fonction depasse(n, v) qui étant donné un entier n et un nombre entier v renvoie True si

   \(\displaystyle 1+\frac 12+\frac 13+\cdots+\frac 1n \geq v\)

   et False sinon. La fonction depasse devra utiliser la fonction harmonique. Voici quelques exemples du comportement de la fonction :

   10, 2 -> True
   10, 5 -> False
   100, 5 -> True
   1000000, 13 -> True
   

Nombre d’arrangements¶

Soient \(n\) et \(p\) deux entiers tels que \(0\leq p\leq n\). On définit l’entier noté \(A(n,p)\) représentant le nombre d’arrangements de \(p\) objets pris parmi \(n\) : c’est le produit des \(p\) entiers consécutifs en décroissant à partir de \(n\). Par exemple,

\(A(7,3)=7\times 6\times 5 =210\)

Ecrire une fonction arrang(n, p) qui renvoie le nombre d’arrangements de p objets pris parmi n.

Nombre de chiffres¶

1. Écrire une fonction nombreChiffres(n) qui étant donné un entier \(n\) entre 0 et 999 renvoie le nombre de chiffres de \(n\). Voici quelques exemples de comportement de la fonction :

   0 -> 1
   42 -> 2
   100 -> 3
   421 -> 3
   

2. Ecrire une fonction afficherNombreChiffres(n) qui affiche le nombre de chiffres d’un entier \(n\) supposé être entre 0 et 999. La fonction devra utiliser la fonction nombreChiffres. Voici quelques exemples de comportement de la fonction :

   n	afficherNombreChiffres(n) affiche
   0	Le nombre de chiffres de 0 est 1
   42	Le nombre de chiffres de 42 est 2
   100	Le nombre de chiffres de 100 est 3
   421	Le nombre de chiffres de 421 est 3

   L’affichage devra être strictement conforme à l’affichage indiqué dans le tableau ci-dessus.

Nombre de chiffres de \(n!\)¶

(Exercice pour matheux).

Le module standard math possède

• une fonction factorielle (factorial)
• une fonction partie entière (floor)
• une fonction logarithme en base 10 (log10).

Voici des exemple d’utilisation (exécutez-le) :

from math import *

print(factorial(42), end ='\n\n')
print(floor(3.14), end ='\n\n')
print(log10(10000), end ='\n\n')
print(log10(2016), end ='\n\n')
print(10**(log10(2016)))

On rappelle que si \(N>0\) est un entier, le nombre de chiffres de \(N\) vaut \(\left \lfloor{\log_{10} N}+1\right \rfloor\) où \(\left \lfloor{x}\right \rfloor\) désigne la partie entière de \(x\) et où \(\log_{10}\) désigne le logarithme en base 10. Par exemple,

\(42!=1405006117752879898543142606244511569936384000000000\)

et qui a 52 chiffres comme le code Python suivant nous le confirme (exécutez ce code) :

from math import *

x=factorial(42)
print(floor(log10(x)+1))

Ecrire une fonction nb_chiffres_factoriel qui calcule le nombre de chiffres de \(n!\). Votre code devra savoir répondre pour de grandes valeurs de \(n\) comme 1 million ou 1 milliard voire encore bien plus grand.

Moyenne harmonique¶

Etant donné \(n\) nombres non nuls \(a_1, a_2,\dots, a_n\), on définit la moyenne harmonique \(h\) de ces n nombres comme le nombre suivant :

\(\ds h=\frac{n}{\frac {1}{a_1} + \frac {1}{a_2} + \cdots + \frac {1}{a_n}}\)

Par exemple, si les entiers \(a_i\) sont ceux de la liste [6, 2, 7, 3] alors leur moyenne harmonique est 3,5.

La moyenne arithmétique de \(a_1, a_2,\dots, a_n\) est la moyenne habituelle, c’est-à-dire :

\(\ds\frac{{a_1} + {a_2} + \cdots + {a_n}}{n}\)

Par exemple, si les entiers \(a_i\) sont ceux de la liste [6, 2, 7, 3] alors leur moyenne arithmétique est 4,5.

[Ainsi, la moyenne harmonique de \(n\) nombres est l’inverse de la moyenne arithmétique des inverses de ces nombres.]

1. Ecrire une fonction moyenne(L) qui renvoie la moyenne arithmétique d’une liste de nombres.
2. Ecrire une fonction harmonique(L) qui renvoie la moyenne harmonique d’une liste L de nombres. Selon votre préférence, vous pouvez ou non, utiliser la fonction moyenne de la question précédente.

Somme supérieure à …¶

1. Ecrire une fonction s(n) qui renvoie la somme \(S=1^2+2^2+\cdots + n^2\). Ainsi, on trouvera que \(s(17)=1785\) ou encore que \(s(18)=2109\)

2. En utilisant la fonction s, construire une fonction f(N) où \(N>0\) est un entier et qui renvoie le plus petit entier \(n\) tel que la somme \(S=1^2+2^2+\cdots + n^2\) vérifie \(S\geq N\). Voici deux exemples de comportement de la fonction f :

   385 -> 10
   2015 -> 18
   

3. Le code précédent appliqué à rechercher le plus petit entier \(n\) tel que la somme \(S=1^2+2^2+\cdots + n^2\) vérifie \(S\geq 123456789101112\) sera beaucoup trop lent à donner une réponse. Construire une fonction g(N) où \(N>0\) est un entier, qui n’utilise pas la fonction s et qui renvoie le plus petit entier \(n\) tel que la somme \(S=1^2+2^2+\cdots + n^2\) vérifie \(S\geq N\). Pour N = 123456789101112, on trouvera que \(n\) vaut 71814.

Somme multiple de …¶

1. Ecrire une fonction s(n) qui renvoie la somme \(S=1^2+2^2+\cdots + n^2\). Ainsi, on trouvera que \(s(24)=4900\) ou encore que \(s(624)=81185000\)

2. En utilisant la fonction s, construire une fonction f(d) où \(d>0\) est un entier et qui renvoie le plus petit entier \(n>0\) tel que la somme \(S=1^2+2^2+\cdots + n^2\) soit multiple de \(d\). Voici deux exemples de comportement de la fonction f :

   100 -> 24
   1000 -> 624
   

3. Le code précédent appliqué à rechercher le plus petit entier \(n\) tel que la somme \(S=1^2+2^2+\cdots + n^2\) soit multiple de \(10^{10}\) sera beaucoup trop lent à donner une réponse. Construire une fonction g(d) où \(d>0\) est un entier, qui n’utilise pas la fonction s et qui renvoie le plus petit entier \(n>0\) tel que la somme \(S=1^2+2^2+\cdots + n^2\) soit multiple de \(d\). Pour \(d = 10^8\), on trouvera que \(n\) vaut 12890624.

Compter les entiers négatifs¶

Ecrire une fonction compter_neg qui prend en paramètre une liste d’entiers L et retourne le nombre de valeurs strictement négatives dans la liste L. On utilisera une variable nommée cpt.

Si vous connaissez les listes en compréhension, essayez de les utilisez. Votre code devrait tenir en une ligne et être aussi rapide (voire largement plus) sur de grosses listes que le code standard.

Si vous connaissez les listes en compréhension, essayez de les utilisez. Votre code devrait tenir en une ligne et être aussi rapide (voire largement plus) sur de grosses listes que le code standard.

Aucun multiple de 10¶

Écrire une fonction aucunMultiple10 qui prend en paramètre une liste d’entiers et qui renvoie True si la liste ne contient aucun multiple de 10. Voici deux exemples de comportement de la fonction :

[42, 81, 33, 81] -> True
[42, 91, 75, 90, 33] -> False

Valeurs non nulles d’une liste¶

Ecrire une fonction \(\mathtt{f}\) qui prend en paramètre une liste \(\mathtt{L}\) d’entiers et renvoie une nouvelle liste dont le contenu est formé des valeurs de \(\mathtt{L}\) non nulles. Par exemple:

• si \(\mathtt{L}\) est [5, 0, -3, 5, 0] alors f(L) est la liste [5, -3, 5]
• si \(\mathtt{L}\) est [5, 2, 1] alors f(L) est la liste [5, 2, 1]
• si \(\mathtt{L}\) est [0, 0, 0] alors f(L) est la liste vide.

Positivons …¶

Ecrire une fonction suppr_neg qui prend en paramètre une liste d’entiers L et retourne une (nouvelle) liste M déterminée à partir de L en en ignorant tous les éléments strictement négatifs. Par exemple :

[-6, 42, 5, -3, 0, 2, 0, -1] -> [42, 5, 0, 2, 0]

Si vous connaissez les listes en compréhension, le code devra les utiliser.

Remplacer les nombres négatifs¶

Pour cet exercice, on pourra consulter la partie du cours qui explique comment une fonction peut modifier un des arguments qu’il reçoit.

Ecrire une fonction rempl_neg qui prend en paramètre une liste d’entiers L, ne retourne rien mais remplace dans la liste L chaque entier négatif en son opposé, par exemple :

[-6, 2, 5, -3, 0, 2, 0, -1] -> [6, 2, 5, 3, 0, 2, 0, 1]

Ainsi, la fonction rempl_neg modifie la liste qu’elle reçoit en argument.

Liste des multiples de 2, 3 ou 5¶

Écrire une fonction \(\mathtt{f}\) qui prend en paramètre un entier \(\mathtt{n\geq 0}\) et qui renvoie la liste de tous les entiers \(\mathtt{k}\) tels que \(\mathtt{0\leq k\leq n}\) et \(\mathtt{k}\) est multiple de 2, 3 ou 5. Par exemple,

f(15) est la liste \(\mathtt{[0, 2, 3, 4, 5, 6, 8, 9, 10, 12, 14, 15]}\).

Nombre d’éléments entre deux valeurs¶

Soit une liste L d’entiers et soit \(z\) un entier. Ecrire une fonction nbOccur(L, z) qui renvoie le nombre d’éléments situées strictement entre le premier élément de L valant \(z\) et le dernier élément de L valant \(z\). Si \(z\) n’est pas présent ou est présent seulement une fois dans la liste L, la fonction renverra -1.

Ci-dessous, pour \(z=42\), quelques exemples du comportement attendu :

[42, 12, 81, 12, 42, 37, 42, 56] 42 -> 5
[42, 5, 42] 42 -> 1
[5, 42, 42, 5] 42 -> 0
[42, 42] 42 -> 0
[42, 42, 42, 42] 42 -> 2
[12, 81, 12, 42, 37] 42 -> -1
[12, 81, 12, 37] 42 -> -1

Liste d’entiers aléatoires¶

Ecrire une fonction listeAleatoire(N, a, b) qui renvoie une liste de N entiers aléatoires entre a et b au sens large. Voici quelques exemples de comportements

Sur certaines listes de trois entiers¶

On s’intéresse aux listes \(\mathtt{L}\) de 3 entiers vérifiant les deux propriétés suivantes :

• la liste \(\mathtt{L}\) contient exactement une fois l’entier 0,
• les deux entiers non nuls de \(\mathtt{L}\) ont même valeur.

Le tableau ci-dessous donne différents exemples de listes qui, selon les cas, vérifient ou, au contraire, ne vérifient pas, les propriétés ci-dessus :

Vous devez écrire une fonction f qui prend en paramètre une liste \(\mathtt{L}\) que l’on supposera contenir exactement trois entiers et qui

• renvoie True si \(\mathtt{L}\) vérifie les propriétés i) et ii),
• renvoie False sinon.

Extraction de valeurs aux indices impairs¶

On donne une liste L d’entiers et on demande de construire la liste des éléments de L qui sont non nuls et placés à des indices impairs. Par exemple, si la liste L est

L = [16, 10, 15, 0, 0, 12, 0, 19, 18, 0]

alors la liste demandée est [10, 12, 19].

On écrira une fonction indices(L).

Derniers éléments d’une liste¶

On donne une liste L d’entiers et un entier N et on demande d’écrire une fonction derniersElement(L, N) qui affiche les N derniers éléments de la liste L. Si N excède la longueur de la liste, on affiche tous les éléments de la liste. Si N=0, aucun élément n’est affiché. L’affichage ne doit faire apparaître ni crochets ni virgules. Voici quelques exemples de comportements avec la liste L=[42, 81, 99, 31, 12] et les entiers N de 0 à 6 :

0->
1-> 12
2-> 31 12
3-> 99 31 12
4-> 81 99 31 12
5-> 42 81 99 31 12
6-> 42 81 99 31 12

Derniers termes d’une liste¶

On donne un entier \(\mathtt{p\geq 0}\) et une liste L d’entiers et on appelle M la nouvelle liste formée des \(\mathtt{p}\) derniers éléments de L. Ecrire une fonction derniersElements(p, L) qui renvoie M. On supposera que \(\mathtt{0\leq p\leq n}\) où \(\mathtt{n}\) est le nombre d’éléments de L.

Voici quelques exemples de comportement de la fonction si L = [12, 81, 31, 65, 9, 32, 82] :

p = 4 -> [65, 9, 32, 82]
p = 1 -> [82]
p = 7 -> [12, 81, 31, 65, 9, 32, 82]
p = 0 -> []

Le code devra parcourir uniquement les éléments utiles de la liste L. Si vous connaissez les listes en compréhension, vous devez les utiliser.

Indice de la dernière occurrence¶

Ecrire une fonction dernier(L, v) qui, partant d’une liste L d’entiers et d’un entier v, renvoie :

• l’indice du dernier élément de L qui vaut v si un tel élément existe
• la longueur de la liste L sinon.

Exemples de comportement :

L = [20, 30, 50, 20, 50, 30, 40], v = 50 : 4
L = [40, 40, 40, 20, 30], v = 50 : 5
L = [10, 20, 30, 30], v = 10 : 0
L = [50, 40], v = 50 : 0
L = [20], v = 30 : 1

On pourra envisager deux méthodes, l’une qui parcourt la liste dans le sens des indices croissants, une autre qui le fait en commençant par la fin.

Cet exercice a été proposé sur le forum Python d’OpenClassrooms.

Valeur absolue des éléments d’une liste¶

Ecrire une fonction abs_liste qui prend en paramètre une liste d’entiers L et retourne une nouvelle liste formée des valeurs absolues des éléments de L. Exemples :

[-5, 4, 2, 0, -1, -2, 3] -> [5, 4, 2, 0, 1, 2, 3]
[42] -> [42]
[0, 0, 0, 0, 0] -> [0, 0, 0, 0, 0]
[-42, -42, -42, -42, -42] -> [42, 42, 42, 42, 42]

Carrés d’une liste¶

Ecrire une fonction carre_liste qui prend en paramètre une liste d’entiers L et retourne une nouvelle liste formée des carrés des éléments de L. La liste initiale L ne doit pas avoir été modifiée après un appel carre_liste(L) .

Exemples de comportement de la fonction :

[-5, 4, 2, 0, -1, -2, 3] -> [25, 16, 4, 0, 1, 4, 9]
[10] -> [100]

Minimum et maximum simultanés¶

Ecrire une fonction min_max qui prend en paramètre une liste L et retourne, sous forme de liste de deux éléments, la plus petite et la plus grande valeur de L.

Exemples :

[12, 81, 65, 9, 32] -> [9, 81]
[42] -> [42, 42]
[42, 42, 42, 42, 42] -> [42, 42]

Il est préférable que votre algorithme parcoure la liste une fois et une seule.

Extraire un point dans une liste¶

On donne une liste d’entiers \(\mathtt{L}\) de longueur paire \(\mathtt{2n}\). Par exemple, si \(\mathtt{n=5}\), on pourrait disposer de la liste suivante :

\(\mathtt{L=[0,0,4,0,4,7,0,4,-3, 4]}\)

La liste \(\mathtt{L}\) représente \(\mathtt{n}\) points du plan :

• le premier point a pour abscisse la première valeur de \(\mathtt{L}\)
• le premier point a pour ordonnée la deuxième valeur de \(\mathtt{L}\)
• le deuxième point a pour abscisse la troisième valeur de \(\mathtt{L}\)
• le deuxième point a pour ordonnée la quatrième valeur de \(\mathtt{L}\)
• et ainsi de suite.

Dans ce qui suit, un point \(\mathtt{M}\) d’abscisse \(\mathtt{x}\) et d’ordonnée \(\mathtt{y}\) sera notée à l’aide de la liste correspondante :

M = [x, y]

La liste \(\mathtt{L}\) donnée en exemple ci-dessus représente donc les 5 points de coordonnées suivants :

\(\mathtt{[0,0]}\), \(\mathtt{[4,0]}\), \(\mathtt{[4,7]}\), \(\mathtt{[0,4]}\) et \(\mathtt{[-3,4]}\).

Ecrire une fonction nroVersPoint(L, r) qui renvoie le point de la liste \(\mathtt{L}\) qui est à la \(\mathtt{r}\)-ème place. Avec la liste \(\mathtt{L}\) donnée en exemple ci-dessus, nroVersPoint(L, 3) renvoie \(\mathtt{[4,7]}\).

Réfléchir une liste¶

Écrire une fonction reflechir qui prend en paramètre une liste L et qui construit une nouvelle liste constituée, dans l’ordre, des éléments de L puis suivis des éléments de L, mais placés en commençant par la fin. Voici un exemple de comportement de la fonction :

[1000, 81, 12] -> [1000, 81, 12, 12, 81, 1000]

Attention, la liste initiale doit rester inchangée.

Nombres entre 1 et 99¶

1. Ecrire une fonction chiffres qui reçoit en paramètre un entier \(n\) tel que \(0\leq n\leq 99\) et qui renvoie la liste de ses chiffres, au sens usuel (le premier chiffre n’est pas 0 sauf pour 0). On pourra utiliser une division par 10. L’usage de la méthode append sera pénalisé. Voici quelques exemples de comportement de la fonction chiffres :

   42 -> [4, 2]
   7 -> [7]
   99 -> [9, 9]
   0 -> [0]
   

2. (Cette question est indépendante de la précédente) On donne un entier \(n\) et une liste L formée d’entiers ayant un ou deux chiffres entre 0 et 9 et on demande d’écrire une fonction estChiffres(L, n) qui renvoie True si L est la liste des chiffres de \(n\) lus de la gauche vers la droite et False sinon. Voici quelques exemples de comportement de la fonction estChiffres :

   [7] , 7 -> True
   [4, 2] , 42 -> True
   [0, 7] , 7 -> True
   [0] , 0 -> True
   [1, 8] , 81 -> False
   [7] , 42 -> False
   [8, 1] , 2016 -> False
   

Moitiés¶

On peut toujours décomposer un entier comme somme deux entiers, l’un étant sa « petite » moitié et l’autre sa « grande » moitié. Par exemple, comme 81=40+41, la petite moitié de 81 est 40 et sa grande moitié est 41. De même, comme 100=50+50, la petite et la grande moitié de 100 sont égales chacune à 50. Dit plus rigoureusement, si \(n=p+g\) avec \(p\) et \(g\) des entiers tels que \(p\leq n/2\leq g\) et \(g-p\) minimal alors \(p\) est la petite moitié de \(n\) et \(g\) sa grande moitié.

Ecrire une fonction moities(n) qui à partir d’un entier \(n\geq 0\) retourne la liste formée de sa petite moitié et de sa grande moitié. L’usage de la méthode append sera pénalisé. Voici quelques exemples de comportements de la fonction moities :

81 -> [40, 41]
100 -> [50, 50]
2021 -> [1010, 1011]
2038 -> [1019, 1019]
0 -> [0, 0]

Eléments distincts¶

Dans cet exercice, l’usage de la méthode append sera pénalisé.

Ecrire une fonction f qui prend deux paramètres entiers a et b et renvoie une liste formée des éléments distincts parmi les paramètres a et b. Voici deux exemples de comportement de f :

42, 81 -> [42, 81]
42, 42 -> [42]

Liste ordonnée à deux éléments¶

Ecrire une fonction trier(a, b) qui prend en paramètre deux entiers a et b et qui renvoie la liste contenant ces deux entiers et ordonnée dans le sens croissant. L’usage de la méthode append sera pénalisé.

Voici quelques exemples du comportement de la fonction :

2016 2020 -> [2016, 2020]
2020 2016 -> [2016, 2020]
2038 2038 -> [2038, 2038]

Éléments non nuls¶

Dans cet exercice, l’usage de la méthode append sera pénalisé.

Ecrire une fonction f qui prend deux paramètres entiers a et b et renvoie une liste formée de tous les éléments non nuls parmi les paramètres a et b. Voici quatre exemples de comportement de f:

a =  42 , b =  81 -> [42, 81]
a =  0 , b =  12 -> [12]
a =  21 , b =  0 -> [21]
a =  0 , b =  0 -> []

Objets qui s’accordent¶

On dispose de deux types d’objets : les objets de type A et les objets de type B.

Un objet de type A est représenté par une liste de couleurs, par exemple

["rouge", "vert", "noir", "rouge", "bleu"]

Les couleurs peuvent ou non être distinctes.

Un objet de type B est représenté par un entier k et une couleur et que l’on rassemblera dans une liste, par exemple

[3, "gris"]

On dit qu’un objet de type A (représenté par la liste de couleurs L) et un objet de type B (représenté par l’entier k et la couleur s) s’accordent si les deux conditions suivantes sont satisfaites :

• le nombre de couleurs dans L, distinctes ou non, et l’entier k sont égaux
• la couleur s ne figure pas dans la liste L

Ecrire une fonction accord(a, b) qui prenant deux paramètres a et b représentant un objet de type A et un objet de type B renvoie True si A et B s’accordent et False. L’argument représentant a sera une liste de couleurs et l’argument représentant b sera une liste formée d’un entier et d’une couleur. Les couleurs sont données sous forme de chaîne de caractères.

Par exemple, si a est représenté par la liste suivante

a = ["rouge", "vert", "noir", "rouge", "bleu"]

alors on observe les comportement suivants :

b = [5, 'rose'] : accord
b = [3, 'rose'] : désaccord
b = [4, 'rose'] : désaccord
b = [5, 'noir'] : désaccord

Cet exercice est directement inspiré du 2e exercice qualificatif du concours Prologin 2022.

Afficher un mouvement¶

Soit une liste L formée d’entiers parmi \(-1\), \(0\) ou \(1\), par exemple L= [-1, 0, -1, 0, 0, 1, -1, 0]. Chaque entier représente une direction de déplacement :

• l’entier \(-1\) représente le déplacement à gauche
• l’entier \(0\) représente le déplacement tout droit
• l’entier \(1\) représente le déplacement à droite

Ecrire une fonction afficherDirection qui prend en paramètre une liste L formée d’entiers parmi \(-1\), \(0\) ou \(1\) et qui affiche une suite de directions de déplacement.

Par exemple, si L= [-1, 0, -1, 0, 0, 1, -1, 0] alors la fonction affichera :

à gauche
tout droit
à gauche
tout droit
tout droit
à droite
à gauche
tout droit

L’utilisation d’une liste de chaînes de caractères est encouragée mais il est toutefois possible de répondre à l’exercice sans y avoir recours

Doubler¶

Ecrire une fonction f qui prend en paramètre une liste d’entiers et renvoie True si chaque élément de la liste est le double du précédent.

Le code sera pénalisé s’il n’utilise pas une boucle while pour résoudre le problème.

Exemples de comportement :

[10, 20, 40, 80, 160] -> True
[10] -> True
[10, 20, 42, 80, 160] -> False
[] -> True

Moyenne olympique¶

La moyenne olympique d’une liste L d’au moins trois nombres est la moyenne des nombres de la liste L dont on a retiré deux valeurs :

• la plus grande valeur de L
• la plus petite valeur de L.

Par exemple, la moyenne olympique de la liste L = [12, 7, 18, 10, 4, 13, 9] est 10.2.

\(\frac{12 + 7+10+13+9}{5} =10.2\)

La moyenne olympique d’une liste d’un ou deux nombres est la moyenne habituelle.

Ecrire une fonction moy_olymp(L) qui renvoie la moyenne olympique d’une liste de nombres. Il est préférable que votre algorithme parcoure la liste une fois et une seule.

Un élément sur trois¶

Ecrire une fonction \(f\) qui prend une liste L d’entiers et qui renvoie la liste M formée d’un élément sur 3 de la liste L en commençant par la fin. Exemples :

[19, 43, 25, 54, 71, 76, 88, 53, 67, 22, 90, 79, 12, 25]
-> [25, 90, 53, 71, 43]

[19, 43, 25, 54] -> [54, 19]
[19] -> [19]

Sommer deux par deux¶

On donne une liste L d’entiers et on demande de produire une liste M d’entiers telle que chaque élément de M soit obtenu en faisant la somme deux éléments consécutifs de L. Par exemple, si L est la liste :

L=[5, 3, 4, 9, 6, 6, 0, 3]

alors M sera la liste

M=[8, 13, 12, 3]

Si L est formé d’un nombre impair d’éléments, le dernier élément de L sera placé à la fin de M. Par exemple, si L est la liste :

L=[5, 3, 4, 9, 6, 6, 0, 3, 5]

alors M sera la liste

M=[8, 13, 12, 3, 5]

1. Ecrire une fonction qui somme_paires(L) qui renvoie la liste M. On introduira le quotient entier q de n par 2 et on traitera le cas où n est impair.

2. Si on répète le procédé précédent jusqu’à ce que la liste ne contienne qu’un seul élément, alors cet élément sera la somme des éléments de la liste initiale. Par exemple, si on applique cette méthode à la liste L=[5, 3, 7, 5, 1], voici les différentes étapes qu’on obtient :

   [5, 3, 7, 5, 1]
   [8, 12, 1]
   [20, 1]
   [21]
   

   et la somme des éléments de L est bien 21.

   Ecrire une fonction somme(L) qui applique cette méthode pour calculer la somme des éléments de L.