Mettre en œuvre le membre du prédicat comme un one-liner

Question d'entrevue!

C'est que vous aviez l'habitude de définir la member relation dans le Prologue:

member(X, [X|_]).        % member(X, [Head|Tail]) is true if X = Head 
                         % that is, if X is the head of the list
member(X, [_|Tail]) :-   % or if X is a member of Tail,
  member(X, Tail).       % ie. if member(X, Tail) is true.

Définir à l'aide d'une seule règle.

Entrevue pour un emploi? ce travail? où? les gens à trouver des emplois grâce à Prolog?
jane st capital

InformationsquelleAutor Claudiu | 2009-11-16

36
1. Solution:
```
member(X, [Y|T]) :- X = Y; member(X, T).
```
2. Démonstration:
```
?- member(a, []).
fail.
?- member(a, [a]).
true ;
fail.
?- member(a, [b]).
fail.
?- member(a, [1, 2, 3, a, 5, 6, a]).
true ;
true ;
fail.
```
3. Comment cela fonctionne:
  - Nous sommes à la recherche pour une occurrence du premier argument, X, dans le deuxième argument, [Y|T].
  - Le deuxième argument est supposé être une liste. Y correspond à sa tête, T correspond à la queue.
  - En conséquence, le prédicat échoue pour la liste vide (comme il se doit).
  - Si X = Y (c'est à dire X peut être unifiée avec Y), puis nous avons trouvé X dans la liste. Dans le cas contraire ( ; ), nous testons si X est dans la queue.
4. Remarques:
  - Grâce à humble café pour souligner que l'utilisation de = (unification) des rendements plus souple que le code à l'aide de == (essais de l'égalité).
  - Ce code peut également être utilisé pour énumérer les éléments d'une liste donnée:
    
    ?- member(X, [a, b]). X = a ; X = b ; fail.
  - Et il peut être utilisé pour "énumérer" toutes les listes qui contiennent un élément donné:
    
    ?- member(a, X). X = [a|_G246] ; X = [_G245, a|_G249] ; X = [_G245, _G248, a|_G252] ; ...
  - Remplacement = par == dans le code ci-dessus, il est beaucoup moins souple: il serait immédiatement échouer sur member(X, [a]) et de provoquer un débordement de pile sur member(a, X) (testé avec SWI-Prolog version 5.6.57).
- hmm très mignon. La clé a été l' ; opérateur - je ne savais pas qu'on pouvait faire " ou à l'intérieur d'une règle.
- Si vous remplacez "X == Y" avec "X = Y", alors vous pouvez faire membre(X, [a]). et même obtenir un bon résultat pour membre(a, X).
- café: merci! J'ai à peine touché Prologue de la dernière quelques années, donc mes connaissances sont un peu rouillé 🙂
- Qu'il soit utilisé pour énumérer les éléments / listes etc. est un impressionnant effet de bord de la voie prologue de marche =). pas de spécial à cet exemple - si vous définissez Plus, vous bénéficiez automatiquement de la Soustraction. Si vous définissez un TypeChecker, vous pouvez également définir un énumérateur pour tous bien tapé des programmes.
- le point de X == Y vs X = Y, c'est qu'avec le second, vous êtes forçant l'unification (mauvais que je peux dire), avec le second, vous faire une profonde contrôle d'égalité
InformationsquelleAutor Stephan202
20

Puisque vous ne spécifiez pas ce que les autres prédicats, nous sommes autorisés à utiliser, je vais essayer de tricher un peu. :P
```
member(X, L) :- append(_, [X|_], L).
```
InformationsquelleAutor bcat
7
```
newmember(X, Xs) :-
   phrase(( ..., [X] ),Xs, _).
```
Avec
```
... --> [] | [_], ... .
```
En fait, la définition suivante s'assure également que Xs une liste:
```
member_oflist(X, Xs) :-
   phrase(( ..., [X], ... ), Xs).
```
Remerciements

La première apparition de la définition ci-dessus de ... est sur p. 205, Note 1 de

David B. Searls, les enquêtes sur la Linguistique de l'ADN avec une Clause de Grammaires. NACLP 1989, Volume 1.

InformationsquelleAutor false

Vous devez vous connecter pour publier un commentaire.

Remerciements