Computer Engineering Made Easy

Friday, 18 October 2013

Semester 7 : Digital Signal and Image Processing (DSIP) MATLAB codes

The MATLAB codes are available in the 'dsip.zip' file.
Download this file from the download box given in the blog.

It contains MATLAB codes for :-
1.IGS
2.Ideal High pass filter
3.Gaussian High pass filter
4.Butterworth High pass filter
5.Ideal Low pass filter
6.Gaussian Low pass filter
7.Butterworth Low pass filter

VIEW OUR SPECIAL PAGE FOR SEM 7 STUDENTS - sem 7 java codes

VIEW OUR SPECIAL PAGE ON, " ROBOTICS AND ARTIFICIAL INTELLIGENCE " FOR SEM 7 STUDENTS - Robotics and Artificial Intelligence

Friday, 20 September 2013

Mobile Computing Project : WML (Wireless Markup Language) mini project on 'E-Commerce website' free download

This is a mini project in wml on an online shop. You can Donload the project from the DOWNLOAD BOX.Download the file 'wmlproject.zip' from the download box.

VIEW OUR SPECIAL PAGE FOR SEM 7 STUDENTS - sem 7 java codes

Monday, 16 September 2013

Robotics and AI : Wumpus world problem Java Code/Program.

Given below is the java program for "Wumpus world problem".
The program gives a perfect implementation of this problem.It accepts the environment from the user dynamically, and then the agent tries to explore the best possible path to reach the gold, preventing the pits and the wumpus.
This is a perfect code with sample outputs for two scenarios/environments.

VIEW OUR SPECIAL PAGE ON, " ROBOTICS AND ARTIFICIAL INTELLIGENCE " FOR SEM 7 STUDENTS - Robotics and Artificial Intelligence

// Aim:To implement Wumpus world problem in Java
//Program:

import java.util.*;
class Environment
{
Scanner scr=new Scanner(System.in);
//char w[][]=new char[5][5];
int np;     //number of pits
int wp,gp; // wumpus position   gold position
int pos[]; // position of pits
int b_pos[]=new int[20];
int s_pos[]=new int[20];
void accept(String w[][])
{
for(int i=0;i<20;++i)
{
b_pos[i]=-1;
s_pos[i]=-1;
}

for(int i=0;i<5;++i)
for(int j=0;j<5;++j)
w[i][j]="";

int count=1;
System.out.println("\n\n********* Wumpus World Problem *********\n-by Aditya Mandhare.\n");

System.out.println("The positions are as follows.");
for(int i=1;i<=4;++i)
{
System.out.println("\n-----------------------------------------------------------------");
System.out.print("|\t");
for(int j=1;j<=4;++j)
System.out.print((count++)+"\t|\t");
}
System.out.println("\n-----------------------------------------------------------------");
System.out.println("\nAgent start position: 13");
w[4][1]="A";
System.out.println("\nEnter the number of pits.");
np=scr.nextInt();
pos=new int[np];
System.out.println("Positions of pit, gold and wumpus should not overlap.");
System.out.println("Enter the position of pits.");
for(int i=0;i<np;++i)
{
pos[i]=scr.nextInt();
show_sense(pos[i],1,w);
}
System.out.println("Enter the position of wumpus.");
wp=scr.nextInt();
show_sense(wp,2,w);

System.out.println("Enter the position of gold.");
gp=scr.nextInt();

insert(w);
}

void insert(String w[][])
{
int temp=0;
int count=0;
int flag1=0,flag2=0;
for(int i=0;i<np;++i)
{
temp=pos[i];
count=0;
for(int j=1;j<=4;++j)
{
for(int k=1;k<=4;++k)
{
++count;
if(count==temp)
w[j][k]+="P";
else
if(count==gp && flag1==0)
{
w[j][k]+="G";
flag1=1;
}
else
if(count==wp && flag2==0)
{
w[j][k]+="W";
flag2=1;
}
}
}
}

display(w);
}

void show_sense(int a,int b,String w[][])
{
int t1,t2,t3,t4;
t1=a-1;
t2=a+1;
t3=a+4;
t4=a-4;

if(a==5 || a==9)
t1=0;
if(a==8 || a==12)
t2=0;
if(a==4)
t2=0;
if(a==13)
t1=0;

if(t3>16)
t3=0;
if(t4<0)
t4=0;

//int temp[]=new int[4];

if(b==1)
{b_pos[0]=t1;b_pos[1]=t2;b_pos[2]=t3;b_pos[3]=t4;}
else
if(b==2)
{s_pos[0]=t1;s_pos[1]=t2;s_pos[2]=t3;s_pos[3]=t4;}

int temp1,count;

for(int i=0;i<4;++i)
{
if(b==1)
temp1=b_pos[i];
else
temp1=s_pos[i];
count=0;
for(int j=1;j<=4;++j)
{
for(int k=1;k<=4;++k)
{
++count;
if(count==temp1 && b==1 && !w[j][k].contains("B"))
{
w[j][k]+="B";
}
else
if(count==temp1 && b==2 && !w[j][k].contains("S"))
w[j][k]+="S";
}
}
}
 
//display(w);
}
void display(String w[][])
{
System.out.println("\nThe environment for problem is as follows.\n");
for(int i=1;i<=4;++i)
{
System.out.println("\n-----------------------------------------------------------------");
System.out.print("|\t");
for(int j=1;j<=4;++j)
System.out.print(w[i][j]+"\t|\t");
}
System.out.println("\n-----------------------------------------------------------------");
}


}

class tiles
{
int safe=0;
int unsafe=0;
int wump=0;
int pit=0;
int gold=0;
int doubt_pit=0;
int doubt_wump=0;
String env;
int num=0;
int br=0;
int bl=0;
int bu=0;
int bd=0;
int visited=0;
int l,r,u,d;
String back="";
tiles(String s,int n)
{
env=s;
num=n;
l=r=u=d=0;
if(n==9 || n==5)
bl=1;

if(n==8 || n==12)
br=1;

if(n==1)
{
bu=1;bl=1;
}
if(n==13)
{
bd=1;bl=1;
}
if(n==4)
{
bu=1;br=1;
}
if(n==16)
{
bd=1;br=1;
}

}

int sense()
{
if(env.contains("B"))
return 1;
else
if(env.contains("S"))
return 2;
else
if(env.contains("G"))
return 3;
if(env.contains("W"))
return 4;
else
return 0;
}

}


class wumpus 
{
static int scream=0;
static int score=0;
static int complete=0;

static boolean check(tiles t)
{
int temp=t.sense();
if(temp==1 || temp==2)
return false;

return true;
}
public static void main(String args[])
{
Scanner scr=new Scanner(System.in);
Environment e=new Environment();
String w[][]=new String[5][5];
e.accept(w);
System.out.println("\n\nFinding the solution...");

tiles t[]=new tiles[17];
int c=1;
out:for(int i=1;i<5;++i)
{
for(int j=1;j<5;++j)
{
if(c>16)
break out;
t[c]=new tiles(w[i][j],c);
++c;
}
}

t[13].safe=1;
t[13].visited=1;

int pos=13;
int condition;
int limit=0;
String temp1,temp2;
do
{
++limit;
condition=-1;

if(t[pos].env.contains("G"))
{
complete=1;
System.out.println("Gold Found!!");
break;
}

if(t[pos].br!=1 && t[pos].r!=1 && t[pos+1].doubt_pit<1 && t[pos+1].doubt_wump<1 && t[pos+1].pit!=1 && t[pos+1].wump!=1 && !(t[pos].back.contains("r") && (t[pos].l!=1 || t[pos].u!=1 || t[pos].d!=1) && check(t[pos]) ))
{
////////////

temp1="l";
///////////
t[pos].r=1;
++pos;
System.out.println("\nfront pos="+pos);
++score;
//t[pos].visited=1;
////////////////
t[pos].back+=temp1;
////////////////
condition=t[pos].sense();
if(condition==3)
{complete=1;break;}
else
if(condition==1 && t[pos].visited==0)
{
if(t[pos].br!=1 && t[pos+1].safe!=1)
t[pos+1].doubt_pit+=1;
if(t[pos].bu!=1 && (pos-4)>=1 && t[pos-4].safe!=1)
t[pos-4].doubt_pit+=1;
if(t[pos].bl!=1 && t[pos-1].safe!=1 )
t[pos-1].doubt_pit+=1;
if(t[pos].bd!=1 && (pos+4)<=16 && t[pos+4].safe!=1)
t[pos+4].doubt_pit+=1;

t[pos].safe=1;
}
else
if(condition==2 && t[pos].visited==0)
{
if(t[pos].br!=1 && t[pos+1].safe!=1)
t[pos+1].doubt_wump+=1;
if(t[pos].bu!=1 && (pos-4)>=1 &&  t[pos-4].safe!=1)
t[pos-4].doubt_wump+=1;
if(t[pos].bl!=1 && t[pos-1].safe!=1)
t[pos-1].doubt_wump+=1;
if(t[pos].bd!=1 && (pos+4)<=16 &&  t[pos+4].safe!=1)
t[pos+4].doubt_wump+=1;

t[pos].safe=1;
}
/*else
if(condition==4)
{
score=score+100;
t[pos].safe=1;
}*/
else
if(condition==0)
t[pos].safe=1;


t[pos].visited=1;
}
else
if(t[pos].bl!=1 && t[pos].l!=1 && t[pos-1].doubt_pit<1 && t[pos-1].doubt_wump<1 && t[pos-1].pit!=1 && t[pos-1].wump!=1 && !(t[pos].back.contains("l") && (t[pos].r!=1 || t[pos].u!=1 || t[pos].d!=1) && check(t[pos]) ))
{
////////////////////
temp1="r";
///////////////////
t[pos].l=1;
pos=pos-1;
System.out.println("\nback pos= "+pos);
++score;
//t[pos].visited=1;

//////////////////////

t[pos].back+=temp1;
/////////////////////


condition=t[pos].sense();
if(condition==3)
{complete=1;break;}
else
if(condition==1 && t[pos].visited==0)
{
if(t[pos].br!=1 && t[pos+1].safe!=1)
t[pos+1].doubt_pit+=1;
if(t[pos].bu!=1 && (pos-4)>=1 &&  t[pos-4].safe!=1)
t[pos-4].doubt_pit+=1;
if(t[pos].bl!=1 && t[pos-1].safe!=1)
t[pos-1].doubt_pit+=1;
if(t[pos].bd!=1 && (pos+4)<=16 &&  t[pos+4].safe!=1)
t[pos+4].doubt_pit+=1;


t[pos].safe=1;
}
else
if(condition==2 && t[pos].visited==0)
{
if(t[pos].br!=1 && t[pos+1].safe!=1)
t[pos+1].doubt_wump+=1;
if(t[pos].bu!=1 && (pos-4)>=1 &&  t[pos-4].safe!=1)
t[pos-4].doubt_wump+=1;
if(t[pos].bl!=1 && t[pos-1].safe!=1)
t[pos-1].doubt_wump+=1;
if(t[pos].bd!=1 && (pos+4)<=16 &&  t[pos+4].safe!=1)
t[pos+4].doubt_wump+=1;

t[pos].safe=1;
}
else
if(condition==0)
t[pos].safe=1;

t[pos].visited=1;


}
else
if(t[pos].bu!=1 && t[pos].u!=1 && (pos-4)>=1 &&  t[pos-4].doubt_pit<1 && t[pos-4].doubt_wump<1 && t[pos-4].pit!=1 && t[pos-1].wump!=1 && !(t[pos].back.contains("u") && (t[pos].l!=1 || t[pos].r!=1 || t[pos].d!=1) && check(t[pos])  ))
{
/////////////////////

temp1="d";
/////////////////////
t[pos].u=1;
pos=pos-4;
System.out.println("\nUp pos= "+pos);
++score;
//t[pos].visited=1;

///////////////////////
t[pos].back+=temp1;
/////////////////////
condition=t[pos].sense();
if(condition==3)
{complete=1;break;}
else
if(condition==1 && t[pos].visited==0)
{
if(t[pos].br!=1 && t[pos+1].safe!=1)
t[pos+1].doubt_pit+=1;
if(t[pos].bu!=1 && (pos-4)>=1 &&  t[pos-4].safe!=1)
t[pos-4].doubt_pit+=1;
if(t[pos].bl!=1 && t[pos-1].safe!=1)
t[pos-1].doubt_pit+=1;
if(t[pos].bd!=1 && (pos+4)<=16 &&  t[pos+4].safe!=1)
t[pos+4].doubt_pit+=1;


t[pos].safe=1;
}
else
if(condition==2 && t[pos].visited==0)
{
if(t[pos].br!=1 && t[pos+1].safe!=1)
t[pos+1].doubt_wump+=1;
if(t[pos].bu!=1 && (pos-4)>=1 &&  t[pos-4].safe!=1)
t[pos-4].doubt_wump+=1;
if(t[pos].bl!=1 && t[pos-1].safe!=1)
t[pos-1].doubt_wump+=1;
if(t[pos].bd!=1 && (pos+4)<=16 &&  t[pos+4].safe!=1)
t[pos+4].doubt_wump+=1;

t[pos].safe=1;
}
else
if(condition==0)
t[pos].safe=1;

t[pos].visited=1;
}
else
if(t[pos].bd!=1 && t[pos].d!=1 && (pos+4)<=16 &&  t[pos+4].doubt_pit<1 && t[pos+4].doubt_wump<1 && t[pos+4].pit!=1 && t[pos+4].wump!=1)
{
/////////////////
temp1="u";
////////////////
t[pos].d=1;
pos=pos+4;
System.out.println("\ndown pos= "+pos);
++score;
//t[pos].visited=1;

//////////////////

t[pos].back+=temp1;
//////////////////
condition=t[pos].sense();
if(condition==3)
{complete=1;break;}
else
if(condition==1 && t[pos].visited==0)
{
if(t[pos].br!=1 && t[pos+1].safe!=1)
t[pos+1].doubt_pit+=1;
if(t[pos].bu!=1 && (pos-4)>=1 &&  t[pos-4].safe!=1)
t[pos-4].doubt_pit+=1;
if(t[pos].bl!=1 && t[pos-1].safe!=1)
t[pos-1].doubt_pit+=1;
if(t[pos].bd!=1 && (pos+4)<=16 &&  t[pos+4].safe!=1)
t[pos+4].doubt_pit+=1;

t[pos].safe=1;
}
else
if(condition==2 && t[pos].visited==0)
{
if(t[pos].br!=1 && t[pos+1].safe!=1)
t[pos+1].doubt_wump+=1;
if(t[pos].bu!=1 && (pos-4)>=1 &&  t[pos-4].safe!=1)
t[pos-4].doubt_wump+=1;
if(t[pos].bl!=1 && t[pos-1].safe!=1)
t[pos-1].doubt_wump+=1;
if(t[pos].bd!=1 && (pos+4)<=16 &&  t[pos+4].safe!=1)
t[pos+4].doubt_wump+=1;

t[pos].safe=1;
}
else
if(condition==0)
t[pos].safe=1;

t[pos].visited=1;
}
else
if(limit>50)
{
int temp3=pos;
int flag_1=0,flag2=0,flag3=0,flag4=0;

System.out.println("\nCurrently at position "+temp3+".\nThinking....");

//if(!(t[pos].back.contains("r") && (t[pos].l!=1 || t[pos].u!=1 || t[pos].d!=1) && check(t[pos]) ))
while(t[pos].visited==1 && t[pos].br!=1)
{
++pos;
++score;
}


if(t[pos].pit==1 || t[pos].wump==1 || (t[pos].br==1 && t[pos].visited==1 && t[pos].safe!=1))
{
//System.out.println("\nUnsuccessful at pos "+pos);
pos=temp3;
//System.out.println("\nBack at pos "+pos);
flag_1=1;
} 

if(flag_1==0)
t[pos].back+="l";

//if(!(t[pos].back.contains("u") && (t[pos].l!=1 || t[pos].r!=1 || t[pos].d!=1) && check(t[pos])  ))
while(pos+4>=1 && t[pos].bu!=1 && t[pos].visited==1)
{
pos-=4;
++score;
}

if(t[pos].pit==1 || t[pos].wump==1 || (t[pos].bu==1 && t[pos].visited==1  && t[pos].safe!=1))
{
//System.out.println("\nUnsuccessful at pos "+pos);
pos=temp3;
//System.out.println("\nBack at pos "+pos);
flag3=1;
} 

if(flag3==0)
t[pos].back+="d";

//if(!(t[pos].back.contains("l") && (t[pos].r!=1 || t[pos].u!=1 || t[pos].d!=1) && check(t[pos]) ))
while(t[pos].visited==1 && t[pos].bl!=1)
{
--pos;
++score;
}

if(t[pos].pit==1 || t[pos].wump==1 || (t[pos].bl==1 && t[pos].visited==1 && t[pos].safe!=1))
{
//System.out.println("\nUnsuccessful at pos "+pos);
pos=temp3;
//System.out.println("\nBack at pos "+pos);
flag2=1;
} 

if(flag2==0)
t[pos].back+="r";



//if(!(t[pos].back.contains("d") && (t[pos].l!=1 || t[pos].r!=1 || t[pos].u!=1) && check(t[pos])  ))
while(pos+4<=16 && t[pos].bd!=1 && t[pos].visited==1)
{
pos+=4;
++score;
}

if(t[pos].pit==1 || t[pos].wump==1 || (t[pos].bd==1 && t[pos].visited==1 && t[pos].safe!=1))
{
//System.out.println("\nUnsuccessful at pos "+pos);
pos=temp3;
//System.out.println("\nBack at pos "+pos);
flag4=1;
} 
//t[pos-1].r=0;
//++pos;
//if(!t[pos].env.contains("P") && !t[pos].env.contains("W"))

if(flag4==0)
t[pos].back+="u";

t[pos].safe=1;
t[pos].visited=1;
System.out.println("reached at position "+pos);
limit=0;
}
if(t[pos].env.contains("W") && scream!=1)
{
score+=100;
scream=1;
t[pos].safe=1;
System.out.println("\n\nWumpus killed >--0-->");
t[pos].env.replace("W"," ");
for(int l=1;l<=16;++l)
{
t[l].doubt_wump=0;
t[l].env.replace("S"," ");
}
}

if(t[pos].env.contains("P"))
{
score+=50;
t[pos].pit=1;
System.out.println("\n\nFallen in pit of position "+pos+".");
}

for(int k=1;k<=16;++k)
{
if(t[k].doubt_pit==1 && t[k].doubt_wump==1)
{
t[k].doubt_pit=0;
t[k].doubt_wump=0;
t[k].safe=1;
}
}

for(int y=1;y<=16;++y)
{
if(t[y].doubt_wump>1)
{
t[y].wump=1;
for(int h=1;h<=16;++h)
{
if(h!=y)
{
t[h].doubt_wump=0;
t[h].env.replace("S"," ");
}
}

}

}

///////////////////////////
for(int y=1;y<=16;++y)
{
if(t[y].doubt_pit>1)
{t[y].pit=1;
//System.out.println("\nPit confirmed at position "+y);
}
}
///////////////////////////


try{Thread.sleep(200);}catch(Exception p){}

}
while(complete==0);

if(complete==1)
{
//score=score*2;
//if(scream==1)
//score-=100;

score*=-1;
score+=1000;
}
System.out.println("The score of the agent till he reaches gold is "+score+".\nNow he will return back following the best explored path.");

}
}

/* OUTPUT 1

C:\Users\Aditya\Desktop\aditya>javac wumpus.java

C:\Users\Aditya\Desktop\aditya>java wumpus


********* Wumpus World Problem *********


The positions are as follows.

-----------------------------------------------------------------
|       1       |       2       |       3       |       4       |
-----------------------------------------------------------------
|       5       |       6       |       7       |       8       |
-----------------------------------------------------------------
|       9       |       10      |       11      |       12      |
-----------------------------------------------------------------
|       13      |       14      |       15      |       16      |
-----------------------------------------------------------------

Agent start position: 13

Enter the number of pits.
3
Positions of pit, gold and wumpus should not overlap.
Enter the position of pits.
4 7 15
Enter the position of wumpus.
5
Enter the position of gold.
6

The environment for problem is as follows.


-----------------------------------------------------------------
|       S       |               |       B       |       P       |
-----------------------------------------------------------------
|       W       |       BSG     |       P       |       B       |
-----------------------------------------------------------------
|       S       |               |       B       |               |
-----------------------------------------------------------------
|       A       |       B       |       P       |       B       |
-----------------------------------------------------------------


Finding the solution...

front pos=14

back pos= 13

Up pos= 9

front pos=10

front pos=11

back pos= 10

Up pos= 6
Gold Found!!
The score of the agent till he reaches gold is 993.
Now he will return back following the best explored path.



OUTPUT 2

C:\Users\Aditya\Desktop\aditya>javac wumpus.java

C:\Users\Aditya\Desktop\aditya>java wumpus


********* Wumpus World Problem *********


The positions are as follows.

-----------------------------------------------------------------
|       1       |       2       |       3       |       4       |
-----------------------------------------------------------------
|       5       |       6       |       7       |       8       |
-----------------------------------------------------------------
|       9       |       10      |       11      |       12      |
-----------------------------------------------------------------
|       13      |       14      |       15      |       16      |
-----------------------------------------------------------------

Agent start position: 13

Enter the number of pits.
2
Positions of pit, gold and wumpus should not overlap.
Enter the position of pits.
5 11
Enter the position of wumpus.
6
Enter the position of gold.
4

The environment for problem is as follows.


-----------------------------------------------------------------
|       B       |       S       |               |       G       |
-----------------------------------------------------------------
|       SP      |       BW      |       BS      |               |
-----------------------------------------------------------------
|       B       |       BS      |       P       |       B       |
-----------------------------------------------------------------
|       A       |               |       B       |               |
-----------------------------------------------------------------


Finding the solution...

front pos=14

front pos=15

back pos= 14

Up pos= 10

down pos= 14

Currently at position 14.
Thinking....
reached at position 16

Currently at position 16.
Thinking....
reached at position 12

Up pos= 8

back pos= 7

front pos=8

Up pos= 4
The score of the agent till he reaches gold is 988.
Now he will return back following the best explored path.

*/

VIEW OUR SPECIAL PAGE FOR SEM 7 STUDENTS - sem 7 java codes

Thursday, 5 September 2013

Sem 4 & Sem 7 (AOAD & RAI) : N queen Algorithm Java Code

import java.util.*;
class nqueen
{
static int n=10;
static int board[]=new int[n];
static boolean place(int row,int column)
{
for(int i=1;i<=row-1;++i)
{
if(column==board[i])
return false;
else 
if(abs(column-board[i])==abs(row-i))
return false;
}
return true;
}
static int abs(int arg)
{
if(arg<0)
return arg*-1;
else
if(arg==0)
return 0;
else
return arg;
}
static void queen(int row,int n)
{

for(int column=1;column<=n;++column)
{
if(place(row,column))
{
board[row]=column;
if(row==n)
display();
else
queen(row+1,n);
}
}
}

static void display()
{
System.out.println();
System.out.print("Pattern ");
for(int i=1;i<=n;++i)
System.out.print(" "+board[i]);
System.out.println();
int pos;
System.out.print(" ");
for(int i=1;i<=n;++i)
System.out.print(" "+i);
System.out.println();
for(int i=1;i<=n;++i)
{
pos=board[i];
System.out.print(" "+i);
for(int j=1;j<=n;++j)
{
if(j==pos)
System.out.print(" Q");
else
System.out.print(" -");
}
System.out.println();
}
}

public static void main(String args[])
{
Scanner scr=new Scanner(System.in);
System.out.println("**********N Queen problem*************");
System.out.println("Enter the number of queens");
n=scr.nextInt();
/* IF there are 'n' queens there are n rows and n columns */
queen(1,n);
}
}

VIEW OUR SPECIAL PAGE FOR SEM 7 STUDENTS - sem 7 java codes

Tuesday, 27 August 2013

Water Jug Problem Java program

The java code for Water Jug Problem is given below.There are many solutions for it run the code to find all.

VIEW OUR SPECIAL PAGE ON, " ROBOTICS AND ARTIFICIAL INTELLIGENCE " FOR SEM 7 STUDENTS - Robotics and Artificial Intelligence

//Aim:To implement Water jug problem in Java.
//Program:
import java.util.*;
class wj2
{
static int gallon1,gallon2;
static int wastage;
static int steps;
static int rules[]=new int[15];
static int reset=0;
static int ct=0;
static int incr;
static int tgallon1,tgallon2;
static int check()
{
if(steps>10 || reset==1)
return 1;
else 
if(gallon1==2)
return 2;
else
return 0;
}

static void empty1()
{
wastage=wastage+gallon1;
gallon1=0;
} 
static void empty2()
{
wastage=wastage+gallon2;
gallon2=0;
}
static void fill1()
{
gallon1=gallon1+4;
}
static void fill2()
{
gallon2+=3;
}
static void gallon1_to_gallon2()
{
int temp=0;
temp=3-gallon2;
gallon2=3;
gallon1=gallon1-temp;
}
static void gallon2_to_gallon1()
{
int temp=0;
temp=4-gallon1;
gallon1=4;
gallon2=gallon2-temp;
}
static void empty1_fill2()
{
gallon2=gallon2+gallon1;
gallon1=0;
}
static void empty2_fill1()
{
gallon1=gallon1+gallon2;
gallon2=0;
}


static void call(int n)
{

tgallon1=gallon1;
tgallon2=gallon2;

try
{
//Thread.sleep(1000);
}
catch(Exception e)
{
System.out.println("Exception in thread");
}
if(steps>10)
{
System.out.println("ERROR num of steps greater than 10");
}

++steps;
if(n==1)
fill1();
//empty1();
else
if(n==2)
fill2();
//empty2();
else
if(n==3)
empty1();
//fill1();
else
if(n==4)
empty2();
//fill2();
else
if(n==5)
gallon1_to_gallon2();
else
if(n==6)
gallon2_to_gallon1();
else
if(n==7)
empty1_fill2();
else
if(n==8)
empty2_fill1();

if(gallon1>4 || gallon1<0 || gallon2>3 || gallon2<0)
reset=1;

}

static void repeat(int rules[])
{
gallon1=0;
gallon2=0;
wastage=0;
steps=0;

System.out.println("\nGallon1\tGallon2\tRule");
System.out.println(gallon1+"\t"+gallon2+"\t");
call(rules[0]);
if(rules[0]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[0]);
call(rules[1]);
if(rules[1]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[1]);
call(rules[2]);
if(rules[2]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[2]);
call(rules[3]);
if(rules[3]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[3]);
call(rules[4]);
if(rules[4]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[4]);
call(rules[5]);
if(rules[5]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[5]);
call(rules[6]);
if(rules[6]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[6]);
call(rules[7]);
if(rules[7]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[7]);
call(rules[8]);
if(rules[8]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[8]);
call(rules[9]);
if(rules[9]!=0)
System.out.println(gallon1+"\t"+gallon2+"\t"+rules[9]);
}
public static void main(String args[])
{
Scanner scr=new Scanner(System.in);
System.out.println("**********This is waterjug *************");
System.out.println("\nRules:\n1.Fill Gallon 1.\n2.Fill Gallon 2.\n3.Empty gallon 1.\n4.Empty Gallon 2.\n5.Gallon 1 to Gallon 2 till full.\n6.Gallon 2 to Gallon 1 till full.\n7.Empty Gallon 1 and add to Gallon 2.\n8.Empty Gallon 2 and add to Gallon 1.");
System.out.println("\nThe Optimal solution is the one with minimum steps and minimum wastage.\n");
int flag=0;
int count1=0;

flag=0;
count1=0;
wastage=0;
steps=0;
for(int i=0;i<10;++i)
rules[i]=0;
reset=0;
int temp1=0;
incr=0;
/************Data for testing the functionality****************/
/*
rules[0]=1;rules[1]=5;rules[2]=3;rules[3]=8;rules[4]=2;rules[5]=6;rules[6]=3;rules[7]=8;rules[8]=0;rules[9]=0;
repeat(rules);
System.out.println("\nWastage= "+wastage);
rules[0]=2;rules[1]=8;rules[2]=2;rules[3]=6;rules[4]=3;rules[5]=8;rules[6]=0;rules[7]=0;rules[8]=0;rules[9]=0;
repeat(rules);
System.out.println("\nWastage= "+wastage);
rules[0]=1;rules[1]=5;rules[2]=4;rules[3]=7;rules[4]=1;rules[5]=5;rules[6]=0;rules[7]=0;rules[8]=0;rules[9]=0;
repeat(rules);
System.out.println("\nWastage= "+wastage);
*/

l1:for(int i=0;i<8;++i)
{
l2:for(int j=0;j<8;++j)
{
l3:for(int k=0;k<8;++k)
{
l4:for(int l=0;l<8;++l)
{
l5:for(int m=0;m<8;++m)
{
l6:for(int n=0;n<8;++n)
{
l7:for(int o=0;o<8;++o)
{
l8:for(int p=0;p<8;++p)
{
l9:for(int q=0;q<8;++q)
{
l10:for(int r=0;r<8;++r)
{
reset=0;
call(i);
call(j);
call(k);
call(l);
call(m);
call(n);
call(o);
call(p);
call(q);
call(r);
if(gallon1==2 && reset==0)
{
try
{
Thread.sleep(10000);
rules[0]=i;rules[1]=j;rules[2]=k;rules[3]=l;rules[4]=m;rules[5]=n;rules[6]=o;rules[7]=p;rules[8]=q;rules[9]=r;
System.out.println("\nFound a pattern !!!!\n");
repeat(rules);
int count2=0;

for(int z=0;z<10;++z)
{
if(rules[z]!=0)
{
//System.out.print(" "+rules[z]);
++count2;
}
}

System.out.println("\nNumber of Steps= "+(count2+1));
System.out.println("\nWastage= "+wastage);
System.out.println("\n\n\nPlease wait for another solution.....");

Thread.sleep(10000);
}
catch(Exception e)
{}
}

gallon1=0;
gallon2=0;
steps=0;
reset=0;
wastage=0;
}
}
}
}
}
}
}
}
}
}

}
}
/*OUTPUT
C:\Users\Aditya\Desktop\aditya>javac wj2.java

C:\Users\Aditya\Desktop\aditya>java wj2
**********This is waterjug *************

Rules:
1.Fill Gallon 1.
2.Fill Gallon 2.
3.Empty gallon 1.
4.Empty Gallon 2.
5.Gallon 1 to Gallon 2 till full.
6.Gallon 2 to Gallon 1 till full.
7.Empty Gallon 1 and add to Gallon 2.
8.Empty Gallon 2 and add to Gallon 1.

The Optimal solution is the one with minimum steps and minimum wastage.


Found a pattern !!!!


Gallon1 Gallon2 Rule
0       0
4       0       1
1       3       5
0       3       3
3       0       8
3       3       2
4       2       6
0       2       3
2       0       8

Number of Steps= 9

Wastage= 5


Please wait for another solution.....

Found a pattern !!!!


Gallon1 Gallon2 Rule
0       0
0       3       2
3       0       8
3       3       2
4       2       6
0       2       3
2       0       8

Number of Steps= 7

Wastage= 4



Please wait for another solution.....

Found a pattern !!!!



Gallon1 Gallon2 Rule
0       0
4       0       1
1       3       5
1       0       4
0       1       7
4       1       1
2       3       5

Number of Steps= 7

Wastage= 3


Please wait for another solution.....

*/