Comment puis-je obtenir la somme des chiffres donnés dans le prologue?

Arithmétique

Comme vous l'avez déjà découvert, l'arithmétique peut être traité dans le Prologue avec le (is)/2 de l'opérateur. C'est parce que dans le Prologue, tout est symbolique de calcul: les choses n'ont pas une signification par défaut, de sorte que l'unification (=)/2 ne sais pas qui (+)/2 se réfère à l'ajout par exemple.

Maintenant, votre problème est que vous utilisez régulièrement un prédicat à l'intérieur de (is)/2 (ici, c'est votre appel récursif). Depuis (is)/2 n'effectue de l'arithmétique, il se complique pas d'évaluer le prédicat d'appel. Il n'a même pas le reconnaître, car il n'est pas une fonction arithmétique.

Le correctif ici serait d'affecter le résultat de l'appel récursif à une variable et ensuite l'utiliser dans le (is)/2 appel:

listsum(X,[]).
listsum(Result, [Head|Tail]) :-
    listsum(SumOfTail, Tail),
    Result is Head + SumOfTail.

De la Base de cas de l'exactitude

Mais si vous testez ce code, vous n'obtiendrez pas le résultat souhaité. La raison en est que vous avez un autre problème, dans votre base de cas. La somme de la liste vide n'est pas "rien", comme vous l'avez indiqué par écrit

listsum(X,[]).

(X est une variable libre, donc peut être n'importe quoi).

Au lieu de cela, il est 0:

listsum(0, []).

Le code résultant est:

listsum(0, []).
listsum(Result, [Head|Tail]) :-
    listsum(SumOfTail, Tail),
    Result is Head + SumOfTail.

Ordre des arguments

Maintenant, au passage, dans le Prologue de la convention est que les variables de sortie doit être placée à la fin du prédicat, tandis que les variables d'entrée doit être mis au début du prédicat, de manière à se comporter comme des voulu nous pourrions refactoriser comme suit:

listsum([], 0).
listsum([Head|Tail], Result) :-
    listsum(Tail, SumOfTail),
    Result is Head + SumOfTail.

Queue Appeler L'Optimisation

Maintenant, nous pouvons encore améliorer ce prédicat avec des techniques plus avancées. On pourrait par exemple introduire la queue appels afin que la Queue d'Appel d'Optimisation (googlable) a pu être effectué grâce à un langage de programmation déclarative appelé un accumulateur:

listsum(List, Sum) :-
    listsum(List, 0, Sum).

listsum([], Accumulator, Accumulator).

listsum([Head|Tail], Accumulator, Result) :-
    NewAccumulator is Accumulator + Head,
    listsum(Tail, NewAccumulator, Result).

L'idée derrière tout ça est de mettre à jour un résultat intermédiaire à chaque étape de la récursion (en ajoutant la valeur de l'actuel chef de la liste), puis juste dire que lorsque la liste est vide, cette valeur intermédiaire est la valeur finale.

Obtenir plus générale des programmes

Comme vous l'avez peut-être noté dans le Prologue, très souvent, les prédicats peuvent être utilisés de plusieurs façons. Par exemple, length/2 peuvent être utilisés pour découvrir la longueur d'une liste:

?- length([1, 2, 3], Length).
Length = 3.

ou de construire un squelette liste avec les variables libres d'une longueur souhaitée:

?- length(List, 3).
List = [_G519, _G522, _G525].

Ici, vous pourriez avoir de noter que vous ne pouvez pas demander à Prologue de ce que sont les listes qui ont une somme qui est 6:

?- listsum(L, 6).
ERROR: is/2: Arguments are not sufficiently instantiated

C'est parce que, à "revenir en arrière", Prologue aurait à résoudre une équation quand vient l'appel à la (is)/2 de l'opérateur. Et tandis que le vôtre est simple (uniquement des ajouts), l'arithmétique n'est pas résoluble de cette façon, dans le cas général.

Pour surmonter ce problème, programmation par contraintes peut être utilisé. Une très belle bibliothèque est disponible pour SWI, clpfd.

La syntaxe serait ici:

:- use_module(library(clpfd)).

listsum(List, Sum) :-
    listsum(List, 0, Sum).

listsum([], Accumulator, Accumulator).

listsum([Head|Tail], Accumulator, Result) :-
    NewAccumulator #= Accumulator + Head,
    listsum(Tail, NewAccumulator, Result).

Maintenant, nous pouvons utiliser notre prédicat de cette façon, nous avons souhaité que nous puissions l'utiliser:

?- listsum(L, 6).
L = [6] ;
L = [_G1598, _G1601],
_G1598+_G1601#=6 ;
L = [_G1712, _G1715, _G1718],
_G1712+_G1715#=_G1728,
_G1728+_G1718#=6 . % Here I interrupted the answer but it would not terminate.

On pourrait même se demander pour toutes les solutions au problème:

?- listsum(L, X).
L = [],
X = 0 ;
L = [X],
X in inf..sup ;
L = [_G2649, _G2652],
_G2649+_G2652#=X . % Here I interrupted the answer but it would not terminate

J'ai juste mentionné que de sorte que vous vous rendez compte que, bien souvent, l'utilisation de (is)/2 doit être évitée et l'utilisation de la programmation par contraintes doivent être privilégiées pour obtenir la plupart des programmes généraux.

OriginalL'auteur m09