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

ee

jj

ff

kk

dd

gg

ll

pp

Output:
Goal: bfs( [ a ], g, X)
X= [ a, b, c, d, e, f, g ]
1 Solution

hh

m
m

ii

nn

oo

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

ee

jj

ff

kk

dd

gg

ll

pp

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

hh

m
m

ii

nn

oo