Skip to content
Related Articles

Related Articles

Final direction after visiting every cell of Matrix starting from (0, 0)

Improve Article
Save Article
  • Last Updated : 05 Apr, 2021
Improve Article
Save Article

Given a 2D grid of size N x M. The task is to find the final direction after visiting every cell under given conditions. 
 

  • You can start only from the top left corner of the N*M grid and facing towards the right.
  • You can walk one square at a time in the direction you are facing.
  • If you reach the boundary of the grid or if the next square you are about to visit has already been visited, you turn right.

Examples: 
 

Input: N = 3, M = 3 
Output: Right 
Explanation: Below is the final position after traversing the grid 
 

Input: N = 3, M = 1 
Output: Down 
 

 

Approach: For the above problem statement we have to observe the following: 
 

  • The path formed will always be a Spiral path. So, we can say that any of the middle cells will be the final cell and we need to find the direction of that cell.
  • If n > m, then the final direction could only be Up or Down depending on the value of m because there always be some cell left in the last uncovered column when all other columns are covered.
  • If n <= m, then the final direction could only be Left or Right depending on the value of n.

Therefore on the basis of above observations, there can be only 4 cases for 4 directions: 
 

  1. If n > m and m is even, final direction will be Up.
  2. If n > m and m is odd, final direction will be Down.
  3. If n <= m and n is even, final direction will be Left.
  4. If n <= m and n is odd, final direction will be Right.

Below is the implementation of the above approach:
 

C++




// C++ program to find the direction
// when stopped moving
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the direction
// when stopped moving
void findDirection(int n, int m)
{
    if (n > m) {
        if (m % 2 == 0)
            printf("Up\n");
        else
            printf("Down\n");
    }
    else {
        if (n % 2 == 0)
            printf("Left\n");
        else
            printf("Right\n");
    }
}
 
// Driver Code
int main()
{
    // Given size of NxM grid
    int n = 3, m = 3;
 
    // Function Call
    findDirection(n, m);
    return 0;
}

Java




// Java program to find the direction
// when stopped moving
class GFG{
 
// Function to find the direction
// when stopped moving
static void findDirection(int n, int m)
{
    if (n > m)
    {
        if (m % 2 == 0)
            System.out.print("Up\n");
        else
            System.out.print("Down\n");
    }
    else
    {
        if (n % 2 == 0)
            System.out.print("Left\n");
        else
            System.out.print("Right\n");
    }
}
 
// Driver code
public static void main(String[] args)
{
     
    // Given size of NxM grid
    int n = 3, m = 3;
 
    // Function Call
    findDirection(n, m);
}
}
 
// This code is contributed by shubham

Python3




# Python3 program to find the direction
# when stopped moving
 
# Function to find the direction
# when stopped moving
def findDirection(n, m):
 
    if (n > m):
        if (m % 2 == 0):
            print("Up\n");
        else:
            print("Down\n");
     
    else:
        if (n % 2 == 0):
            print("Left\n");
        else:
            print("Right\n");
     
# Driver Code
 
# Given size of NxM grid
n = 3; m = 3;
 
# Function Call
findDirection(n, m);
 
# This code is contributed by Code_Mech

C#




// C# program to find the direction
// when stopped moving
using System;
class GFG{
 
// Function to find the direction
// when stopped moving
static void findDirection(int n, int m)
{
    if (n > m)
    {
        if (m % 2 == 0)
            Console.Write("Up\n");
        else
            Console.Write("Down\n");
    }
    else
    {
        if (n % 2 == 0)
            Console.Write("Left\n");
        else
            Console.Write("Right\n");
    }
}
 
// Driver code
public static void Main()
{
     
    // Given size of NxM grid
    int n = 3, m = 3;
 
    // Function Call
    findDirection(n, m);
}
}
 
// This code is contributed by Code_Mech

Javascript




<script>
// Javascript program to find the direction
// when stopped moving
 
// Function to find the direction
// when stopped moving
function findDirection(n, m)
{
    if (n > m) {
        if (m % 2 == 0)
            document.write("Up<br>");
        else
            document.write("Down<br>");
    }
    else {
        if (n % 2 == 0)
            document.write("Left<br>");
        else
            document.write("Right<br>");
    }
}
 
// Driver Code
// Given size of NxM grid
let n = 3, m = 3;
 
// Function Call
findDirection(n, m);
 
// This code is contributed by rishavmahato348.
</script>

Output: 

Right

 

Time Complexity: O(1) 
Auxiliary Space: O(1)
 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!