Program #1

// Program to count the total members in a given List.

domains
list=integer*

predicates
count(list,integer)

clauses
count([],0).
count([H|T],N):- N=X+1,count(T,X).

Output:

Goal: count([ 5, 2, 7, 3, 4 ], X)
X=5
1 Solution
 Program #2

// Program to append the contents of one List to another.

domains
L=integer*

predicates
append(L,L,L)

clauses
append([],L,L).
append(L,[],L).
append([],[],[]).
append([H|T],L,[H|NT]):-append(T,L,NT).

Output:

Goal: append([ 5, 2, 7, 3, 4 ], [ 8,9 ], X)

X = [ 5, 2, 7, 3, 4, 8, 9 ]
1 Solution
 Program #3

// Program to find Last member in a given list.

domains
list=integer*

predicates
last(list,integer)

clauses
last([X],X).
last([H|T],X):-last(T,X).

Output:

Goal: last([ 5, 2, 7, 3, 4 ], X)
X=4
1 Solution
 Program #4

// Program to find if an element is present or not in a given list.

domains
list=integer*

predicates
member(integer,list)

clauses
member(X,[X|_]).
member(X,[_|T]):-member(X,T),!.

Output:

Goal: member( 5, [ 5, 2, 7, 3, 4 ] )
Yes

Goal: member( 9, [ 5, 2, 7, 3, 4 ] )
No
 Program #5

// Program to delete an element from a given list.

domains
L=integer*

Predicates
delete(integer,L,L)

clauses
delete(X,[],[]).
delete(X,[H|T],T):-X=H.
delete(X,[H|T],[H|NT]):-X<>H, delete(X,T,NT).

Output:

Goal: delete( 5, [ 5, 2, 7, 3, 4 ], X )
X= [ 2, 7, 3, 4 ]
1 Solution
 Program #6

// Program to find sum of all elements in a given list.

domains
list=integer*

predicates
sum(list,integer)

clauses
sum([],0).
sum([H|T],N):- sum(T,X),N=X+H.

Output:

Goal: sum( [ 5, 2, 7, 3, 4 ], X )
X= 21
1 Solution
 Program #7

// Program to compare two given lists.

domains
L=integer*

predicates
compare(L,L,string)

clauses
compare([],[],"Equal"):-!.
compare([],L,"Less"):-!.
compare(L,[],"Greater"):-!.
compare([H1|T1],[H2|T2],X):-H1=H2,compare(T1,T2,X).
compare([H1|T1],[H2|T2],"Different"):-H1<>H2.

Output:

Goal: compare( [ 5, 2, 7, 3, 4 ], [ 5, 2, 7, 3, 4], X )

X= Equal
1 Solution

Goal: compare( [ 5, 2, 7, 3, 4 ], [ 5, 2, 7, 3], X )

X= Greater
1 Solution

Goal: compare( [ 5, 2, 7, 3 ], [ 5, 2, 7, 3, 4], X )

X= Less
1 Solution

Goal: compare( [ 6, 2, 7, 3, 4 ], [ 5, 2, 7, 3, 4], X )

X= Different
1 Solution
 Program #8

// Program to replace every occurrence of a given element in the list by

// another element.

domains
list = integer*

predicates
replace(integer,integer,list,list)

clauses
replace(_,_,[],[]).
replace(X,Y,[X|T1],[Y|T2]):-replace(X,Y,T1,T2).
replace(X,Y,[Z|T1],[Z|T2]):-X<>Z, replace(X,Y,T1,T2).

Output:

Goal: replace( 5, 2, [ 6, 5, 7, 3, 5 ], X )
X= [ 6, 2, 7, 3, 2]
1 Solution
 Program #9

// Program to reverse the order of elements of a given list.

domains
L=integer*

predicates
reverse(L,L)

clauses
reverse([],[]).
reverse([X],[X]).
reverse([H|T],[RT|H]):-reverse(T,RT).

Output:

Goal: reverse( [ 6, 5, 7, 3, 5 ], X )
X= [ 5, 3, 7, 5, 6]
1 Solution
 Program #10

// Program to partition a given list according to a given number where one

// contains elements less then or equal to the number and the other list
// contains elements greater then the number.

domains
list=integer*

predicates
partition(integer,list,list,list)

clauses
partition(X,[],[],[]).
partition(X,[H|T],[H|LT],GT):-H<=X, partition(X,T,LT,GT).
partition(X,[H|T],LT,[H|GT]):-H>X, partition(X,T,LT,GT).

Output:

Goal: ( 5,[ 6, 5, 7, 3, 5 ], X,Y )

X= [ 3,5,5]
Y= [ 6, 7 ]
1 Solution
 Program #11

// Program to sort the list in descending order using Selection Sort.

domains
list=integer*

predicates
greatest(list,integer)
selsort(list,list)
append(list,list,list)
delete(integer,list,list)

clauses
greatest([X],X).
greatest([H|T1],X):-greatest(T1,X), X > H.
greatest([H|T1],H):-greatest(T1,X), X <= H.

delete(_,[],[]).
delete(X,[X|T1],T1).
delete(X,[H|T1],[H|T2]):-H <> X, delete(X,T1,T2).

append([],[],[]).
append([],L,L).
append(L,[],L).
append([H|T1],L,[H|T2]):-append(T1,L,T2).

selsort([],[]).
selsort([X],[X]).
selsort(L,SL):-greatest(L,X), delete(X,L,L1), selsort(L1,NSL),
append([X],NSL,SL),!.

Output:

Goal: ( [ 6, 5, 7, 3, 4, 1 ], X )
X= [ 7, 6, 5, 4, 3, 1]
1 Solution
 Program #12

// Program to sort the list using Quick Sort.

domains
list=integer*

predicates
partition(integer,list,list,list)
qsort(list,list)
append(list,list,list)

clauses
partition(X,[],[],[]).
partition(X,[H|T],[H|LT],GT):-H<=X, partition(X,T,LT,GT).
partition(X,[H|T],LT,[H|GT]):-H>X, partition(X,T,LT,GT).

append([],L,L).
append(L,[],L).
append([],[],[]).
append([H|T],L,[H|NT]):-append(T,L,NT).

qsort([],[]).
qsort([H|Tail],L):-partition(Tail,H,LEH,GH), qsort(LEH,L1), qsort(GH,L2),
append(L1,[H|L2],L),!.

Output:

Goal: ( [ 6, 5, 7, 3, 4, 1 ], X )
X= [ 1, 3, 4, 5, 6, 7]
1 Solution
 Program #13

// Program to implement the Family Tree.

domains
person=symbol

predicates
husband(person,person)
wife(person,person)
father(person,person)
mother(person,person)
parent(person,person)
son(person,person)
daughter(person,person)
female(person)
male(person)
grandfather(person,person)
grandmother(person,person)
brother(person,person)
sister(person,person)
chacha(person,person)
chachi(person,person)
mama(person,person)
mami(person,person)

clauses
husband("Rajkapoor","Krishna").
husband("Shammi","Geeta").
husband("Shashi","Jenifer").
husband("Randhir","Babita").
husband("Rishi","Neetu").
husband("Sanjay","Karishma").
husband("Rajan","Ritu").
wife(X,Y):-husband(Y,X).

father("Prithviraj","Rajkapoor").
father("Prithviraj","Shammi").
father("Prithviraj","Shashi").
father("Rajkapoor","Ritu").
father("Rajkapoor","Randhir").
father("Rajkapoor","Rishi").
father("Rajkapoor","Rajiv").
father("Shashi","Kunal").
father("Shashi","Sanjna").
father("Randhir","Karishma").
father("Randhir","Kareena").
father("Rishi","Ranvir").
father("Rishi","Ridhima").
father("Rajan","Nikhil").

male("Rajiv").
male("Kunal").
male("Ranvir").
male("Prithviraj").
male(X):-husband(X,_).

female("Kareena").
female("Ridhima").
female("Ritu").
female("Sanjna").
female(X):-wife(X,_),!.

mother(X,Y):-wife(X,Z), father(Z,Y).
parent(X,Y):-mother(X,Y) ; father(X,Y).

son(X,Y):-male(X), father(Y,X).
daughter(X,Y):-female(X), father(Y,X).

grandfather(X,Y):-father(X,Z), father(Z,Y).
grandmother(X,Y):-wife(X,Z), grandfather(Z,Y).

brother(X,Y):-male(X), father(Z,X), father(Z,Y), X<>Y.

sister(X,Y):-female(X), father(Z,X), father(Z,Y), X<>Y.

chacha(X,Y):-brother(X,Z), father(Z,Y).
chachi(X,Y):-wife(X,Z), chacha(Z,Y).

mama(X,Y):-brother(X,Z), mother(Z,Y).
mami(X,Y):-wife(X,Z), mama(Z,Y).
Output:

Goal: female(X)
X= Kareena
X= Ridhima
X= Ritu
X= Sanjna
X= Krishna
X= Geeta
X= Jenifer
X= Babita
X= Neetu
X= Kareena
X= Karishma
10 Solutions

Goal: son( X, “Prithviraj”)

X= Rajkapoor
X= Shammi
X= Shashi
3 Solutions
 Program #14

// Program to implement the Route Map as Graph.

domains
city=symbol
distance=integer
path=city*

predicates
road(city,city,distance)
route(city,city,distance,path)
append(path,path,path)

clauses
append([],L,L).
append(L,[],L).
append([H|T],L,[H|NT]):-append(T,L,NT).

road("Fbd","Palwal",30).
road("Palwal","Hodal",30).
road("Delhi","Fbd",35).
road("Grg","Fbd",45).
road("Delhi","Grg",40).

route(C1,C2,D,[C2]):-road(C1,C2,D).
route(C1,C2,D,L):-route(C1,X,D1,L1), route(X,C2,D2,L2),
D=D1+D2, append(L1,L2,L).

Output:

Goal: route(“Fbd”, ”Hodal”, X, Y)

X= 60
Y= [ “Palwal”, ”Hodal” ]
 Program #15

// Program to implement the Breath First Search.

domains
list=symbol*

predicates
bfs(list,symbol,list)
children(symbol,list)
append(list,list,list)

clauses
children(a,[b,c,d]).
children(b,[e,f]).
children(c,[g]).
children(d,[h,i]).
children(e,[j,k]).
children(f,[]).
children(g,[l,m]).
children(h,[]).
children(i,[n,o]).
children(j,[]).
children(k,[]).
children(l,[p]).
children(m,[]).
children(n,[]).
children(o,[]).

append([],[],[]).
append([],L,L).
append(L,[],L).
append([H|T1],L,[H|T2]):-append(T1,L,T2).

bfs([],_,[]).
bfs([H|_],H,[H]).
bfs([H|Tail],Y,Path):-H<>Y, children(H,L1), append(Tail,L1,Ntail),
bfs(NTail,Y,Npath), append([H],Npath,Path),!.
 Tree Used for BFS Programs

aa

bb cc dd

ee ff gg hh ii

jj kk ll m
m nn oo

pp

Output:

Goal: bfs( [ a ], g, X)
X= [ “a”, “b”, “c”, “d”, “e”, “f”, “g” ]
1 Solution
 Program #16

// Program to implement the Depth First Search.

domains
list=symbol*

predicates
dfs(list,symbol,list)
children(symbol,list)
append(list,list,list)

clauses
children(a,[b,c,d]).
children(b,[e,f]).
children(c,[g]).
children(d,[h,i]).
children(e,[j,k]).
children(f,[]).
children(g,[l,m]).
children(h,[]).
children(i,[n,o]).
children(j,[]).
children(k,[]).
children(l,[p]).
children(m,[]).
children(n,[]).
children(o,[]).

append([],[],[]).
append([],L,L).
append(L,[],L).
append([H|T1],L,[H|T2]):-append(T1,L,T2).

dfs([],_,[]).
dfs([H|_],H,[H]).
dfs([H|Tail],Y,Path):-H<>Y,children(H,L1),append(L1,Tail,Ntail),
dfs(NTail,Y,Npath),append([H],Npath,Path),!.
 Tree Used for DFS Programs

aa

bb cc dd

ee ff gg hh ii

jj kk ll m
m nn oo

pp

Output:

Goal: dfs( [ a ], g, X)
X= [ “a”, “b”, “e”, “j”, “k”, “f”, “c”, “g” ]
1 Solution