Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Reaching a point using clockwise or anticlockwise movements

  • Last Updated : 06 Sep, 2021

Given starting and ending position and a number N. Given that we are allowed to move in only four directions as shown in the image below. The directions of moves are U(\uparrow   ), R\rightarrow   , D\downarrow   and L\leftarrow   . We need to write a program to determine if starting from the given starting position we can reach the given end position in exactly N moves in moving about any direction(Clockwise or Anticlockwise). 
 

Examples : 
 

Input: start = U , end = L , N = 3 
Output: Clockwise 
Explanation: Step 1: move clockwise to reach R
             Step 2: move clockwise to reach D
             Step 3: move clockwise to reach L 
So we reach from U to L in 3 steps moving in 
clockwise direction.

Input: start = R , end = L , N = 3
Output: Not possible 
Explanation: It is not possible to start from 
R and end at L in 3 steps moving about in any 
direction. 

Input: start = D , end = R , N = 7 
Output: Clockwise
Explanation: Starting at D, we complete one 
complete clockwise round in 4 steps to reach D 
again, then it takes 3 step to reach R 

 

The idea to solve this problem is to observe that we can complete one round in 4 steps by traveling in any direction (clockwise or anti-clockwise), so taking n%4 steps is equivalent to taking n steps from the starting point. Therefore n is reduced to n%4. Consider the values of ‘U’ as 0, ‘R’ as 1, ‘D’ as 2 and ‘L’ as 3. If the abs(value(a)-value(b)) is 2 and n is also 2, then we can move either in clockwise or anticlockwise direction to reach the end position from the start position. If moving k steps in clockwise direction take us to the end position from start position then we can say that the condition for clockwise move will be (value(a)+k)%4==value(b). Similarly, the condition for anticlockwise move will be (value(a)+k*3)%4==value(b) since taking k step from position a in clockwise direction is equivalent to taking (a + k*3)%4 steps in anticlockwise direction. 
Below is the implementation of the above approach: 
 

C++




// CPP program to determine if
// starting from the starting
// position we can reach the 
// end position in N moves
// moving about any direction
#include <bits/stdc++.h>
using namespace std;
 
// function that returns mark
// up value of directions
int value(char a)
{
    if (a == 'U')
        return 0;
    if (a == 'R')
        return 1;
    if (a == 'D')
        return 2;
    if (a == 'L')
        return 3;
}
 
// function to print
// the possible move
void printMove(char a, char b, int n)
{
    // mod with 4 as completing
    // 4 steps means completing
    // one single round
    n = n % 4;
 
    // when n is 2 and the
    // difference between moves is 2
    if (n == 2 and abs(value(a) -
                       value(b)) == 2)
        cout << "Clockwise or Anticlockwise";
 
    // anticlockwise condition
    else if ((value(a) + n * 3) % 4 == value(b))
        cout << "Anticlockwise";
 
    // clockwise condition
    else if ((value(a) + n) % 4 == value(b))
        cout << "Clockwise";
    else
        cout << "Not Possible";
}
 
// Driver Code
int main()
{
    char a = 'D', b = 'R';
    int n = 7;
    printMove(a, b, n);
 
    return 0;
}

Java




// Java program to determine if
// starting from the starting
// position we can reach the
// end position in N moves
// moving about any direction
class GFG
{
    // function that returns mark
    // up value of directions
    static int value(char a)
    {
        if (a == 'U')
            return 0;
        if (a == 'R')
            return 1;
        if (a == 'D')
            return 2;
        if (a == 'L')
            return 3;
             
            return -1;
    }
 
    // function to print
    // the possible move
    static void printMove(char a,
                          char b,
                          int n)
    {
        // mod with 4 as completing
        // 4 steps means completing
        // one single round
        n = n % 4;
     
        // when n is 2 and
        // the difference
        // between moves is 2
        if (n == 2 && Math.abs(value(a) -
                               value(b)) == 2)
            System.out.println("Clockwise " +
                        " or Anticlockwise");
     
        // anticlockwise condition
        else if ((value(a) + n * 3) %
                       4 == value(b))
            System.out.println("Anticlockwise");
     
        // clockwise condition
        else if ((value(a) + n) % 4 == value(b))
            System.out.println("Clockwise");
        else
            System.out.println("Not Possible");
    }
 
    // Driver Code
    public static void main(String args[])
    {
        char a = 'D', b = 'R';
        int n = 7;
        printMove(a, b, n);
    }
}
 
// This code is contributed by Sam007

Python3




# python program to determine
# if starting from the starting
# position we can reach the end
# position in N moves moving 
# any direction
 
# function that returns mark
# up value of directions
def value(a):
     
    if (a == 'U'):
        return 0
    if (a == 'R'):
        return 1
    if (a == 'D'):
        return 2
    if (a == 'L'):
        return 3
 
# function to print
# the possible move
def printMove(a, b, n):
     
    # mod with 4 as completing
    # 4 steps means completing
    # one single round
    n = n % 4;
 
    # when n is 2 and
    # the difference
    # between moves is 2
    if (n == 2 and
        abs(value(a) - value(b)) == 2):
        print ("Clockwise or Anticlockwise")
 
    # anticlockwise condition
    elif ((value(a) + n * 3) % 4 == value(b)):
        print ("Anticlockwise")
 
    # clockwise condition
    elif ((value(a) + n) % 4 == value(b)):
        print ("Clockwise")
    else:
        print ("Not Possible")
 
 
# Driver Code
a = 'D'
b = 'R'
n = 7
printMove(a, b, n)
 
# This code is contributed by Sam007.

C#




// C# program to determine
// if starting from the
// starting position we
// can reach the end position
// in N moves moving about
// any direction
using System;
 
class GFG
{
    // function that returns mark
    // up value of directions
    static int value(char a)
    {
        if (a == 'U')
            return 0;
        if (a == 'R')
            return 1;
        if (a == 'D')
            return 2;
        if (a == 'L')
            return 3;
         
            return -1;
    }
 
    // function to print
    // the possible move
    static void printMove(char a,
                          char b,
                          int n)
    {
        // mod with 4 as completing
        // 4 steps means completing
        // one single round
        n = n % 4;
     
        // when n is 2 and
        // the difference
        // between moves is 2
        if (n == 2 && Math.Abs(value(a) -
                               value(b)) == 2)
            Console.Write("Clockwise " +
                    "or Anticlockwise");
     
        // anticlockwise condition
        else if ((value(a) + n * 3) %
                        4 == value(b))
            Console.Write("Anticlockwise");
     
        // clockwise condition
        else if ((value(a) + n) %
                    4 == value(b))
            Console.WriteLine("Clockwise");
        else
            Console.WriteLine("Not Possible");
    }
 
    // Driver Code
    public static void Main()
    {
    char a = 'D', b = 'R';
    int n = 7;
    printMove(a, b, n);
    }
}
 
// This code is contributed by Sam007

PHP




<?php
// PHP program to determine
// if starting from the
// starting position we can
// reach the end position in
// N moves moving about
// any direction
 
// function that returns mark
// up value of directions
 
function value($a)
{
    if ($a == 'U')
        return 0;
    if ($a == 'R')
        return 1;
    if ($a == 'D')
        return 2;
    if ($a == 'L')
        return 3;
}
 
// function to print
// the possible move
function printMove($a, $b,$n)
{
    // mod with 4 as completing
    // 4 steps means completing
    // one single round
    $n = $n % 4;
 
    // when n is 2 and the
    // difference between
    // moves is 2
    if ($n == 2 and abs(value($a) -
                        value($b)) == 2)
        echo "Clockwise or Anticlockwise";
 
    // anticlockwise condition
    else if ((value($a) + $n * 3) %
                    4 == value($b))
        echo "Anticlockwise";
 
    // clockwise condition
    else if ((value($a) + $n) %
                4 == value($b))
        echo "Clockwise";
    else
        echo "Not Possible";
}
 
// Driver Code
$a = 'D'; $b = 'R';
$n = 7;
printMove($a, $b, $n);
 
// This code is contributed ajit.
?>

Javascript




<script>
 
// JavaScript program to determine if
// starting from the starting
// position we can reach the
// end position in N moves
// moving about any direction
 
    // function that returns mark
    // up value of directions
    function value(a)
    {
        if (a == 'U')
            return 0;
        if (a == 'R')
            return 1;
        if (a == 'D')
            return 2;
        if (a == 'L')
            return 3;
               
            return -1;
    }
   
    // function to print
    // the possible move
    function printMove(a, b, n)
    {
        // mod with 4 as completing
        // 4 steps means completing
        // one single round
        n = n % 4;
       
        // when n is 2 and
        // the difference
        // between moves is 2
        if (n == 2 && Math.abs(value(a) -
                               value(b)) == 2)
            document.write("Clockwise " +
                        " or Anticlockwise");
       
        // anticlockwise condition
        else if ((value(a) + n * 3) %
                       4 == value(b))
            document.write("Anticlockwise");
       
        // clockwise condition
        else if ((value(a) + n) % 4 == value(b))
            document.write("Clockwise");
        else
            document.write("Not Possible");
    }
   
 
// Driver code
     
        let a = 'D', b = 'R';
        let n = 7;
        printMove(a, b, n);
     
    // This code is contributed by code_hunt.
</script>

Output : 
 

Clockwise

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!