Tp2 prolog - intelligence artificielle ai - prolog - télécha

Intelligence Artificielle AI - Prolog : TP2 PROLOG

Télécharger PDF

Manipulation de Listes en Prolog

1. Prédicat pour vérifier si X est un élément de la liste L

Voici la définition du prédicat element(X, L) qui permet de vérifier si X appartient à la liste L :

element(X, [X|_]).
element(X, [_|T]) :- element(X, T).

2. Prédicat pour renverser une liste L

Voici la définition du prédicat renverser(L, R) qui inverse l'ordre des éléments de la liste L :

renverser([], []).
renverser([T|Q], R) :- renverser(Q, RQ), append(RQ, [T], R).

Le Problème du Zèbre

Ce problème classique consiste à attribuer des caractéristiques uniques à cinq maisons alignées. Voici les prédicats nécessaires pour le résoudre :

1. Prédicat meme_maison(X, L1, Y, L2)

Ce prédicat vérifie si X et Y occupent la même position dans les listes L1 et L2 :

meme_maison(X, [X|_], Y, [Y|_]).
meme_maison(X, [_|T1], Y, [_|T2]) :- meme_maison(X, T1, Y, T2).

2. Prédicat maison_a_cote(X, L1, Y, L2)

Ce prédicat vérifie si X et Y sont dans des positions voisines (adjacentes) dans les listes L1 et L2 :

maison_a_cote(X, [X|[Y|_]], Y, [_|_]).
maison_a_cote(X, [X|[_|T1]], Y, [_|T2]) :- meme_maison(X, T1, Y, T2).
maison_a_cote(X, [Y|[X|_]], Y, [_|_]).
maison_a_cote(X, [_|T1], Y, [_|T2]) :- meme_maison(X, T1, Y, T2).

3. Prédicat maison_a_droite(X, Y, L)

Ce prédicat vérifie si X est à droite de Y dans la liste L :

maison_a_droite(X, Y, L) :- index(Y, L, I), index(X, L, J), J is I + 1.

index(X, [X|_], 1).
index(X, [_|T], I) :- index(X, T, J), I is J + 1.

4. Prédicat zebre(C, N, B, A, P, PossZebre, BoitVin)

Ce prédicat résout le problème du Zèbre en déterminant le propriétaire du Zèbre et le buveur de vin.

zebre(C, N, B, A, P, PossZebre, BoitVin) :-
    longueur(C, 5), longueur(N, 5), longueur(B, 5), longueur(A, 5), longueur(P, 5),
    permutation(C, [rouge, bleu, jaune, blanc, vert]),
    permutation(N, [anglaise, espagnole, japonaise, norvégienne, italienne]),
    permutation(B, [thé, jus_de_fruits, café, lait, vin]),
    permutation(A, [chien, escargots, renard, cheval, zèbre]),
    permutation(P, [peintre, sculpteur, diplomate, docteur, violoniste]),

    meme_maison(rouge, C, anglaise, N),
    meme_maison(espagnole, N, chien, A),
    meme_maison(japonaise, N, peintre, P),
    meme_maison(italienne, N, thé, B),

    maison_a_droite(blanche, verte, C),

    meme_maison(verte, C, café, B),

    maison_a_cote(bleue, C, norvégienne, N),

    meme_maison(escargots, A, sculpteur, P),

    meme_maison(jaune, C, diplomate, N),

    meme_maison(milieu, [1,2,3,4,5], blanche, C),

    meme_maison(renard, A, voisin, [X|_]):-
        meme_maison(X, [1,2,3,4,5], docteur, P),
        maison_a_cote(X, [1,2,3,3,4,5], renard, A),

    meme_maison(cheval, A, voisin, [X|_]):-
        meme_maison(X, [1,2,3,4,5], diplomate, N),
        maison_a_cote(X, [1,2,3,4,5], cheval, A),

    meme_maison(jus_de_fruits, B, violoniste, P),

    meme_maison(zèbre, A, PossZebre, N),
    meme_maison(vin, B, BoitVin, N).

Le Métro Lyonnais

Représentation des lignes et stations

Voici une représentation simplifiée des lignes et des stations du métro lyonnais sous forme de listes :

ligneA([perrache, ampere, bellecour, cordeliers, hotel_de_ville, foch, massena, charpennes, republique, gratte_ciel, flachet, cusset, laurent_bonnevay]).
ligneB([charpennes, brotteaux, part_dieu, place_guichard, saxe_gambetta, jean_mace, place_jean_jaures, debourg, stade_de_gerland]).
ligneC([hotel_de_ville, croix_paquet, croix_rousse, henon, cuire]).
ligneD([gare_de_vaise, valmy, gorge_de_loup, vieux_lyon, bellecour, guillotiere, saxe_gambetta, garibaldi, sans_souci, monplaisir_lumiere, grange_blanche, laennec, mermoz_pinel, parilly, gare_de_venissieux]).

Prédicat pour trouver un chemin entre deux stations

Voici une approche pour déterminer un chemin entre deux stations, en précisant les lignes empruntées et les changements :

chemin(Depart, Arrivee, Chemin) :-
    trouver_chemin(Depart, Arrivee, [Depart], Chemin).

trouver_chemin(Depart, Arrivee, Visite, [Depart|Arrivee]) :-
    meme_ligne(Depart, Arrivee),
    pas_deja_visite(Depart, Visite),
    pas_deja_visite(Arrivee, Visite).

trouver_chemin(Depart, Arrivee, Visite, Chemin) :-
    meme_ligne(Depart, Station, Ligne),
    pas_deja_visite(Station, Visite),
    trouver_chemin(Station, Arrivee, [Station|Visite], Chemin).

meme_ligne(Station1, Station2, Ligne) :-
    (ligneA(L) -> membre(Station1, L); ligneB(L) -> membre(Station1, L); ligneC(L) -> membre(Station1, L); ligneD(L) -> membre(Station1, L)),
    membre(Station2, L).

membre(X, [X|_]).
membre(X, [_|T]) :- membre(X, T).

pas_deja_visite(X, []) :- fail.
pas_deja_visite(X, [X|_]).
pas_deja_visite(X, [_|T]) :- pas_deja_visite(X, T).

FAQ

Comment définir une liste en Prolog ?

Une liste en Prolog est définie entre crochets avec des éléments séparés par des virgules. Par exemple : [rouge, bleu, jaune].

Qu'est-ce qu'une permutation en Prolog ?

La permutation en Prolog est une fonction qui génère toutes les combinaisons possibles d'une liste. Par exemple, permutation([1,2], L) génère L = [1,2] et L = [2,1].

Comment vérifier si deux éléments sont adjacents dans une liste ?

Utilisez le prédicat maison_a_cote/4 qui vérifie si deux éléments sont dans des positions adjacentes dans deux listes données.

Cela peut vous intéresser :

Partagez vos remarques, questions , propositions d'amélioration ou d'autres cours à ajouter dans notre site

Enregistrer un commentaire (0)
Plus récente Plus ancienne