Outils pour utilisateurs

Outils du site


playerone

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

playerone [2019/01/07 11:08] (Version actuelle)
195.221.62.1 créée
Ligne 1: Ligne 1:
 +# Exercices sur les listes de listes
  
 +## Prérequis
 +
 +Il faut avoir suivi [cette page](profgra:​peda:​listes:​listes_1) pour
 +lire celle-ci dans de bonnes conditions.
 +
 +## Liste de listes
 +
 +Une liste peut contenir n’importe quel type de valeur, même des listes !  ​
 +
 +Pour accéder à une valeur dans la liste, on utilise `Nieme`.
 +Pour accéder à un élément d’une sous-liste, on emboîte les appels à `Nième`.
 +
 +(MicroAlg "​src-lili-1"​)
 +(Declarer lili De_type "​liste"​)
 +(Affecter_a lili (Liste "​Salut"​ 42 Vrai (Liste "​A"​ "​B"​)))
 +(Afficher lili)
 +(Afficher (Nieme lili 4))
 +(Afficher (Nieme (Nieme lili 4) 2))
 +(/MicroAlg)
 +
 +Dans le programme suivant, changez les « 1 » en d’autres nombres entiers pour écrire « BONJOUR ».
 +
 +(MicroAlg "​src-lili-2"​)
 +(Declarer lili De_type "​liste"​)
 +(Affecter_a lili (Liste (Liste "​A"​ "​B"​) (Liste "​J"​ "​N"​) (Liste "​O"​ "​U"​ (Liste "​R"​))))
 +(Afficher (Nieme (Nieme lili 1) 1))
 +(Afficher (Nieme (Nieme lili 1) 1))
 +(Afficher (Nieme (Nieme lili 1) 1))
 +(Afficher (Nieme (Nieme lili 1) 1))
 +(Afficher (Nieme (Nieme lili 1) 1))
 +(Afficher (Nieme (Nieme lili 1) 1))
 +(Afficher (Nieme (Nieme lili 1) 1))
 +(/MicroAlg)
 +
 +## Parcours
 +
 +On considère ici une liste de listes appelée `lili`. Dans l’algorithme ci-dessous,
 +on la parcourt pour afficher chaque sous-liste.
 +
 +(MicroAlg "​parcours_1"​)
 +(Declarer lili De_type "​liste"​)
 +(Declarer i De_type "​nombre"​)
 +(Affecter_a lili (Liste (Liste "​A"​ "​B"​) (Liste "​C"​ "​D"​) (Liste "​E"​ "​F"​)))
 +(Afficher lili)
 +(Affecter_a i 1)
 +(Tant_que (<= i (Longueur lili)) Faire
 +    (Afficher (Nieme lili i))
 +    (Affecter_a i (+ i 1))
 +)
 +(/MicroAlg)
 +
 +Dans la fenêtre suivante, modifier l’algorithme de telle sorte qu’au lieu
 +d’afficher la sous-liste (qui a été affectée à la variable `ssl`),
 +un sous-parcours est effectué pour en afficher les éléments.
 +
 +(MicroAlg "​parcours_1_affectation"​)
 +(Declarer lili ssl De_type "​liste"​)
 +(Declarer i De_type "​nombre"​)
 +(Affecter_a lili (Liste (Liste "​A"​ "​B"​) (Liste "​C"​ "​D"​) (Liste "​E"​ "​F"​)))
 +(Afficher lili)
 +(Affecter_a i 1)
 +(Tant_que (<= i (Longueur lili)) Faire
 +    (Affecter_a ssl (Nieme lili i))
 +    (!!! "​Remplacer la ligne suivante par un parcours,"​)
 +    (!!! "et afficher chaque élément de ssl.")
 +    (Afficher ssl)
 +    (Affecter_a i (+ i 1))
 +)
 +(/MicroAlg)
 +
 +Vous devrez obtenir les lettres de A à F, dans l’ordre, et chacune sur sa ligne.
 +
 +**Indice** :​ Remplacer `(Afficher ssl)` par un `Tant_que`.
 +
 +Encore plus fort, on pourrait faire la même chose sans
 +la variable intermédiaire `ssl`. Essayez à partir de la
 +fenêtre ci-dessous.
 +
 +(MicroAlg "​parcours_2"​)
 +(Declarer lili De_type "​liste"​)
 +(Declarer i De_type "​nombre"​)
 +(Affecter_a lili (Liste (Liste "​A"​ "​B"​) (Liste "​C"​ "​D"​) (Liste "​E"​ "​F"​)))
 +(Affecter_a i 1)
 +(Tant_que (<= i (Longueur lili)) Faire
 +    (Afficher (Nieme lili i))
 +    (Affecter_a i (+ i 1))
 +)
 +(/MicroAlg)
 +
 +**Indice** : Remplacer `(Afficher (Nieme lili i))` par un
 +`Tant_que`. Vous devrez sans doute utiliser `Nieme` deux
 +fois, peut-être même les imbriquer.
 +
 +## Remarques
 +
 +Voici la solution du dernier exercice. Ce parcours de
 +liste de liste sera appelé le parcours « canonique ».
 +L’affichage de i et de j nous permet de voir que la
 +variable de la boucle intérieure « tourne plus vite »
 +que l’autre.
 +
 +(MicroAlg "​script_parcours_canonique"​)
 +(Declarer lili De_type "​liste"​)
 +(Declarer i j De_type "​nombre"​)
 +(Affecter_a lili (Liste (Liste "​A"​ "​B"​) (Liste "​C"​ "​D"​) (Liste "​E"​ "​F"​)))
 +(Affecter_a i 1)
 +(Tant_que (<= i (Longueur lili)) Faire
 +    (Affecter_a j 1)
 +    (Tant_que (<= j 2) Faire
 +        (Afficher (Nieme (Nieme lili i) j))
 +        (Afficher (Concatener "i vaut " (Texte i) " et j vaut " (Texte j)))
 +        (Affecter_a j (+ j 1))
 +    )
 +    (Affecter_a i (+ i 1))
 +)
 +(/MicroAlg)
 +
 +## Affichages
 +
 +Dans `lili`, on travaille maintenant avec des nombres pour faciliter la lecture.
 +
 +Avec `Definir`, écrire une commande qui affiche une
 +liste de liste sous forme de matrice, les sous-listes
 +étant considérées comme étant les lignes de la matrice,
 +puis idem pour les colonnes de la matrice. Vous les
 +appelerez `Afficher_comme_lignes` et `Afficher_comme_colonnes`.
 +
 +En clair, on veut que `(Afficher_comme_lignes lili)` donne :
 +
 +    1 2
 +    3 4
 +    5 6
 +
 +Et on veut que `(Afficher_comme_colonnes lili)` donne :
 +
 +    1 3 5
 +    2 4 6
 +
 +(MicroAlg "​script_affichage"​)
 +(Declarer lili De_type "​liste"​)
 +(Declarer i j De_type "​nombre"​)
 +(Affecter_a lili (Liste (Liste 1 2) (Liste 3 4) (Liste 5 6)))
 +(Definir (Afficher_comme_lignes ll)
 +    "​Affiche la matrice en considérant les sous-listes comme des lignes."​
 +    "?"​
 +    (!!! "​...votre code ici..."​)
 +    (Retourner Rien)
 +)
 +(Afficher_comme_lignes lili)
 +(Definir (Afficher_comme_colonnes ll)
 +    "​Affiche la matrice en considérant les sous-listes comme des colonnes."​
 +    "?"​
 +    (!!! "​...votre code ici..."​)
 +    (Retourner Rien)
 +)
 +(Afficher_comme_colonnes lili)
 +(/MicroAlg)
 +
 +## Création
 +
 +Toujours avec `Definir`, écrire une commande `Creer_matrice` prenant
 +deux entiers strictement positifs m et n en paramètre et
 +retournant une liste de longueur n contenant des listes
 +de longueur m pleines de zéros. Appelons cette procédure
 +`matrice_mxn`.
 +
 +(MicroAlg "​script-creation"​)
 +(Definir (Creer_matrice m n)
 +    "Crée une matrice de taille m×n."
 +    "?"​
 +    (!!! "​...votre code ici..."​)
 +    (Retourner Rien)
 +)
 +(Afficher_comme_lignes (Creer_matrice 2 3))
 +(/MicroAlg)
 +
 +## Autres parcours
 +
 +Écrire huit parcours qui vont remplir des matrices 3×2 avec les
 +nombres entiers de 1 à 6 de façons à obtenir :
 +
 +    1) 1 4   2) 4 1   3) 3 6   4) 6 3
 +       2 5      5 2      2 5      5 2
 +       3 6      6 3      1 4      4 1
 +    5) 1 2   6) 2 1   7) 5 6   8) 6 5
 +       3 4      4 3      3 4      4 3
 +       5 6      6 5      1 2      2 1
 +
 +Vous avez carte blanche pour la stratégie de parcours (il y en a au moins
 +trois), mais vous pouvez réutiliser `Creer_matrice` et `Afficher_comme_lignes`.
 +
 +(MicroAlg "​script-huit-parcours"​)
 +(Declarer lili De_type "​liste"​)
 +(Affecter_a matrice (Creer_matrice 2 3))
 +(!!! "​...votre code ici..."​)
 +(Afficher_comme_lignes matrice)
 +(!!! "​...votre code ici..."​)
 +(Afficher_comme_lignes matrice)
 +(!!! "​...votre code ici..."​)
 +(Afficher_comme_lignes matrice)
 +(!!! "​...votre code ici..."​)
 +(Afficher_comme_lignes matrice)
 +(!!! "​...votre code ici..."​)
 +(Afficher_comme_lignes matrice)
 +(!!! "​...votre code ici..."​)
 +(Afficher_comme_lignes matrice)
 +(!!! "​...votre code ici..."​)
 +(Afficher_comme_lignes matrice)
 +(!!! "​...votre code ici..."​)
 +(Afficher_comme_lignes matrice)
 +(/MicroAlg)
 +
 +## Approfondissement
 +
 +* création de la matrice nulle d’une taille donnée
 +* affichage de matrice
 +* saisie de matrice
 +* opérations
 +    * addition de matrices (vérification même taille)
 +    * multiplication par un scalaire
 +    * soustraction
 +    * produit
 +* transposition
 +* construire
 +    * des matrices unité
 +    * des matrices avec des 1 strictement au dessus de la diag principale
 +* trouver l'​élément maximal ou la  colonne de somme maximale
playerone.txt · Dernière modification: 2019/01/07 11:08 par 195.221.62.1