Nous souhaitons programmer une fonction qui, étant donné une liste de points du plan à coordonnées entières, donne celui qui est le plus proche d'un point de départ.

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.

La distance utilisée est la distance euclidienne, dont on rappelle la définition. La distance euclidienne entre deux points du plan de coordonnées \((x_1;y_1)\) et \((x_2;y_2)\) est donnée par la formule :

\[d=\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}\]

Indication

Si la variable point référence notre couple de coordonnées, alors le décompactage permet de donner un nom simple aux composantes point[0] et point[1] :

🐍 Script Python

x, y = point

Vous pouvez utiliser cette astuce dans votre solution.

Nous disposons d'une fonction distance et d'une fonction plus_proche dans l'IDE suivant. Compléter comme il se doit et tester.

Exemples

🐍 Console Python

>>> plus_proche([(7, 9), (2, 5), (5, 2)], (0, 0))
(2, 5)
>>> plus_proche([(7, 9), (2, 5), (5, 2)], (7, 9))
(7, 9)

∞/∞

from math import sqrtbksl-nlbksl-nldef distance(pointpy-und1, pointpy-und2):bksl-nl """ Calcule et renvoie la distance euclidiennebksl-nl entre deux points. """bksl-nl # vous pouvez ajouter des lignes de code ici si besoinbksl-nl return sqrt(((...)py-strpy-str2 + (...)py-strpy-str2))bksl-nlbksl-nldef pluspy-undproche(points, depart):bksl-nl """ Renvoie le point du tableau points se trouvant à la plus bksl-nl courte distance du point depart."""bksl-nl pointpy-undproche = points[0]bksl-nl distpy-undminimale = ...bksl-nl for i in range(1, ...):bksl-nl point = ...bksl-nl distpy-undcourante = ...bksl-nl if distpy-undcourante ...:bksl-nl pointpy-undproche = ...bksl-nl distpy-undminimale = ...bksl-nl return pointpy-undprochebksl-nlbksl-nlbksl-nl# testsbksl-nlbksl-nlassert pluspy-undproche([(7, 9), (2, 5), (5, 2)], (0, 0)) == (2, 5)bksl-nlassert pluspy-undproche([(7, 9), (2, 5), (5, 2)], (7, 9)) == (7, 9)bksl-nlbksl-nlfrom math import sqrtbksl-nlbksl-nldef distance(pointpy-und1, pointpy-und2):bksl-nl """ Calcule et renvoie la distance euclidiennebksl-nl entre deux points. """bksl-nl # vous pouvez ajouter des lignes de code ici si besoinbksl-nl x1, y1 = pointpy-und1bksl-nl x2, y2 = pointpy-und2bksl-nl return sqrt(((x1 - x2)py-strpy-str2 + (y1 - y2)py-strpy-str2))bksl-nlbksl-nldef pluspy-undproche(points, depart):bksl-nl """ Renvoie le point du tableau points se trouvant à la plus bksl-nl courte distance du point depart."""bksl-nl pointpy-undproche = points[0]bksl-nl distpy-undminimale = distance(pointpy-undproche, depart)bksl-nl for i in range(1, len(points)):bksl-nl point = points[i]bksl-nl distpy-undcourante = distance(point, depart)bksl-nl if distpy-undcourante < distpy-undminimale:bksl-nl pointpy-undproche = pointbksl-nl distpy-undminimale = distpy-undcourantebksl-nl return pointpy-undprochebksl-nlbksl-nl

Commentaires⚓︎

Première version⚓︎

Variante⚓︎

Une autre possibilité en initialisant la distance minimale à \(+\infty\) et en faisant une boucle sur les éléments du tableau et non sur les indices.

D'autre part, comme ce qui nous intéresse ici est de comparer les distances, nous pouvons nous contenter de calculer le carré de la distance euclidienne. Nous éviterons ainsi la manipulation des nombres flottants.

🐍 Script Python

def distance_carree(point_1, point_2):
    """ Calcule et renvoie le carré de la distance euclidienne
    entre deux points. """
    # vous pouvez ajouter des lignes de code ici si besoin
    x1, y1 = point_1
    x2, y2 = point_2
    return ((x1 - x2)**2 + (y1 - y2)**2)

def plus_proche(points, depart):
    """ Renvoie le point du tableau points se trouvant à la plus 
    courte distance du point depart."""
    point_proche = None
    dist_minimale = float('inf')
    for point in points:
        dist_courante = distance_carree(point, depart)
        if dist_courante < dist_minimale:
            point_proche = point
            dist_minimale = dist_courante
    return point_proche