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: 
 

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

# 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# 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 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.
?>

<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

 Time Complexity: O(1), as we are not using any loop or recursion to traverse.

Auxiliary Space: O(1), as we are not using any extra space.