Find paths from corner cell to middle cell in maze
Here given code implementation process.
/*
Java Program for
Find paths from corner cell to middle cell in maze
*/
public class Path
{
public boolean status;
public Path()
{
this.status = false;
}
public void display(int[][] maze, int n)
{
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
System.out.print(" " + maze[i][j]);
}
}
System.out.print("\n");
}
public void printPath(int[][] maze, int i, int j, int mid, String result)
{
if (i == mid && j == mid)
{
// When we get middle row and middle column
this.status = true;
System.out.println(result + "(MID[" + i + "][" + j + "]) ");
return;
}
if (maze[i][j] == 0)
{
return;
}
int value = maze[i][j];
maze[i][j] = 0;
if (j + value < maze.length)
{
// Move right
printPath(maze, i, j + value, mid, result + "[" + i + "][" + j + "]⤑ ");
}
if (i + value < maze.length)
{
// Move down
printPath(maze, i + value, j, mid, result + "[" + i + "][" + j + "]⤑ ");
}
if (j - value > 0)
{
// Move left
printPath(maze, i, j - value, mid, result + "[" + i + "][" + j + "]⤑ ");
}
if (i - value > 0)
{
// Move Up
printPath(maze, i - value, j, mid, result + "[" + i + "][" + j + "]⤑ ");
}
maze[i][j] = value;
}
void printSolution(int[][] maze)
{
int n = maze.length;
this.status = false;
// Find path
printPath(maze, 0, 0, n / 2, "");
if (this.status == false)
{
// No solution
System.out.println("\n No result ");
}
}
public static void main(String[] args)
{
Path task = new Path();
// Odd square matrix
int[][] maze = {
{
3 , 1 , 4 , 2 , 3
},
{
3 , 2 , 2 , 1 , 3
},
{
1 , 3 , 4 , 3 , 2
},
{
2 , 3 , 1 , 1 , 2
},
{
4 , 2 , 4 , 3 , 0 ,
}
};
/*
maze =
[
[ 3, 1, 4, 2, 3 ]
[ 3, 2, 2, 1, 3 ]
[ 1, 3, 4, 3, 2 ]
[ 2, 3, 1, 1, 2 ]
[ 4, 2, 4, 3, 0,]
]
------------------------
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, 2, 1, - ]
[ -, 3, 4, 3, - ]
[ -, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➀
[0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
[1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, -, -, - ]
[ -, -, 4, -, - ]
[ -, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➁
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
[3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ -, -, -, -, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➂
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, -, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➃
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, 2, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➄
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, -, 2, 1, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➅
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
*/
task.printSolution(maze);
}
}Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])// Include header file
#include <iostream>
#include <string>
#define N 5
using namespace std;
/*
C++ Program for
Find paths from corner cell to middle cell in maze
*/
class Path
{
public: bool status;
Path()
{
this->status = false;
}
void display(int maze[N][N])
{
for (int i = 0; i < N; ++i)
{
for (int j = 0; j < N; ++j)
{
cout << " " << maze[i][j];
}
}
cout << "\n";
}
void printPath(int maze[N][N], int i, int j, int mid, string result)
{
if (i == mid && j == mid)
{
// When we get middle row and middle column
this->status = true;
cout << result << "(MID[" << i << "][" << j << "]) " << endl;
return;
}
if (maze[i][j] == 0)
{
return;
}
int value = maze[i][j];
maze[i][j] = 0;
if (j + value < N)
{
// Move right
this->printPath(maze, i, j + value, mid,
result + "[" + to_string(i) + "][" + to_string(j) + "]⤑ ");
}
if (i + value < N)
{
// Move down
this->printPath(maze, i + value, j, mid,
result + "[" + to_string(i) + "][" + to_string(j) + "]⤑ ");
}
if (j - value > 0)
{
// Move left
this->printPath(maze, i, j - value, mid,
result + "[" + to_string(i) + "][" + to_string(j) + "]⤑ ");
}
if (i - value > 0)
{
// Move Up
this->printPath(maze, i - value, j, mid,
result + "[" + to_string(i) + "][" + to_string(j) + "]⤑ ");
}
maze[i][j] = value;
}
void printSolution(int maze[N][N])
{
this->status = false;
this->printPath(maze, 0, 0, N / 2, "");
if (this->status == false)
{
// No solution
cout << "\n No result " << endl;
}
}
};
int main()
{
Path *task = new Path();
// Odd square matrix
int maze[N][N] = {
{
3 , 1 , 4 , 2 , 3
} , {
3 , 2 , 2 , 1 , 3
} , {
1 , 3 , 4 , 3 , 2
} , {
2 , 3 , 1 , 1 , 2
} , {
4 , 2 , 4 , 3 , 0
}
};
/*
maze =
[
[ 3, 1, 4, 2, 3 ]
[ 3, 2, 2, 1, 3 ]
[ 1, 3, 4, 3, 2 ]
[ 2, 3, 1, 1, 2 ]
[ 4, 2, 4, 3, 0,]
]
------------------------
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, 2, 1, - ]
[ -, 3, 4, 3, - ]
[ -, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➀
[0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
[1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, -, -, - ]
[ -, -, 4, -, - ]
[ -, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➁
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
[3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ -, -, -, -, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➂
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, -, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➃
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, 2, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➄
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, -, 2, 1, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➅
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
*/
task->printSolution(maze);
return 0;
}Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])// Include namespace system
using System;
/*
Csharp Program for
Find paths from corner cell to middle cell in maze
*/
public class Path
{
public Boolean status;
public Path()
{
this.status = false;
}
public void display(int[,] maze, int n)
{
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
Console.Write(" " + maze[i,j]);
}
}
Console.Write("\n");
}
public void printPath(int[,] maze,
int i, int j,
int mid, String result)
{
if (i == mid && j == mid)
{
// When we get middle row and middle column
this.status = true;
Console.WriteLine(result + "(MID[" + i + "," + j + "]) ");
return;
}
if (maze[i,j] == 0)
{
return;
}
int value = maze[i,j];
maze[i,j] = 0;
if (j + value < maze.GetLength(0))
{
// Move right
this.printPath(maze, i, j + value,
mid, result + "[" + i + "," + j + "]⤑ ");
}
if (i + value < maze.GetLength(0))
{
// Move down
this.printPath(maze, i + value, j,
mid, result + "[" + i + "," + j + "]⤑ ");
}
if (j - value > 0)
{
// Move left
this.printPath(maze, i, j - value,
mid, result + "[" + i + "," + j + "]⤑ ");
}
if (i - value > 0)
{
// Move Up
this.printPath(maze, i - value, j,
mid, result + "[" + i + "," + j + "]⤑ ");
}
maze[i,j] = value;
}
void printSolution(int[,] maze)
{
int n = maze.GetLength(0);
this.status = false;
this.printPath(maze, 0, 0, n / 2, "");
if (this.status == false)
{
// No solution
Console.WriteLine("\n No result ");
}
}
public static void Main(String[] args)
{
Path task = new Path();
// Odd square matrix
int[,] maze = {
{
3 , 1 , 4 , 2 , 3
},
{
3 , 2 , 2 , 1 , 3
},
{
1 , 3 , 4 , 3 , 2
},
{
2 , 3 , 1 , 1 , 2
},
{
4 , 2 , 4 , 3 , 0
}
};
/*
maze =
[
[ 3, 1, 4, 2, 3 ]
[ 3, 2, 2, 1, 3 ]
[ 1, 3, 4, 3, 2 ]
[ 2, 3, 1, 1, 2 ]
[ 4, 2, 4, 3, 0,]
]
------------------------
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, 2, 1, - ]
[ -, 3, 4, 3, - ]
[ -, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➀
[0,0] ⤑ [0,3] ⤑ [0,1] ⤑ [1,1] ⤑
[1,3] ⤑ [1,2] ⤑ [3,2] ⤑ (MID[2,2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, -, -, - ]
[ -, -, 4, -, - ]
[ -, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➁
[0,0]⤑ [0,3]⤑ [0,1]⤑ [1,1]⤑ [3,1]⤑
[3,4]⤑ [3,2]⤑ (MID[2,2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ -, -, -, -, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➂
[0,0]⤑ [3,0]⤑ [3,2]⤑ (MID[2,2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, -, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➃
[0,0]⤑ [3,0]⤑ [1,0]⤑ [1,3]⤑ [1,4]⤑
[1,1]⤑ [3,1]⤑ [3,4]⤑ [3,2]⤑ (MID[2,2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, 2, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➄
[0,0]⤑ [3,0]⤑ [1,0]⤑ [1,3]⤑ [1,2]⤑ [1,4]⤑
[1,1]⤑ [3,1]⤑ [3,4]⤑ [3,2]⤑ (MID[2,2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, -, 2, 1, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➅
[0,0]⤑ [3,0]⤑ [1,0]⤑ [1,3]⤑ [1,2]⤑ [3,2]⤑ (MID[2,2])
*/
task.printSolution(maze);
}
}Output
[0,0]⤑ [0,3]⤑ [0,1]⤑ [1,1]⤑ [1,3]⤑ [1,2]⤑ [3,2]⤑ (MID[2,2])
[0,0]⤑ [0,3]⤑ [0,1]⤑ [1,1]⤑ [3,1]⤑ [3,4]⤑ [3,2]⤑ (MID[2,2])
[0,0]⤑ [3,0]⤑ [3,2]⤑ (MID[2,2])
[0,0]⤑ [3,0]⤑ [1,0]⤑ [1,3]⤑ [1,4]⤑ [1,1]⤑ [3,1]⤑ [3,4]⤑ [3,2]⤑ (MID[2,2])
[0,0]⤑ [3,0]⤑ [1,0]⤑ [1,3]⤑ [1,2]⤑ [1,4]⤑ [1,1]⤑ [3,1]⤑ [3,4]⤑ [3,2]⤑ (MID[2,2])
[0,0]⤑ [3,0]⤑ [1,0]⤑ [1,3]⤑ [1,2]⤑ [3,2]⤑ (MID[2,2])package main
import "strconv"
import "fmt"
/*
Go Program for
Find paths from corner cell to middle cell in maze
*/
type Path struct {
status bool
}
func getPath() * Path {
var me *Path = &Path {}
me.status = false
return me
}
func(this Path) display(maze[][] int, n int) {
for i := 0 ; i < n ; i++ {
for j := 0 ; j < n ; j++ {
fmt.Print(" ", maze[i][j])
}
}
fmt.Print("\n")
}
func(this *Path) printPath(maze[][] int, i int, j int, mid int, result string) {
if i == mid && j == mid {
// When we get middle row and middle column
this.status = true
fmt.Println(result, "(MID[", i, "][", j, "]) ")
return
}
if maze[i][j] == 0 {
return
}
var value int = maze[i][j]
maze[i][j] = 0
if j + value < len(maze) {
// Move right
this.printPath(maze, i, j + value, mid, result + "[" +
strconv.Itoa(i) + "][" +
strconv.Itoa(j) + "]⤑ ")
}
if i + value < len(maze) {
// Move down
this.printPath(maze, i + value, j, mid, result + "[" +
strconv.Itoa(i) + "][" +
strconv.Itoa(j) + "]⤑ ")
}
if j - value > 0 {
// Move left
this.printPath(maze, i, j - value, mid, result + "[" +
strconv.Itoa(i) + "][" +
strconv.Itoa(j) + "]⤑ ")
}
if i - value > 0 {
// Move Up
this.printPath(maze, i - value, j, mid, result + "[" +
strconv.Itoa(i) + "][" +
strconv.Itoa(j) + "]⤑ ")
}
maze[i][j] = value
}
func(this Path) printSolution(maze[][] int) {
var n int = len(maze)
this.status = false
this.printPath(maze, 0, 0, n / 2, "")
if this.status == false {
// No solution
fmt.Println("\n No result ")
}
}
func main() {
var task * Path = getPath()
// Odd square matrix
var maze = [][] int {
{ 3 , 1 , 4 , 2 , 3 } ,
{ 3 , 2 , 2 , 1 , 3 } ,
{ 1 , 3 , 4 , 3 , 2 } ,
{ 2 , 3 , 1 , 1 , 2 } ,
{ 4 , 2 , 4 , 3 , 0 }}
/*
maze =
[
[ 3, 1, 4, 2, 3 ]
[ 3, 2, 2, 1, 3 ]
[ 1, 3, 4, 3, 2 ]
[ 2, 3, 1, 1, 2 ]
[ 4, 2, 4, 3, 0,]
]
------------------------
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, 2, 1, - ]
[ -, 3, 4, 3, - ]
[ -, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➀
[0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
[1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, -, -, - ]
[ -, -, 4, -, - ]
[ -, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➁
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
[3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ -, -, -, -, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➂
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, -, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➃
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, 2, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➄
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, -, 2, 1, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➅
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
*/
task.printSolution(maze)
}Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])<?php
/*
Php Program for
Find paths from corner cell to middle cell in maze
*/
class Path
{
public $status;
public function __construct()
{
$this->status = false;
}
public function display($maze, $n)
{
for ($i = 0; $i < $n; ++$i)
{
for ($j = 0; $j < $n; ++$j)
{
echo(" ".$maze[$i][$j]);
}
}
echo("\n");
}
public function printPath($maze, $i, $j, $mid, $result)
{
if ($i == $mid && $j == $mid)
{
// When we get middle row and middle column
$this->status = true;
echo($result."(MID[".$i."][".$j."]) \n");
return;
}
if ($maze[$i][$j] == 0)
{
return;
}
$value = $maze[$i][$j];
$maze[$i][$j] = 0;
if ($j + $value < count($maze))
{
// Move right
$this->printPath($maze, $i, $j + $value, $mid,
$result."[".strval($i)."][".strval($j)."]⤑ ");
}
if ($i + $value < count($maze))
{
// Move down
$this->printPath($maze, $i + $value, $j, $mid,
$result."[".strval($i)."][".strval($j)."]⤑ ");
}
if ($j - $value > 0)
{
// Move left
$this->printPath($maze, $i, $j - $value, $mid,
$result."[".strval($i)."][".strval($j)."]⤑ ");
}
if ($i - $value > 0)
{
// Move Up
$this->printPath($maze, $i - $value, $j, $mid,
$result."[".strval($i)."][".strval($j)."]⤑ ");
}
$maze[$i][$j] = $value;
}
function printSolution($maze)
{
$n = count($maze);
$this->status = false;
$this->printPath($maze, 0, 0, (int)($n / 2), "");
if ($this->status == false)
{
// No solution
echo("\n No result ".
"\n");
}
}
}
function main()
{
$task = new Path();
// Odd square matrix
$maze = array(array(3, 1, 4, 2, 3), array(3, 2, 2, 1, 3), array(1, 3, 4, 3, 2), array(2, 3, 1, 1, 2), array(4, 2, 4, 3, 0));
/*
maze =
[
[ 3, 1, 4, 2, 3 ]
[ 3, 2, 2, 1, 3 ]
[ 1, 3, 4, 3, 2 ]
[ 2, 3, 1, 1, 2 ]
[ 4, 2, 4, 3, 0,]
]
------------------------
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, 2, 1, - ]
[ -, 3, 4, 3, - ]
[ -, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➀
[0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
[1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, -, -, - ]
[ -, -, 4, -, - ]
[ -, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➁
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
[3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ -, -, -, -, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➂
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, -, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➃
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, 2, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➄
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, -, 2, 1, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➅
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
*/
$task->printSolution($maze);
}
main();Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])/*
Node JS Program for
Find paths from corner cell to middle cell in maze
*/
class Path
{
constructor()
{
this.status = false;
}
display(maze, n)
{
for (var i = 0; i < n; ++i)
{
for (var j = 0; j < n; ++j)
{
process.stdout.write(" " + maze[i][j]);
}
}
process.stdout.write("\n");
}
printPath(maze, i, j, mid, result)
{
if (i == mid && j == mid)
{
// When we get middle row and middle column
this.status = true;
console.log(result + "(MID[" + i + "][" + j + "]) ");
return;
}
if (maze[i][j] == 0)
{
return;
}
var value = maze[i][j];
maze[i][j] = 0;
if (j + value < maze.length)
{
// Move right
this.printPath(maze, i, j + value,
mid, result + "[" + i + "][" + j + "]⤑ ");
}
if (i + value < maze.length)
{
// Move down
this.printPath(maze, i + value, j,
mid, result + "[" + i + "][" + j + "]⤑ ");
}
if (j - value > 0)
{
// Move left
this.printPath(maze, i, j - value,
mid, result + "[" + i + "][" + j + "]⤑ ");
}
if (i - value > 0)
{
// Move Up
this.printPath(maze, i - value, j,
mid, result + "[" + i + "][" + j + "]⤑ ");
}
maze[i][j] = value;
}
printSolution(maze)
{
var n = maze.length;
this.status = false;
this.printPath(maze, 0, 0, parseInt(n / 2), "");
if (this.status == false)
{
// No solution
console.log("\n No result ");
}
}
}
function main()
{
var task = new Path();
// Odd square matrix
var maze = [
[3, 1, 4, 2, 3],
[3, 2, 2, 1, 3],
[1, 3, 4, 3, 2],
[2, 3, 1, 1, 2],
[4, 2, 4, 3, 0]
];
/*
maze =
[
[ 3, 1, 4, 2, 3 ]
[ 3, 2, 2, 1, 3 ]
[ 1, 3, 4, 3, 2 ]
[ 2, 3, 1, 1, 2 ]
[ 4, 2, 4, 3, 0,]
]
------------------------
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, 2, 1, - ]
[ -, 3, 4, 3, - ]
[ -, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➀
[0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
[1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, -, -, - ]
[ -, -, 4, -, - ]
[ -, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➁
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
[3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ -, -, -, -, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➂
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, -, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➃
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, 2, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➄
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, -, 2, 1, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➅
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
*/
task.printSolution(maze);
}
main();Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])# Python 3 Program for
# Find paths from corner cell to middle cell in maze
class Path :
def __init__(self) :
self.status = False
def display(self, maze, n) :
i = 0
while (i < n) :
j = 0
while (j < n) :
print(" ", maze[i][j], end = "")
j += 1
i += 1
print(end = "\n")
def printPath(self, maze, i, j, mid, result) :
if (i == mid and j == mid) :
# When we get middle row and middle column
self.status = True
print(result ,"(MID[", i ,"][", j ,"]) ")
return
if (maze[i][j] == 0) :
return
value = maze[i][j]
maze[i][j] = 0
if (j + value < len(maze)) :
# Move right
self.printPath(maze, i, j + value, mid, result + "["
+ str(i) + "]["
+ str(j) + "]⤑ ")
if (i + value < len(maze)) :
# Move down
self.printPath(maze, i + value, j, mid, result + "["
+ str(i) + "]["
+ str(j) + "]⤑ ")
if (j - value > 0) :
# Move left
self.printPath(maze, i, j - value, mid, result + "["
+ str(i) + "]["
+ str(j) + "]⤑ ")
if (i - value > 0) :
# Move Up
self.printPath(maze, i - value, j, mid, result + "["
+ str(i) + "]["
+ str(j) + "]⤑ ")
maze[i][j] = value
def printSolution(self, maze) :
n = len(maze)
self.status = False
self.printPath(maze, 0, 0, int(n / 2), "")
if (self.status == False) :
# No solution
print("\n No result ")
def main() :
task = Path()
# Odd square matrix
maze = [
[3, 1, 4, 2, 3],
[3, 2, 2, 1, 3],
[1, 3, 4, 3, 2],
[2, 3, 1, 1, 2],
[4, 2, 4, 3, 0]
]
# maze =
# [
# [ 3, 1, 4, 2, 3 ]
# [ 3, 2, 2, 1, 3 ]
# [ 1, 3, 4, 3, 2 ]
# [ 2, 3, 1, 1, 2 ]
# [ 4, 2, 4, 3, 0,]
# ]
# ------------------------
# Path =
# [
# [ 3, 1, -, 2, - ]
# [ -, 2, 2, 1, - ]
# [ -, 3, 4, 3, - ]
# [ -, -, 1, -, - ]
# [ -, -, -, -, -,]
# ]
# Solution ➀
# [0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
# [1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, 1, -, 2, - ]
# [ -, 2, -, -, - ]
# [ -, -, 4, -, - ]
# [ -, 3, 1, -, 2 ]
# [ -, -, -, -, -,]
# ]
# Solution ➁
# [0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
# [3][4]⤑ [3][2]⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, -, -, -, - ]
# [ -, -, -, -, - ]
# [ -, -, 4, -, - ]
# [ 2, -, 1, -, - ]
# [ -, -, -, -, -,]
# ]
# Solution ➂
# [0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, -, -, -, - ]
# [ 3, 2, -, 1, 3 ]
# [ -, -, 4, -, - ]
# [ 2, 3, 1, -, 2 ]
# [ -, -, -, -, -,]
# ]
# Solution ➃
# [0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
# [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, -, -, -, - ]
# [ 3, 2, 2, 1, 3 ]
# [ -, -, 4, -, - ]
# [ 2, 3, 1, -, 2 ]
# [ -, -, -, -, -,]
# ]
# Solution ➄
# [0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
# [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, -, -, -, - ]
# [ 3, -, 2, 1, - ]
# [ -, -, 4, -, - ]
# [ 2, -, 1, -, - ]
# [ -, -, -, -, -,]
# ]
# Solution ➅
# [0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
task.printSolution(maze)
if __name__ == "__main__": main()Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[ 2 ][ 2 ])# Ruby Program for
# Find paths from corner cell to middle cell in maze
class Path
# Define the accessor and reader of class Path
attr_reader :status
attr_accessor :status
def initialize()
self.status = false
end
def display(maze, n)
i = 0
while (i < n)
j = 0
while (j < n)
print(" ", maze[i][j])
j += 1
end
i += 1
end
print("\n")
end
def printPath(maze, i, j, mid, result)
if (i == mid && j == mid)
# When we get middle row and middle column
self.status = true
print(result ,"(MID[", i ,"][", j ,"]) ", "\n")
return
end
if (maze[i][j] == 0)
return
end
value = maze[i][j]
maze[i][j] = 0
if (j + value < maze.length)
# Move right
self.printPath(maze, i, j + value, mid,
result + "[" + i.to_s + "][" + j.to_s + "]⤑ ")
end
if (i + value < maze.length)
# Move down
self.printPath(maze, i + value, j, mid,
result + "[" + i.to_s + "][" + j.to_s + "]⤑ ")
end
if (j - value > 0)
# Move left
self.printPath(maze, i, j - value, mid,
result + "[" + i.to_s + "][" + j.to_s + "]⤑ ")
end
if (i - value > 0)
# Move Up
self.printPath(maze, i - value, j, mid,
result + "[" + i.to_s + "][" + j.to_s + "]⤑ ")
end
maze[i][j] = value
end
def printSolution(maze)
n = maze.length
self.status = false
self.printPath(maze, 0, 0, n / 2, "")
if (self.status == false)
# No solution
print("\n No result ", "\n")
end
end
end
def main()
task = Path.new()
# Odd square matrix
maze = [
[3, 1, 4, 2, 3],
[3, 2, 2, 1, 3],
[1, 3, 4, 3, 2],
[2, 3, 1, 1, 2],
[4, 2, 4, 3, 0]
]
# maze =
# [
# [ 3, 1, 4, 2, 3 ]
# [ 3, 2, 2, 1, 3 ]
# [ 1, 3, 4, 3, 2 ]
# [ 2, 3, 1, 1, 2 ]
# [ 4, 2, 4, 3, 0,]
# ]
# ------------------------
# Path =
# [
# [ 3, 1, -, 2, - ]
# [ -, 2, 2, 1, - ]
# [ -, 3, 4, 3, - ]
# [ -, -, 1, -, - ]
# [ -, -, -, -, -,]
# ]
# Solution ➀
# [0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
# [1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, 1, -, 2, - ]
# [ -, 2, -, -, - ]
# [ -, -, 4, -, - ]
# [ -, 3, 1, -, 2 ]
# [ -, -, -, -, -,]
# ]
# Solution ➁
# [0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
# [3][4]⤑ [3][2]⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, -, -, -, - ]
# [ -, -, -, -, - ]
# [ -, -, 4, -, - ]
# [ 2, -, 1, -, - ]
# [ -, -, -, -, -,]
# ]
# Solution ➂
# [0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, -, -, -, - ]
# [ 3, 2, -, 1, 3 ]
# [ -, -, 4, -, - ]
# [ 2, 3, 1, -, 2 ]
# [ -, -, -, -, -,]
# ]
# Solution ➃
# [0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
# [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, -, -, -, - ]
# [ 3, 2, 2, 1, 3 ]
# [ -, -, 4, -, - ]
# [ 2, 3, 1, -, 2 ]
# [ -, -, -, -, -,]
# ]
# Solution ➄
# [0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
# [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# Path =
# [
# [ 3, -, -, -, - ]
# [ 3, -, 2, 1, - ]
# [ -, -, 4, -, - ]
# [ 2, -, 1, -, - ]
# [ -, -, -, -, -,]
# ]
# Solution ➅
# [0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
task.printSolution(maze)
end
main()Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
/*
Scala Program for
Find paths from corner cell to middle cell in maze
*/
class Path(var status: Boolean)
{
def this()
{
this(true);
}
def display(maze: Array[Array[Int]], n: Int): Unit = {
var i: Int = 0;
while (i < n)
{
var j: Int = 0;
while (j < n)
{
print(" " + maze(i)(j));
j += 1;
}
i += 1;
}
print("\n");
}
def printPath(maze: Array[Array[Int]],
i: Int, j: Int, mid: Int, result: String): Unit = {
if (i == mid && j == mid)
{
// When we get middle row and middle column
this.status = true;
println(result + "(MID[" + i + "][" + j + "]) ");
return;
}
if (maze(i)(j) == 0)
{
return;
}
var value: Int = maze(i)(j);
maze(i)(j) = 0;
if (j + value < maze.length)
{
// Move right
printPath(maze, i, j + value, mid,
result + "[" + i.toString() + "][" + j.toString() + "]⤑ ");
}
if (i + value < maze.length)
{
// Move down
printPath(maze, i + value, j, mid,
result + "[" + i.toString() + "][" + j.toString() + "]⤑ ");
}
if (j - value > 0)
{
// Move left
printPath(maze, i, j - value, mid,
result + "[" + i.toString() + "][" + j.toString() + "]⤑ ");
}
if (i - value > 0)
{
// Move Up
printPath(maze, i - value, j, mid,
result + "[" + i.toString() + "][" + j.toString() + "]⤑ ");
}
maze(i)(j) = value;
}
def printSolution(maze: Array[Array[Int]]): Unit = {
var n: Int = maze.length;
this.status = false;
printPath(maze, 0, 0, n / 2, "");
if (this.status == false)
{
// No solution
println("\n No result ");
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Path = new Path();
// Odd square matrix
var maze: Array[Array[Int]] = Array(
Array(3, 1, 4, 2, 3),
Array(3, 2, 2, 1, 3),
Array(1, 3, 4, 3, 2),
Array(2, 3, 1, 1, 2),
Array(4, 2, 4, 3, 0)
);
/*
maze =
[
[ 3, 1, 4, 2, 3 ]
[ 3, 2, 2, 1, 3 ]
[ 1, 3, 4, 3, 2 ]
[ 2, 3, 1, 1, 2 ]
[ 4, 2, 4, 3, 0,]
]
------------------------
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, 2, 1, - ]
[ -, 3, 4, 3, - ]
[ -, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➀
[0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
[1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, -, -, - ]
[ -, -, 4, -, - ]
[ -, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➁
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
[3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ -, -, -, -, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➂
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, -, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➃
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, 2, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➄
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, -, 2, 1, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➅
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
*/
task.printSolution(maze);
}
}Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])import Foundation;
/*
Swift 4 Program for
Find paths from corner cell to middle cell in maze
*/
class Path
{
var status: Bool;
init()
{
self.status = false;
}
func display(_ maze: [[Int]], _ n: Int)
{
var i: Int = 0;
while (i < n)
{
var j: Int = 0;
while (j < n)
{
print(" ", maze[i][j], terminator: "");
j += 1;
}
i += 1;
}
print(terminator: "\n");
}
func printPath(_ maze: inout[[Int]],
_ i: Int, _ j: Int, _ mid: Int, _ result: String)
{
if (i == mid && j == mid)
{
// When we get middle row and middle column
self.status = true;
print(result ,"(MID[", i ,"][", j ,"]) ",separator:"");
return;
}
if (maze[i][j] == 0)
{
return;
}
let value: Int = maze[i][j];
maze[i][j] = 0;
if (j + value < maze.count)
{
// Move right
self.printPath(&maze, i, j + value, mid,
result + "["
+ String(i) + "]["
+ String(j) + "]⤑ ");
}
if (i + value < maze.count)
{
// Move down
self.printPath(&maze, i + value, j, mid,
result + "["
+ String(i) + "]["
+ String(j) + "]⤑ ");
}
if (j - value > 0)
{
// Move left
self.printPath(&maze, i, j - value, mid,
result + "["
+ String(i) + "]["
+ String(j) + "]⤑ ");
}
if (i - value > 0)
{
// Move Up
self.printPath(&maze, i - value, j, mid,
result + "["
+ String(i) + "]["
+ String(j) + "]⤑ ");
}
maze[i][j] = value;
}
func printSolution(_ maze: inout[[Int]])
{
let n: Int = maze.count;
self.status = false;
self.printPath(&maze, 0, 0, n / 2, "");
if (self.status == false)
{
// No solution
print("\n No result ");
}
}
}
func main()
{
let task: Path = Path();
// Odd square matrix
var maze: [
[Int]
] = [
[3, 1, 4, 2, 3],
[3, 2, 2, 1, 3],
[1, 3, 4, 3, 2],
[2, 3, 1, 1, 2],
[4, 2, 4, 3, 0]
];
/*
maze =
[
[ 3, 1, 4, 2, 3 ]
[ 3, 2, 2, 1, 3 ]
[ 1, 3, 4, 3, 2 ]
[ 2, 3, 1, 1, 2 ]
[ 4, 2, 4, 3, 0,]
]
------------------------
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, 2, 1, - ]
[ -, 3, 4, 3, - ]
[ -, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➀
[0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
[1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, -, -, - ]
[ -, -, 4, -, - ]
[ -, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➁
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
[3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ -, -, -, -, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➂
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, -, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➃
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, 2, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➄
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, -, 2, 1, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➅
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
*/
task.printSolution(&maze);
}
main();Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])/*
Kotlin Program for
Find paths from corner cell to middle cell in maze
*/
class Path
{
var status: Boolean;
constructor()
{
this.status = false;
}
fun display(maze: Array < Array < Int >> , n: Int): Unit
{
var i: Int = 0;
while (i < n)
{
var j: Int = 0;
while (j < n)
{
print(" " + maze[i][j]);
j += 1;
}
i += 1;
}
print("\n");
}
fun printPath(maze: Array < Array < Int >> ,
i: Int, j: Int, mid: Int, result: String): Unit
{
if (i == mid && j == mid)
{
// When we get middle row and middle column
this.status = true;
println(result + "(MID[" + i + "][" + j + "]) ");
return;
}
if (maze[i][j] == 0)
{
return;
}
val value: Int = maze[i][j];
maze[i][j] = 0;
if (j + value < maze.count())
{
// Move right
this.printPath(maze, i, j + value,
mid, result + "[" + i.toString() + "][" + j.toString() + "]⤑ ");
}
if (i + value < maze.count())
{
// Move down
this.printPath(maze, i + value, j,
mid, result + "[" + i.toString() + "][" + j.toString() + "]⤑ ");
}
if (j - value > 0)
{
// Move left
this.printPath(maze, i, j - value,
mid, result + "[" + i.toString() + "][" + j.toString() + "]⤑ ");
}
if (i - value > 0)
{
// Move Up
this.printPath(maze, i - value, j,
mid, result + "[" + i.toString() + "][" + j.toString() + "]⤑ ");
}
maze[i][j] = value;
}
fun printSolution(maze: Array < Array < Int >> ): Unit
{
val n: Int = maze.count();
this.status = false;
this.printPath(maze, 0, 0, n / 2, "");
if (this.status == false)
{
// No solution
println("\n No result ");
}
}
}
fun main(args: Array < String > ): Unit
{
val task: Path = Path();
// Odd square matrix
val maze: Array < Array < Int >> = arrayOf(
arrayOf(3, 1, 4, 2, 3),
arrayOf(3, 2, 2, 1, 3),
arrayOf(1, 3, 4, 3, 2),
arrayOf(2, 3, 1, 1, 2),
arrayOf(4, 2, 4, 3, 0)
);
/*
maze =
[
[ 3, 1, 4, 2, 3 ]
[ 3, 2, 2, 1, 3 ]
[ 1, 3, 4, 3, 2 ]
[ 2, 3, 1, 1, 2 ]
[ 4, 2, 4, 3, 0,]
]
------------------------
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, 2, 1, - ]
[ -, 3, 4, 3, - ]
[ -, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➀
[0][0] ⤑ [0][3] ⤑ [0][1] ⤑ [1][1] ⤑
[1][3] ⤑ [1][2] ⤑ [3][2] ⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, 1, -, 2, - ]
[ -, 2, -, -, - ]
[ -, -, 4, -, - ]
[ -, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➁
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑
[3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ -, -, -, -, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➂
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, -, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➃
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, 2, 2, 1, 3 ]
[ -, -, 4, -, - ]
[ 2, 3, 1, -, 2 ]
[ -, -, -, -, -,]
]
Solution ➄
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑
[1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Path =
[
[ 3, -, -, -, - ]
[ 3, -, 2, 1, - ]
[ -, -, 4, -, - ]
[ 2, -, 1, -, - ]
[ -, -, -, -, -,]
]
Solution ➅
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
*/
task.printSolution(maze);
}Output
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [0][3]⤑ [0][1]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [1][4]⤑ [1][1]⤑ [3][1]⤑ [3][4]⤑ [3][2]⤑ (MID[2][2])
[0][0]⤑ [3][0]⤑ [1][0]⤑ [1][3]⤑ [1][2]⤑ [3][2]⤑ (MID[2][2])
Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.
New Comment