compter le nombre d'un élément particulier dans un prologue de la liste

Je suis en train de compter le nombre de fois qu'un élément apparaît dans une liste, pour l'instant j'ai venu avec

rate(X,[H|T],N):-
  X == H,
  N is N+1,
  rate(X,T,N).
rate(X,[_|T],N) :-
  rate(X,T,N).  
rate(_,[],N) :-
  N is 0.

J'ai couvert quand une correspondance est trouvée, quand il n'y a pas un match et quand il atteint la fin de la liste. Mais quand je l'ai tester je obtenir

43 ?- rate(4,[4,2,3,4,4,2],X).
ERROR: is/2: Arguments are not sufficiently instantiated
Exception: (6) frequency(4, [4, 2, 3, 4, 4, 2], _G393) ?

Quels sont les arguments qui me manque exactement?

OriginalL'auteur rex | 2012-08-12

4

Vous pouvez utiliser is/2 (comme dans N is X) si et seulement si X est un nombre. Vous ne pouvez pas utiliser is/2 si X est une variable libre. Dans votre première clause vous avez: N is N+1. Ce qui est mauvais, puisque N est une variable libre (il n'a pas une valeur à ce point, et c'est donc pour N+1).

Il y a une autre erreur. Dans:
```
rate(X,[_|T],N) :-
  rate(X,T,N).
```
puisque vous ne l'utilisez que lorsque X n'est pas le premier élément dans la liste, vous devriez vérifier pour que cela soit vrai! Voici le code:
```
count(_, [], 0) :- !. /* empty list, base case */

count(X, [X|T], N) :- /* if X is in the head of the list */
    count(X, T, N2), /* count on the tail (let this N2) */
    N is N2 + 1.     /* and N is N2 + 1  */

count(X, [Y|T], N) :- 
    X \= Y,          /* if X is not in the head */
    count(X, T, N).  /* just count the rest */
```
Je comprends maintenant, merci beaucoup pour l'explication sur la manipulation de variables libres!
Vous n'avez pas besoin de l'étape X \= Y. Il suffit de mettre un cut dans le précédent prédicat, ce qui est quand ils de l'égalité.

OriginalL'auteur Haile
2

Vous avez besoin pour faire de votre clauses mutuellement exclusifs, la deuxième clause de réussir là où la première.

De votre erreur, il est à propos de la circulation de l'information. Vous avez besoin d'échanger les lignes de votre premier alinéa comme suit:
```
rate(X,[H|T],N):-
  X == H,
  rate(X,T,N1),
  N is N1+1.
```
Ce changement va rendre votre prédicat à pas queue récursive. À la queue récursive, il doit transmettre les informations bas l'appel de la chaîne, de ne pas la recevoir en retour sur la manière comme il le fait maintenant:
```
rate(X,[H|T],N):-
  X == H,
  N1 is N+1,
  rate(X,T,N1).
```
Maintenant, vous voyez que vous ne recevez pas la valeur finale ici, mais spécifier de la valeur initiale. Lorsque nous atteignons le cas de base, nous avons notre résultat:
```
rate(X, [], N).
```
ici N est le résultat. Comment le récupérer? Utiliser d'autres arguments, un uninstantiated variable, d'être unifié avec ce résultat, lorsque nous avons atteint le fond:
```
rate(X, [], N, V) :- V is N.
```
Maintenant la clause récursive doit tenir compte de cette variable, en passant le long inchangé en bas de la chaîne d'appel.

Merci pour la réponse!
vous avez le pouvoir de upvote maintenant, dans le cas où vous ne le savais pas. Toute réponse que vous pensez est bon, vous pouvez upvote. 🙂
Ok merci, de nouveau à ce genre de chose.
btw N is N+1 est pas mauvais, mais pas parce que N est une "variable indépendante" (plus connu sous le nom de uninstantiated variable). Je veux dire, même si N ont été instancié tout d'abord, N is N+1 serait toujours mauvais.

OriginalL'auteur Will Ness

Si vous aimez le style fonctionnel, vous pouvez écrire qu'avec SWI Prolog :

:- use_module(library(lambda)).


rate(X,L,N) :-
    foldl(\Y^V0^V1^((X = Y->V1 is V0+1; V1 = V0)), L, 0, N).

OriginalL'auteur joel76

Vous devez vous connecter pour publier un commentaire.