Discussion :

[Miss1987]

Bonjour,

Actuellement en école d'ingénieur, je dois rendre un projet dans une semaine, mais j'ai un problème avec une fonction.

Je voudrai faire la fonction combine qui prend en argument 2 listes et retourne une liste de couples av : le 1er élément de la 1ère liste en couple av le 1er élément de la 2e liste etc.
Le pb est que si la 2e liste est plus petite que la 2e, je voudrais que ça reprenne du début.
C'est à dire si la 2e liste a 3 éléments et la 1ère liste 4, je voudrai que le dernier élément de la 1ère liste soit de nouveau avec le premier de la 2e.

Pour l'insant, j'ai ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
let rec combine (p,c) = match (p,c) with
([],[]) -> []
  |_,[] -> []
  |[],_ -> []
  | (e1::r1), (e::r) -> (e1,e)::combine (r1,r);;

merci bcp

[gasche]

C'est un peu plus délicat.

J'ai essayé de faire une version pour voir, voici ce que ça donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
let combine liste_a liste_b =
  let rec comb (p, c) (fin_a, fin_b) = match (p, c) with
  | ([], _) when fin_b -> []
  | (_, []) when fin_a -> []
  | (reste_a, []) -> comb (reste_a, liste_b) (fin_a, true)
  | ([], reste_b) -> comb (liste_a, reste_b) (true, fin_b)
  | (hd1::tl1), (hd2::tl2) -> (hd1, hd2) :: comb (tl1, tl2) (fin_a, fin_b)
  in comb (liste_a, liste_b) (false, false)

Pourquoi y a-t-il autant d'arguments supplémentaires ? Déjà, pour pouvoir "redonner" la liste au milieu de la fonction (si on arrive à la fin) il faut garder le contenu des deux listes de base. J'ai donc fait deux fonctions imbriquées : seule la fonction interne est récursive, et quelle que soit la valeur de ses arguments p et c tu peux retrouver la valeur des deux listes données initialement en argument, liste_a et liste_b.

Ensuite, on boucle sur les listes, mais comment savoir quand on s'arrête ?
La méthode que j'utilise est un couple de booléens, qui indique pour chaque liste si on est déjà arrivé à la fin : par exemple fin_a est vrai si la liste de gauche (liste_a) a déjà été parcourue en entier. Ainsi, quand une des deux listes est vide, il suffit de regarder si l'autre a déjà été parcourue, et dans ce cas on peut s'arrêter. Sinon, il faut continuer en remplacant la liste vide par la valeur initiale de la liste correspondante.

Mon code me paraît un peu compliqué, il y a sûrement moyen de faire plus cout.

[gasche]

Aussitôt dit, aussitôt fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
let combine la lb =
  let ta, tb = Array.of_list la, Array.of_list lb in
  let na, nb = Array.length ta, Array.length tb in
  Array.to_list (Array.init (max na nb) (fun i -> ta.(i mod na), tb.(i mod nb)))

Bon, c'est une méthode assez déloyale

[GnuVince]

Miss: soit dit en passant, ta fonction telle qu'elle est actuellement est une implémentation de la fonction zip trouvée dans beaucoup de langages fonctionnels:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Prelude> zip [1, 2, 3, 4, 5] [5, 4, 3, 2, 1]
[(1,5),(2,4),(3,3),(4,2),(5,1)]
Prelude>

zip ne "recommence" pas une liste si elle est plus courte, il arrête là.

[Jedai]

En OCaml, zip s'appelle combine (et est dans le module List), donc le nom est cohérent.

--
Jedaï