# Check if a given value can be reached from another value in a Circular Queue by K-length jumps

Given integers **N**, **K**, **A**, and **B**, check if it is possible to reach **B** from **A **in a circular queue of integers from **1** to **N **placed sequentially, by jumps of **K** length. In each move, If it is possible, then print **“Yes”**. Otherwise, print **“No”**.

**Examples:**

Input:N = 5, A = 2, B = 1, K = 2Output:YesExplanation:2 -> 4 -> 1. Therefore, it is possible to reach B from A.

Input:N = 9, A = 6, B = 5, K = 3Output:No

**Approach:** The idea to solve the problem is based on the following observations:

- For position
**A**, and after**t steps**, the position of**A**is**(A + K*t)%N**. - For position
**B**, and after**t steps**, the position of**B**is**(A + K*t)%N**. - It can be written as:

(A + K*t) = (N*q + B), where q is any positive integer

(A – B) = N*q – K*t

On observing the above equation **(N*q – K*t)** is divisible by GCD of **N** and **K**. Therefore, **(A – B)** is also divisible by GCD of **N** and **K**. Therefore, to reach **B** from **A**, **(A – B)** must be divisible by **GCD(N, K)**.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return GCD of two` `// numbers a and b` `int` `GCD(` `int` `a, ` `int` `b)` `{` ` ` `// Base Case` ` ` `if` `(b == 0)` ` ` `return` `a;` ` ` `// Recursively Find the GCD` ` ` `return` `GCD(b, a % b);` `}` `// Function to check of B can be reached` `// from A with a jump of K elements in` `// the circular queue` `void` `canReach(` `int` `N, ` `int` `A, ` `int` `B, ` `int` `K)` `{` ` ` `// Find GCD of N and K` ` ` `int` `gcd = GCD(N, K);` ` ` `// If A - B is divisible by gcd` ` ` `// then print Yes` ` ` `if` `(` `abs` `(A - B) % gcd == 0) {` ` ` `cout << ` `"Yes"` `;` ` ` `}` ` ` `// Otherwise` ` ` `else` `{` ` ` `cout << ` `"No"` `;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 5, A = 2, B = 1, K = 2;` ` ` `// Function Call` ` ` `canReach(N, A, B, K);` ` ` `return` `0;` `}` |

## Java

`// Java program for the` `// above approach` `import` `java.util.*;` `class` `solution{` `// Function to return GCD` `// of two numbers a and b` `static` `int` `GCD(` `int` `a, ` `int` `b)` `{` ` ` `// Base Case` ` ` `if` `(b == ` `0` `)` ` ` `return` `a;` ` ` `// Recursively Find` ` ` `// the GCD` ` ` `return` `GCD(b, a % b);` `}` `// Function to check of B can` `// be reached from A with a jump` `// of K elements in the circular` `// queue` `static` `void` `canReach(` `int` `N, ` `int` `A,` ` ` `int` `B, ` `int` `K)` `{` ` ` `// Find GCD of N and K` ` ` `int` `gcd = GCD(N, K);` ` ` `// If A - B is divisible` ` ` `// by gcd then print Yes` ` ` `if` `(Math.abs(A - B) %` ` ` `gcd == ` `0` `)` ` ` `{` ` ` `System.out.println(` `"Yes"` `);` ` ` `}` ` ` `// Otherwise` ` ` `else` ` ` `{` ` ` `System.out.println(` `"No"` `);` ` ` `}` `}` `// Driver Code` `public` `static` `void` `main(String args[])` `{` ` ` `int` `N = ` `5` `, A = ` `2` `,` ` ` `B = ` `1` `, K = ` `2` `;` ` ` `// Function Call` ` ` `canReach(N, A, B, K);` `}` `}` `// This code is contributed by SURENDRA_GANGWAR` |

## Python3

`# Python3 program for the` `# above approach` `# Function to return GCD` `# of two numbers a and b` `def` `GCD(a, b):` ` ` ` ` `# Base Case` ` ` `if` `(b ` `=` `=` `0` `):` ` ` `return` `a` ` ` `# Recursively Find` ` ` `# the GCD` ` ` `return` `GCD(b, a ` `%` `b)` `# Function to check of B` `# can be reached from A` `# with a jump of K elements` `# in the circular queue` `def` `canReach(N, A, B, K):` ` ` `# Find GCD of N and K` ` ` `gcd ` `=` `GCD(N, K)` ` ` `# If A - B is divisible` ` ` `# by gcd then prYes` ` ` `if` `(` `abs` `(A ` `-` `B) ` `%` ` ` `gcd ` `=` `=` `0` `):` ` ` `print` `(` `"Yes"` `)` ` ` ` ` `# Otherwise ` ` ` `else` `:` ` ` `print` `(` `"No"` `)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `N ` `=` `5` ` ` `A ` `=` `2` ` ` `B ` `=` `1` ` ` `K ` `=` `2` ` ` `# Function Call` ` ` `canReach(N, A, B, K)` `# This code is contributed by Mohit Kumar 29` |

## C#

`// C# program for the` `// above approach` `using` `System;` `class` `GFG{` ` ` `// Function to return GCD` `// of two numbers a and b` `static` `int` `GCD(` `int` `a, ` `int` `b)` `{` ` ` ` ` `// Base Case` ` ` `if` `(b == 0)` ` ` `return` `a;` ` ` ` ` `// Recursively Find` ` ` `// the GCD` ` ` `return` `GCD(b, a % b);` `}` ` ` `// Function to check of B can` `// be reached from A with a jump` `// of K elements in the circular` `// queue` `static` `void` `canReach(` `int` `N, ` `int` `A,` ` ` `int` `B, ` `int` `K)` `{` ` ` ` ` `// Find GCD of N and K` ` ` `int` `gcd = GCD(N, K);` ` ` ` ` `// If A - B is divisible` ` ` `// by gcd then print Yes` ` ` `if` `(Math.Abs(A - B) % gcd == 0)` ` ` `{` ` ` `Console.WriteLine(` `"Yes"` `);` ` ` `}` ` ` ` ` `// Otherwise` ` ` `else` ` ` `{` ` ` `Console.WriteLine(` `"No"` `);` ` ` `}` `}` ` ` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `int` `N = 5, A = 2,` ` ` `B = 1, K = 2;` ` ` ` ` `// Function Call` ` ` `canReach(N, A, B, K);` `}` `}` `// This code is contributed by code_hunt` |

## Javascript

`<script>` `// JavaScript program for the above approach` `// Function to return GCD of two` `// numbers a and b` `function` `GCD(a, b)` `{` ` ` `// Base Case` ` ` `if` `(b == 0)` ` ` `return` `a;` ` ` `// Recursively Find the GCD` ` ` `return` `GCD(b, a % b);` `}` `// Function to check of B can be reached` `// from A with a jump of K elements in` `// the circular queue` `function` `canReach(N, A, B, K)` `{` ` ` `// Find GCD of N and K` ` ` `var` `gcd = GCD(N, K);` ` ` `// If A - B is divisible by gcd` ` ` `// then print Yes` ` ` `if` `(Math.abs(A - B) % gcd == 0) {` ` ` `document.write( ` `"Yes"` `);` ` ` `}` ` ` `// Otherwise` ` ` `else` `{` ` ` `document.write( ` `"No"` `);` ` ` `}` `}` `// Driver Code` `var` `N = 5, A = 2, B = 1, K = 2;` `// Function Call` `canReach(N, A, B, K);` `</script>` |

**Output:**

Yes

**Time Complexity:** *O(log(min(N, K))***Auxiliary Space:** *O(1)*