Déterminer quelle liste d'entiers est la plus grande

Question

J'essaie de déterminer quelle liste d'entiers est la plus grande. La représentation de [1;2;3] est actuellement 123. Donc donné deux listes d'entiers, je veux comparer chaque élément pour déterminer quel nombre est plus grand à la fin. Renvoyant 1 si list1 > list2, -1 si list1 < list2 et 0 s'ils sont égaux. C'est ce que j'ai jusqu'ici, mais quand j'essaie de l'exécuter, j'ai des erreurs et je ne comprends pas pourquoi. On m'a également demandé de faire tous les récurrents dans la forme de récurrence de la queue chaque fois que possible. Est-ce la récursion correcte de la queue?

let rec compare' list1 list2 currentOrder = match (list1, list2) with 
    | [],[]      -> 0 
    | list1, []     -> 1 
    | [], list2     -> -1 
    | car1::cdr1, car2::cdr2 ->  (*car1 contains the current element and cdr1 contains the rest of the list. Ex car1 = [1], cdr2 = [2;3]*) 
    let nextCompare = 
     (
      if cdr1 = [] && cdr2 = [] 
      then 0 
      else 1 
     )       
    in 
    (
     if (nextCompare != 0)(*To check if we are not at the end of the list*) 
     then (  (*Compare the cars to determine the currentOrder and recursively call with the next number*) 
     if car1 > car2 
     then (compare' (cdr1 cdr2 1)) 
     else if car1 < car2 
     then (compare' (cdr1 cdr2 -1)) 
     else (compare' cdr1 cdr2 currentOrder) 
    ) 
     else (*we are at the end of the list so we want to return the current order*) 
     ( (*Still need to check in case there is only 1 digit number, because we did not update currentOrder for it to be returned*) 
     if car1 > car2 
     then 1 
     else if car1 < car2 
     then -1 
     else currentOrder 
    ) 
    ) 


Printf.printf (compare' [1;2;3] [3;2;1] 0) 

Answer 1

Le premier problème que vous aviez eu quelques parenthèses supplémentaires autour des arguments de quelques applications de fonction (par exemple (compare' (cdr1 cdr2 1))) qui indique OCaml que vous souhaitez appeler cdr1 avec les arguments cdr2 et 1, puis appliquer la résultat de cela à la compare'. Le compilateur se plaindra donc que vous essayez d'utiliser la liste cdr1 en tant que fonction. C'est une erreur simple à faire si vous avez l'habitude de faire une application avec des parenthèses.

Le deuxième problème est que vous avez eu -1 sans parenthèses, que le compilateur interprétera comme application 1 à l'opérateur - binaire, et donc se plaignent que le résultat de c'est une fonction et non un int, comme on pouvait s'y attendre . La raison de ce comportement étrange est que OCaml supporte l'application de fonction partielle, ce qui provoque certaines ambiguïtés. Désambiguquez-le, il vous suffit de l'entourer entre parenthèses: (-1). Et enfin, il y avait un peu de redondance dans votre code, donc je l'ai simplifié un peu pour vous. Moins de code signifie aussi moins d'endroits à vis, et de regarder à travers pour trouver screwups, qui est très pratique quand vous apprenez :)

let rec compare' list1 list2 currentOrder = 
    match list1, list2 with 
    | [], []      -> currentOrder 
    | _, []      -> 1 
    | [], _      -> -1 
    | car1::cdr1, car2::cdr2 -> 
    let order = 
     if car1 > car2 then 1 
     else if car1 < car2 then -1 
     else currentOrder 
    in 
    compare' cdr1 cdr2 order 

Je donne cependant aucune garantie que cela est logiquement correct, il est juste une transformation de ce que vous aviez écrit (en fait, je sais que ce n'est pas correct, mais c'est une mission pour une raison).