## Get more of such content, Weekly

* indicates required
Web & App Development

# Best answer to AMCAT automata 2015 If you have attempted the AMCAT exam there is an optional section that is AUTOMATA which have 2 questions here is the question I am going to solve it written in JAVA and can be written in any other language with minor changes in logic. Let’s see the problem and its program

## Mooshak the mouse Maze Question

#### Problem:

Mooshak the mouse has been placed in a maze.There is a huge chunk of cheese somewhere in the maze. The maze is represented as a two-dimensional array of integers, where 0 represents walls.1 represents paths where mooshak can move and 9 represents the huge chunk of cheese.

Also read: AMCAT Automata Important questions 2015

Mooshak starts in the top left corner at 0.
Write a method is Path of class Maze Path to determine if Mooshak can reach the huge chunk of cheese. The input to is Path consists of a two dimensional array gnd for the maze matrix. the method should return 1 if there is a path from Mooshak to the cheese.and 0 if not Mooshak is not allowed to leave the maze or climb on walls.

```EX: 8 by 8(8*8) matrix maze where Mooshak can get the cheese.

1 0 1 1 1 0 0 1
1 0 0 0 1 1 1 1
1 0 0 0 0 0 0 0
1 0 1 0 9 0 1 1
1 1 1 0 1 0 0 1
1 0 1 0 1 1 0 1
1 0 0 0 0 1 0 1
1 1 1 1 1 1 1 1```

#### Test Cases:

Case 1:
Input:[[1,1,1,][9,1,1],[0,1,0]]

Expected return value :1

### Explanation:

The piece of cheese is placed at(1,0) on the grid Mooshak can move from (0,0) to (1,0) to reach it or can move from (0,0) to (0,1) to (1,1) to (1,0)

#### Test case 2:

Input: [[0,0,0],[9,1,1],[0,1,1]]

Expected return value: 0

### Explanation:

Mooshak cannot move anywhere as there exists a wall right on (0,0)

### Code format: (C Language)

```//include header files needed by your program
// some libray functionality may be restricted
// define any function needed
// fucion signature begins, this function is required
Int isPath(int **grid,int m,int n)
{/
}/
/function signature ends```

### Java Code format:

```//import librays packages needed by your program
// some clases with in a package may be restricted
//define any class and method needed
//class begins ,this class is required
Public class MazePath
{
Public static int isPath(int[][] grid)
}/
/ method signature ends
}``` ### Java Program Code:

```Int isPath(int **grid,int m,int n)
{
Return SolveMazeUtil(grid,0,0,m,n);
}I
nt SolveMazeUtil(int **grid,x,y,m,n)
{
If(x>=0 && x < m && y>=0 && y<n)
{
if(grid[x][y]==9))
{
return 1;
}
// Check if maze[x][y] is valid
if(grid[x][y] == 1)
{
/* Move forward in x direction */
if (solveMazeUtil(grid, x+1, y, m,n) == 1)
return 1;
/* If moving in x direction doesn't give solution then
Move down in y direction */
if (solveMazeUtil(grid, x, y+1, m,n) == 1)
return 1;
/* If none of the above movements work then BACKTRACK:
unmark x,y as part of solution path */
return 0;
}
return 0;
}
return 0;
}```

Hello here is a solution of a problem asked in automata AMCAT exam. The solution is in C++ but logic can be applied to any programming language.

## Colony of 8 cells arranged in a straight line

Problem: There is a colony of 8 cells arranged in a straight line where each day every cell competes with its adjacent cells(neighbour). Each day, for each cell, if its neighbours are both active or both inactive, the cell becomes inactive the next day, otherwise it becomes active the next day.

Assumptions:

The two cells on the ends have single adjacent cell, so the other adjacent cell can be assumsed to be always inactive.
Even after updating the cell state. consider its previous state for updating the state of other cells. Update the cell information of all cells simultaneously.

Write a function cellCompete which takes takes one 8 element array of integers cells representing the current state of 8 cells and one integer days representing te number of days to simulate.

An integer value of 1 represents an active cell and value of 0 represents an inactive cell.

program:
int* cellCompete(int* cells,int days)
{/
}
//function signature ends  Example automata AMCAT fig
TESTCASES 1:
INPUT:
[1,0,0,0,0,1,0,0],1
EXPECTED RETURN VALUE:
[0,1,0,0,1,0,1,0]
TESTCASE 2:
INPUT:
[1,1,1,0,1,1,1,1,],2
EXPECTED RETURN VALUE:
[0,0,0,0,0,1,1,0]
```#include<iostream>
using namespace std;

int cellCompete(int *cells ,int day){

for (int i=0;i<day;i++){

cells[-1]=0; //assumptions
cells=0;//assumptions
int u; //another array to copy value
for (int i=-1;i<9;i++){
u[i]=cells[i];
}

for(int j=0;j<8;j++){
if(u[j-1]==u[j+1]){ //comparing the value of the neighbouring cells of u[]
cells[j]=0; //changing value of cell according to condition
}
else
cells[j]=1;
} }

for (int i=0;i<8;i++){
cout<<cells[i];
}
return 0;}

int main(){ //main function
int days,cells[]={1,0,0,0,0,1,0,0}; //array to pass through function
int *cellsptr=cells; //creating array values to pointer
cout<<"enter days:"; //for days
cin>>days;
cout<<"n[1,0,0,0,0,1,0,0]n";
cellCompete(cellsptr, days); //passing to function
return 0;
}```
Thanks for reading, share and help others. • AkshayM says:

in your code, mouse can either move in horizontal right or vertically down…but in some cases it may need that mouse move in horizontal left and vertically up to make a way and get cheese…

• sharma ji says:

The solution to the mouse problem is not complete.
New solution with some changes

int isPath(int **grid,int m,int n)
{
return SolveMazeUtil(grid,0,0,m,n);
}

int SolveMazeUtil(int **grid,x,y,m,n)
{
If(x>=0 && x =0 && y<n)
{
if(grid[x][y]==9)) // We reached the cheese.
return 1;

//If maze[x][y] is valid we will find next valid position around this position.

if(grid[x][y] == 1)
{
if (solveMazeUtil(grid, x+1, y, m, n) == 1) //move toward's right for finding a valid path.
return 1;
if (solveMazeUtil(grid, x, y+1, m, n) == 1) //move toward's bottom.
return 1;
if (solveMazeUtil(grid, x-1, y, m, n) == 1) //move toward's left.
return 1;
if (solveMazeUtil(grid, x, y-1, m, n) == 1) //move toward's top.
return 1;

grid[x][y] = 0; //If we don't find any valid path around this position we will erase this as a path to avoid going throung this path again.