Différences entre versions de « Tutoriel:Tri pointu pour une liste »

De GeoGebra Manual
Aller à : navigation, rechercher
 
(6 versions intermédiaires par 3 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
 +
{{Tutoriel|titre=Tri pointu pour une liste.}}
 +
 +
 
Si vous désirez trier une  liste d'objets  GeoGebra, il n'est pas improbable que la manière de trier que vous désirez ne soit pas possible avec la commande [[Commande Trier|Trier]].<br /> (Si vous désirez simplement inverser le résultat, vous pouvez utiliser <code>Trier[]</code> en association avec la commande [[Commande Retourner|Retourner[]]]).
 
Si vous désirez trier une  liste d'objets  GeoGebra, il n'est pas improbable que la manière de trier que vous désirez ne soit pas possible avec la commande [[Commande Trier|Trier]].<br /> (Si vous désirez simplement inverser le résultat, vous pouvez utiliser <code>Trier[]</code> en association avec la commande [[Commande Retourner|Retourner[]]]).
  
Ligne 9 : Ligne 12 :
  
 
== Explication ==
 
== Explication ==
 +
 +
 
Pour clarifier la situation, essayons de formuler la demande mathématiquement : Soit une liste <math>(a_1, a_2, \ldots, a_n) \subset X</math> et une application  <math>f: X \to \mathbb R</math>, nous voulons trouver une permutation <math>\sigma \in S_n</math>  telle que <math>f(a_{\sigma(k)}) \leq f(a_{\sigma(l)}) \; \forall (k,l) \in \mathbb N^2: 1 \leq k \leq l \leq n</math>. Vous pouvez interpréter la permutation <math>\sigma</math> comme une renumérotation telle que <math>(a_{\sigma(1)}, a_{\sigma(2)}, \ldots, a_{\sigma(n)})</math>soit la liste triée.
 
Pour clarifier la situation, essayons de formuler la demande mathématiquement : Soit une liste <math>(a_1, a_2, \ldots, a_n) \subset X</math> et une application  <math>f: X \to \mathbb R</math>, nous voulons trouver une permutation <math>\sigma \in S_n</math>  telle que <math>f(a_{\sigma(k)}) \leq f(a_{\sigma(l)}) \; \forall (k,l) \in \mathbb N^2: 1 \leq k \leq l \leq n</math>. Vous pouvez interpréter la permutation <math>\sigma</math> comme une renumérotation telle que <math>(a_{\sigma(1)}, a_{\sigma(2)}, \ldots, a_{\sigma(n)})</math>soit la liste triée.
  
Ligne 17 : Ligne 22 :
 
{{example|1=
 
{{example|1=
 
Si nous voulons ordonner une liste de cercles suivant les valeurs croissantes de leur rayon, la '''*section  en gras*''' dans l'algorithme peut être lue comme  <code>Rayon[Elément[liste,i]]</code>.}}
 
Si nous voulons ordonner une liste de cercles suivant les valeurs croissantes de leur rayon, la '''*section  en gras*''' dans l'algorithme peut être lue comme  <code>Rayon[Elément[liste,i]]</code>.}}
{{example|1=Une construction complète pour trier une liste de nombres complexes en fonction de leur argument peut être trouvée sur [http://www.geogebra.org/material/show/id/7518 GeoGebra].
+
 
 +
{{example|1=Une construction complète pour trier une liste de nombres complexes en fonction de leur argument peut être trouvée sur [http://www.geogebra.org/material/show/id/7774 GeoGebra]. <br/> Testable en ligne ci-dessous : Déplacez un point quelconque pour faire varier l'argument du nombre complexe représenté :
 
}}  
 
}}  
 +
 +
<ggb_applet width="1225" height="570"  version="4.0" id="7774" framePossible = "true" showResetIcon = "false" showAnimationButton = "true" enableRightClick = "false" errorDialogsActive = "true" enableLabelDrags = "false" showMenuBar = "false" showToolBar = "false" showToolBarHelp = "false" showAlgebraInput = "false" useBrowserForJS = "true" allowRescaling = "true" />
 +
 
L'astuce pour résoudre ce problème avec GeoGebra est d'utiliser la commande existant pour trier une liste de point.<br />
 
L'astuce pour résoudre ce problème avec GeoGebra est d'utiliser la commande existant pour trier une liste de point.<br />
 
Au lieu de considérer géométriquement un point, nous le considérons simplement comme un couple de nombres.<br /> GeoGebra nous permet de trier ces points par leur abscisse,  ainsi nous créons une liste de points <math>\tilde c = (\tilde c_1, \ldots, \tilde c_n)</math> avec <math>\tilde c_k := (f(a_k), k)</math> et trions cette liste. Appelons cette liste triée <math>c = (c_1, \ldots, c_n)</math>. Elle nous permet maintenant de construire <math>\sigma</math>, parce que <math>y(c_{\sigma(k)}) = k</math>. En utilisant <math>\sigma</math> nous pouvons ensuite construire la version triée de notre liste originale.
 
Au lieu de considérer géométriquement un point, nous le considérons simplement comme un couple de nombres.<br /> GeoGebra nous permet de trier ces points par leur abscisse,  ainsi nous créons une liste de points <math>\tilde c = (\tilde c_1, \ldots, \tilde c_n)</math> avec <math>\tilde c_k := (f(a_k), k)</math> et trions cette liste. Appelons cette liste triée <math>c = (c_1, \ldots, c_n)</math>. Elle nous permet maintenant de construire <math>\sigma</math>, parce que <math>y(c_{\sigma(k)}) = k</math>. En utilisant <math>\sigma</math> nous pouvons ensuite construire la version triée de notre liste originale.
Ligne 29 : Ligne 38 :
 
La <code>liste</code> de l'algorithme ci-dessus, sera alors définie par <code>liste=Séquence[Objet[Elément[listeD, k]], k, 1, Longueur[listeD]]</code>.
 
La <code>liste</code> de l'algorithme ci-dessus, sera alors définie par <code>liste=Séquence[Objet[Elément[listeD, k]], k, 1, Longueur[listeD]]</code>.
  
Une fois, votre liste triée dans la <code>liste_t </code>, vous analysez les rangs de chacun des objets, par la commande :
 
<code>RangNoms=Nettoyer[Unir[Séquence[Séquence[Si[Elément[liste_t, i] ≟ Elément[liste, j], i], i, 1, Longueur[liste]], j, 1, Longueur[liste]]]]</code>
 
  
 
Et maintenant, vous pouvez obtenir la liste ordonnée des noms par la commande :
 
Et maintenant, vous pouvez obtenir la liste ordonnée des noms par la commande :
  
<code>listeA=Séquence[Elément[listeD, Position[j, RangNoms]], j, 1, Longueur[listeD]]</code>
+
<code>listeA=Séquence[Elément[listeD, y(Elément[liste_a, k])], k, 1, Longueur[listeD]]</code>
 +
 
 +
 
 +
Ainsi l'exemple mis en ligne ci-dessus utilise les listes :
  
 +
listeD = {"w", "w_1", "w_2", "w_3", "z", "z_1", "z_2", "z_3"}
 +
liste=Séquence[Objet[Elément[listeD, k]], k, 1, Longueur[listeD]]
 +
liste_a=Trier[Séquence[(arg(Elément[liste, i]) + Si[arg(Elément[liste, i]) < 0, 6.28319, 0], i), i, 1, Longueur[liste]]]
 +
liste_t=Séquence[Elément[liste, y(Elément[liste_a, i])], i, 1, Longueur[liste]]
 +
listeA=Séquence[Elément[listeD, y(Elément[liste_a, k])], k, 1, Longueur[listeD]]
  
 
[[Catégorie:Tutoriel]]
 
[[Catégorie:Tutoriel]]
[[en:Tutorial:Advanced_List_Sorting]]
 
[[es:Tutorial:Orden de Listas Avanzado]]
 

Version actuelle datée du 28 novembre 2019 à 00:26

Tutoriel : Tri pointu pour une liste.


Si vous désirez trier une liste d'objets GeoGebra, il n'est pas improbable que la manière de trier que vous désirez ne soit pas possible avec la commande Trier.
(Si vous désirez simplement inverser le résultat, vous pouvez utiliser Trier[] en association avec la commande Retourner[]).

Mais dans le cas où le type d'objet n'est pas traité par Trier[] ou que vous désirez un critère de tri complétement différent, cette page peut vous aider dans votre recherche. Si vous avez des difficultés à comprendre l'algorithme, vous pouvez trouver ensuite l'explication et des exemples.

Algorithme

  1. Soit liste la liste que nous voulons trier.
  2. liste_a = Trier[Séquence[(*nombre basé sur Elément[liste, i]*, i), i, 1, Longueur[liste]]]
    Elle correspond à c dans l'explication (la liste d'aide). La *section en gras* est appelée f dans l'explication.
  3. liste_t = Séquence[Elément[liste, y(Elément[liste_a, i])], i, 1, Longueur[liste]]
    C'est la liste triée.

Explication

Pour clarifier la situation, essayons de formuler la demande mathématiquement : Soit une liste (a_1, a_2, \ldots, a_n) \subset X et une application f: X \to \mathbb R, nous voulons trouver une permutation \sigma \in S_n telle que f(a_{\sigma(k)}) \leq f(a_{\sigma(l)}) \; \forall (k,l) \in \mathbb N^2: 1 \leq k \leq l \leq n. Vous pouvez interpréter la permutation \sigma comme une renumérotation telle que (a_{\sigma(1)}, a_{\sigma(2)}, \ldots, a_{\sigma(n)})soit la liste triée.

Ainsi nous devons d'abord établir une application f en adéquation avec notre tri, par exemple :

Exemple: Si nous voulons ordonner une liste de points suivant les valeurs croissantes de leur distance à l'origine, nous avons X := \mathbb R^2 et f((x,y)) := \sqrt{x^2 + y^2}. Dans GeoGebra, f pour un point A peut être Longueur[A], ainsi la *section en gras* dans l'algorithme peut être lue comme Longueur[Elément[liste,i]].
Exemple: Si nous voulons ordonner une liste de cercles suivant les valeurs croissantes de leur rayon, la *section en gras* dans l'algorithme peut être lue comme Rayon[Elément[liste,i]].
Exemple: Une construction complète pour trier une liste de nombres complexes en fonction de leur argument peut être trouvée sur GeoGebra.
Testable en ligne ci-dessous : Déplacez un point quelconque pour faire varier l'argument du nombre complexe représenté :

L'astuce pour résoudre ce problème avec GeoGebra est d'utiliser la commande existant pour trier une liste de point.
Au lieu de considérer géométriquement un point, nous le considérons simplement comme un couple de nombres.
GeoGebra nous permet de trier ces points par leur abscisse, ainsi nous créons une liste de points \tilde c = (\tilde c_1, \ldots, \tilde c_n) avec \tilde c_k := (f(a_k), k) et trions cette liste. Appelons cette liste triée c = (c_1, \ldots, c_n). Elle nous permet maintenant de construire \sigma, parce que y(c_{\sigma(k)}) = k. En utilisant \sigma nous pouvons ensuite construire la version triée de notre liste originale.


Et pour les noms ?

La démarche précédente peut sembler frustrante, si on veut récupérer la liste ordonnée des noms des objets.
Définissez au départ, la liste des noms (en tant que textes) listeD={"nom1","nom2", ... }.

La liste de l'algorithme ci-dessus, sera alors définie par liste=Séquence[Objet[Elément[listeD, k]], k, 1, Longueur[listeD]].


Et maintenant, vous pouvez obtenir la liste ordonnée des noms par la commande :

listeA=Séquence[Elément[listeD, y(Elément[liste_a, k])], k, 1, Longueur[listeD]]


Ainsi l'exemple mis en ligne ci-dessus utilise les listes :

listeD = {"w", "w_1", "w_2", "w_3", "z", "z_1", "z_2", "z_3"}
liste=Séquence[Objet[Elément[listeD, k]], k, 1, Longueur[listeD]]
liste_a=Trier[Séquence[(arg(Elément[liste, i]) + Si[arg(Elément[liste, i]) < 0, 6.28319, 0], i), i, 1, Longueur[liste]]]
liste_t=Séquence[Elément[liste, y(Elément[liste_a, i])], i, 1, Longueur[liste]]
listeA=Séquence[Elément[listeD, y(Elément[liste_a, k])], k, 1, Longueur[listeD]]
© 2024 International GeoGebra Institute