Aller au contenu

Sujet n°36

Sujet original

Pour télécharger l'énoncé original, cliquer ici.

Exercice n°1

Programmer la fonction recherche, prenant en paramètre un tableau non vide tab (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
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def recherche(tab, n):
    """
    tab - list, tableau non vide d'entiers
    n - int
    Sortie: int, indice de la dernière occurence de n dans le tableau
            len(tab) si n n'est pas présent
    """
    indice_elt = -1
    for i in range(len(tab)):
        if tab[i] == n:
            indice_elt = i
    if indice_elt == -1:
        indice_elt = len(tab)
    return indice_elt


if __name__ == '__main__':
    print(recherche([5, 3], 1) == 2)
    print(recherche([2, 4], 2) == 0)
    print(recherche([2, 3, 5, 2, 4], 2) == 3)

Exercice n°2

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

On dispose d'une fonction distance et d'une fonction plus_courte_distance :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
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)

assert distance((1, 0), (5, 3)) == 5.0, "erreur de calcul"

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

assert plus_courte_distance([(7, 9), (2, 5), (5, 2)], (0, 0)) == (2, 5), "erreur"
Commentaires sur le code original
  1. Pour télécharger l'original du fichier à compléter, cliquer ici.

  2. L'exemple est proposé avec des assertions, ce qui diffère des énoncés habituels et devrait être évité par soucis d'harmonisation.

  3. Le premier tests d'assertion aurait pu être placé en fin de programme. De plus, effectuer un test d'égalité sur des flottants est hasardeux (il vaut mieux importer la fonction isclose()).

  4. La deuxième fonction est mal nommée puisqu'elle renvoie un point (couple de coordonnées) au lieu d'une valeur (plus courte distance).

  5. La deuxième fonction ne donne pas d'indication sur le point à sélectionner si plusieurs conviennent. En se basant sur le second test d'assertion, on peut en déduire que c'est le premier rencontré qui convient.

Recopier sous Python (sans les commentaires) ces deux fonctions puis compléter leur code et ajouter une ou des déclarations (assert) à la fonction distance permettant de vérifier la ou les préconditions.

Une solution

Attention ! Vous devez compléter les pointillés et seulement les pointillés : il ne faut pas ajouter d'autres instructions, ni définir de fonction supplémentaire...

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((point1[0] - point2[0])**2 + ((point1[1] - point2[1]))**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 = distance(point, depart)
    for i in range (1, len(tab)):
        if distance(tab[i], depart) < min_dist :
            point = tab[i]
            min_dist = distance(point, depart)
    return point


if __name__ == '__main__':
    print(distance((1, 0), (5, 3)) == 5.0)
    print(plus_courte_distance([(7, 9), (2, 5), (5, 2)], (0, 0)) == (2, 5))