Reaching a point using clockwise or anticlockwise movements

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
  
// fucntion 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 setps 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 setps 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# python program to determine 
# if starting from the starting
# position we can reach the end 
# position in N moves moving  
# any direction
  
# fucntion 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 setps 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.

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 setps 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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to determine 
// if starting from the 
// starting position we can
// reach the end position in
// N moves moving about 
// any direction
  
// fucntion 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 setps 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.
?>

chevron_right



Output :

Clockwise


My Personal Notes arrow_drop_up

Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Sam007, jit_t