Nouveauté de Prolog. Je veux un programme qui échange 1 à 0 et 0 à 1 et répond à cette question:Prolog, prédicat qui permute 1 à 0 et 0 à 1 et les place dans une liste
?- swap([1,1,0,1,0,0,0,1], L2).
L2 = [0,0,1,0,1,1,1,0]
complement(0, 1).
complement(1, 0).
swap(X, Y) :- maplist(complement, X, Y).
Merci pour la réponse mais j'essaye de le faire récursivement et sans maplist/3. Y a-t-il un autre moyen? – Mitsos
@Mitsos oui, il y a deux autres façons de le faire de manière récursive. Vous pouvez regarder [99 Prolog Problems] (http://www.ic.unicamp.br/~meidanis/courses/mc336/2009s2/prolog/problemas/) et vous concentrer sur les exemples de traitement de liste pour avoir une idée de comment début. À ce stade, il est difficile de dire combien Prolog vous connaissez, et ce n'est pas un site de tutoriel pour le démarrage de Prolog. C'est plus pour poser des questions de codage spécifiques. – lurker
Une solution CLPFD qui fonctionne correctement dans toutes les directions, pour référence:
:- use_module(library(clpfd)).
swap(X, Y) :-
maplist(#\=, X, Y),
X ins 0..1,
Y ins 0..1.
Plus précisément :
?- swap(X,Y).
X = Y, Y = [] ;
X = [_2640],
Y = [_2658],
_2640 in 0..1,
_2640#\=_2658,
_2658 in 0..1 ;
X = [_3200, _3206],
Y = [_3224, _3230],
_3200 in 0..1,
_3200#\=_3224,
_3224 in 0..1,
_3206 in 0..1,
_3206#\=_3230,
_3230 in 0..1 ;
…
fonctionne correctement, lorsque swap/2 de l'autre réponse non:
?- swap2(X,Y).
X = Y, Y = [] ;
X = [0],
Y = [1] ;
X = [0, 0], % Doesn't enumerate ([1],[0]), etc.
Y = [1, 1] ;
X = [0, 0, 0],
Y = [1, 1, 1] ;
…
Essayez 'longueur (X, _), échangez (X, Y) .' avec le' swap' de mon anwer pour une énumération juste. – danlei
@danlei Cela produira des boucles infinies sur bactracking pour, par exemple, 'longueur (X, _), swap2 (X, [1,0]).' – Fatalize
Eh bien, je voulais dire pour la génération en utilisant la requête la plus générale, mais oui - assez juste. – danlei
Avez-vous essayé de tout montrer et de poser une question précise? – lurker
Je vais donner quelques indices. Pensez-y en termes de règles. Le cas de base consiste à permuter une liste vide, 'swap ([], []).' (Une liste vide permutée est également une liste vide.). Puis un cas récursif. Par exemple, 'swap ([1 | X], ...): - ...' A quoi ressemble '...' 'si le premier argument est' [1 | X] '(une liste avec 1 au la tête et la queue de la liste est 'X')? – lurker