Exercices Python

par · Publié · Mis à jour

Sites pour apprendre en s’amusant

 

Exercices ciblés

Les exercices suivants portent sur des éléments bien précis du langage Python.

 

Exercices divers

Comptage de lettres

Écrire une fonction compterLettre(texte, lettre) ayant pour arguments une chaîne de caractères texte et un caractère lettre et qui renvoie un dictionnaire qui contient la fréquence de la lettres dans la chaîne.

 

Écrire une fonction compterLettres(texte) ayant pour argument une chaîne de caractères texte et qui renvoie un dictionnaire qui contient la fréquence de toutes les lettres de la chaîne entrée.

par exemple, compterLettres("L'informatique, c'est fantastique !") doit renvoyer :  {'t': 4, 'n': 2, 'i': 3, ',': 1, 'o': 1, ' ': 3, 'f': 2, 'm': 1, "'": 2, 's': 2, 'L': 1, 'u': 2, 'c': 1, 'r': 1, 'e': 3, '!': 1, 'a': 3, 'q': 2}

Correction
def compterLettre(texte, lettre):
   # à faire !
   return
def compterLettres(texte):
   d = {}
   for c in texte:
      if c in d.keys():
         d[c] += 1
      else:
         d[c] = 1
   return d

 

 Rectangles

Soient deux rectangles définis par des listes de la forme [positionX, positionY, largeur, hauteur].

Écrire une fonction intersection() qui à partir de deux rectangles ainsi définis renvoie, s'il existe, le rectangle intersection.

 

 

 

Correction
def intersection(rect1, rect2):
   x1, y1, l1, h1 = rect1
   x2, y2, l2, h2 = rect2
   x3 = max(x1, x2)
   y3 = max(y1, y3)
   l3 = max(x1+l1-x2, x2+l2-x1)
   h3 = max(y1+h1-y2, y2+h2-y1)
   if l3 <0 or h3 < 0:
      return
   return x3, y3, l3, h3

 

 Cinématique

Écrire une instruction qui permet de calculer puis afficher la distance d parcourue par un point qui s'est déplacé à vitesse constante v pendant un temps t.

 

Améliorer l'affichage pour limiter le résultat à 3 chiffres significatifs, quelles que soient les valeurs de d et t.

 

La vitesse n'est plus constante. Elle est donnée par une fonction v(t).

Écrire un algorithme permettant d'estimer la vitesse parcourue par une méthode d'intégration numérique : méthode des rectangles et méthode des trapèzes.

(voir https://fr.wikipedia.org/wiki/Calcul_numérique_d'une_intégrale)

méthode des trapèzes

méthode des rectangles

remarque : écrire cet algorithme dans une fonction distance()  acceptant comme arguments :

la fonction v, l'intervalle de temps (t0, t1) pendant lequel estimer la distance parcourue, et la durée dt  de l'échantillon de calcul.

Correction
v = 10.2 # m/s
t = 2.3 # s
d = v*t
print(d)
print(round(d, 3))
# mieux :
print("%.2E" %d)

v = lambda t:t**2 # v(t)
dt = 0.1      # s
t0, t1 = 1, 3 # s

def distance_rect(v, t0, t1, dt):
   t = t0
   d = 0
   while t < t1:
      d += dt*(v(t))
      t += dt
   return d

def distance_trap(v, t0, t1, dt):
   t = t0
   d = 0
   while t < t1-dt:
      d += dt*(v(t)+v(t+dt))/2
      t += dt
   return d

 

 Recherche dans une liste (séquentielle et dichotomique)

Il est fréquemment nécessaire de rechercher un élément particulier dans une liste (de nombres, de mots, de couleurs, ....).

Soit une liste de nombres réels, classés par ordre croissants :

from random import random
l = sorted([random() for i in range(1000)])

L'objectif de l'exercice est d'obtenir l'indice i et la valeur v de l'élément de la liste le plus proche d'un nombre n donné (mais inférieur).

Écrire un algorithme réalisant ceci par balayage (recherche séquentielle) : par test de tous les éléments de la liste depuis le premier, jusqu'à celui recherché.

Correction
Indice = 0
Tant que l'élément d'indice Indice < Valeur_recherchée et ...(à compléter)...
   Incrémenter Indice
Élément_recherché = élément d'indice Indice

 

Écrire un algorithme de recherche dichotomique :

On envisage deux types de fonction : une fonction séquentielle et une fonction récursive.

Comparer les performances de ces 3 solutions à l'aide de méthodes de mesure de performances.

Correction
n = 0.6  # Valeur recherchée

def recherche_seq(n, l):
   i = 0
   while i < len(l) and ...... :
      i += 1
   return ... , ...

def recherche_dicho(n, l):
   i = 0
   j = len(l) - 1
   while .... :
      m = (i+j) // 2
      if n >= l[m]:      # la valeur recherchée est "à droite"
         ......
      else:
         ......
   return ... ,  ...

 

rubikscube Rubik's cube

Construire un tableau (une liste de listes) représentant la face de ce Rubik's cube :

 

Réaliser une fonction tourner_Rubik() opérant une rotation d'un quart de tour (sens trigonométrique) des cases du Rubik'cube.

 

 Suite de Conway

1 11 21 1211 111221 312211 13112221 1113213211 31131211131221 …

"Avez-vous deviné la règle de construction de cette suite ? Le premier terme se compose de un « un », puis le deuxième énonce le premier « un un ». Ce deuxième terme se compose de deux « un », donc le troisième, énonçant le deuxième, est « deux un ». Il est composé de un « deux » et de un « un », et donc est suivi par « un deux un un », et ainsi de suite."

J.H. Conway , The Book of Numbers , Springer-Verlag, 1996

Écrire une fonction Conway(u_n) acceptant en argument une chaîne de caractères représentant un terme \(u_n\) de la suite de Conway et renvoyant le terme \(u_{n+1}\).

 

 Génération de code HTML

Écrire une fonction qui accepte comme argument un dictionnaire (clefs et valeurs de type chaîne de caractères) et renvoie le code HTML d'un tableau :
<!DOCTYPE html>
<html>
<body>
<table border="1" style="width:100%">
  <tr>
    <td>Père</td>
    <td>Homer</td>        
  </tr>

  <tr>
    <td>Mère</td>
    <td>Marge</td>        
  </tr>

  <tr>
    <td>Fils</td>
    <td>Bart</td>         
  </tr>
</table>
</body>
</html>

 

 7 segments

Écrire une fonction sept_seg() capable de convertir un nombre décimal dans un format pour afficheurs "7 segments".

Par exemple, la chaîne de caractères "23" sera convertie en une chaîne de caractères qui s'affichera comme ceci :

 _  _
 _| _|
|_  _|

Ce qui correspond à la chaîne de caractères :" _ _ \n _| _|\n|_ _|\n"

Correction
# Solution la plus courte !!! (http://pycontest.net/job)
>>> j=''.join;seven_seg=lambda z:j(j(' _   |_|_ _| |'[-~ord("¤Ž°Ú¬¼hJž"[int(a)])%u:][:3]for a in z)+"\n"for u in(3,14,10))
>>> seven_seg("23")
 _  _ 
 _| _|
|_  _|

Mais on doit pouvoir faire plus lisible !!

 

Vous aimerez aussi...

  • Les listes

    Les listes

  • EduPython

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *