GeeksforGeeks App
Open App
Browser
Continue

# Reach the numbers by making jumps of two given lengths

Given integers k, d1, d2 and an integer array arr[]. Starting from number k you are allowed to make jumps of size d1 and d2 i.e. all the possible moves from k are:

• k + d1 and k – d1
• k + d2 and k – d2

The task is to find which of the numbers from the array are reachable from k making any number of jumps and any given jump is either of size d1 or d2. For every number print 1 if its reachable else print 0.

Examples:

Input: k = 10, d1 = 4, d2 = 6, arr[] = {10, 15, 20}
Output: 1 0 1
10 can be reached from k with no extra move.
20 can be reached with k + d1 + d2 = 10 + 4 + 6 = 20

Input: k = 8, d1 = 3, d2 = 2, arr[] = {9, 4}
Output: 1 1

Approach:

Any number x that is reachable from k with jumps d1 or d2 will be of the form x = k + (i * d1) + (j * d2) where i and j are integers.
Let the GCD of d1 and d2 be gcd. Since, gcd divides both d1 and d2. Therefore we can write d1 = m1 * gcd and d2 = m2 * gcd where m1 and m2 are integers
And x = k + gcd * (i * m1 + j * m2) = k + M * gcd
So, any number x that is reachable from k should satisfy (x – k) % gcd = 0.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``#include ``using` `namespace` `std;` `// Function that returns the vector containing the``// result for the reachability of the required numbers``void` `reachTheNums(``int` `nums[], ``int` `k, ``int` `d1, ``int` `d2, ``int` `n)``{``    ``int` `i, ans[n] = { 0 };``    ``int` `gcd = __gcd(d1, d2);` `    ``for` `(i = 0; i < n; i++) {``        ``int` `x = nums[i] - k;` `        ``// If distance x is coverable``        ``if` `(x % gcd == 0)``            ``ans[i] = 1;``        ``else``            ``ans[i] = 0;``    ``}` `    ``for` `(i = 0; i < n; i++)``        ``cout << ans[i] << ``" "``;``}` `// Driver code``int` `main()``{``    ``// Numbers to be checked for reachability``    ``int` `nums[] = { 9, 4 };``    ``int` `n = ``sizeof``(nums) / ``sizeof``(nums[0]);``    ``// Starting number K``    ``int` `k = 8;` `    ``// Sizes of jumps d1 and d2``    ``int` `d1 = 3, d2 = 2;` `    ``reachTheNums(nums, k, d1, d2, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach` `import` `java.io.*;``class` `GFG {``// Recursive function to return gcd of a and b``    ``static` `int` `__gcd(``int` `a, ``int` `b)``    ``{``        ``// Everything divides 0 ``        ``if` `(a == ``0``)``          ``return` `b;``        ``if` `(b == ``0``)``          ``return` `a;``       ` `        ``// base case``        ``if` `(a == b)``            ``return` `a;``       ` `        ``// a is greater``        ``if` `(a > b)``            ``return` `__gcd(a-b, b);``        ``return` `__gcd(a, b-a);``    ``}`  `    `  `// Function that returns the vector containing the``// result for the reachability of the required numbers``static` `void` `reachTheNums(``int` `nums[], ``int` `k, ``int` `d1, ``int` `d2, ``int` `n)``{``    ``int` `i;``    ``int` `ans[] = ``new` `int``[n];``    ``int` `gcd = __gcd(d1, d2);` `    ``for` `(i = ``0``; i < n; i++) {``        ``int` `x = nums[i] - k;` `        ``// If distance x is coverable``        ``if` `(x % gcd == ``0``)``            ``ans[i] = ``1``;``        ``else``            ``ans[i] = ``0``;``    ``}` `    ``for` `(i = ``0``; i < n; i++)``        ``System.out.print(ans[i] + ``" "``);``}` `// Driver code`  `    ``public` `static` `void` `main (String[] args) {``        ``// Numbers to be checked for reachability``    ``int` `nums[] = { ``9``, ``4` `};``    ``int` `n =nums.length;``    ``// Starting number K``    ``int` `k = ``8``;` `    ``// Sizes of jumps d1 and d2``    ``int` `d1 = ``3``, d2 = ``2``;` `    ``reachTheNums(nums, k, d1, d2, n);``    ``}``}` `// This code is contributed by inder_verma..`

## Python3

 `# Python3 implementation of the approach``import` `math as mt` `# Function that returns the vector``# containing the result for the reachability``# of the required numbers``def` `reachTheNums(nums, k, d1, d2, n):` `    ``ans ``=` `[``0` `for` `i ``in` `range``(n)]` `    ``gcd ``=` `mt.gcd(d1, d2)` `    ``for` `i ``in` `range``(n):``        ``x ``=` `nums[i] ``-` `k` `        ``# If distance x is coverable``        ``if` `(x ``%` `gcd ``=``=` `0``):``            ``ans[i] ``=` `1``        ``else``:``            ``ans[i] ``=` `0` `    ``for` `i ``in` `range``(n):``        ``print``(ans[i], end ``=` `" "``)` `# Driver code` `# Numbers to be checked for``# reachability``nums ``=` `[``9``, ``4``]``n ``=` `len``(nums)` `# Starting number K``k ``=` `8` `# Sizes of jumps d1 and d2``d1, d2 ``=` `3``, ``2` `reachTheNums(nums, k, d1, d2, n)` `# This code is contributed``# by mohit kumar 29`

## C#

 `// C# implementation of the above approach` `using` `System ;` `class` `GFG {``    ` `    ``// Recursive function to return gcd of a and b``    ``static` `int` `__gcd(``int` `a, ``int` `b)``    ``{``        ``// Everything divides 0``        ``if` `(a == 0)``        ``return` `b;``        ``if` `(b == 0)``        ``return` `a;``        ` `        ``// base case``        ``if` `(a == b)``            ``return` `a;``        ` `        ``// a is greater``        ``if` `(a > b)``            ``return` `__gcd(a-b, b);``            ` `        ``return` `__gcd(a, b-a);``    ``}`  `    `  `    ``// Function that returns the vector containing the``    ``// result for the reachability of the required numbers``    ``static` `void` `reachTheNums(``int` `[]nums, ``int` `k, ``int` `d1, ``int` `d2, ``int` `n)``    ``{``        ``int` `i;``        ``int` `[]ans = ``new` `int``[n];``        ``int` `gcd = __gcd(d1, d2);``    ` `        ``for` `(i = 0; i < n; i++) {``            ``int` `x = nums[i] - k;``    ` `            ``// If distance x is coverable``            ``if` `(x % gcd == 0)``                ``ans[i] = 1;``            ``else``                ``ans[i] = 0;``        ``}``    ` `        ``for` `(i = 0; i < n; i++)``            ``Console.Write(ans[i] + ``" "``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main () {``        ``// Numbers to be checked for reachability``    ``int` `[]nums = { 9, 4 };``    ``int` `n =nums.Length;``    ``// Starting number K``    ``int` `k = 8;` `    ``// Sizes of jumps d1 and d2``    ``int` `d1 = 3, d2 = 2;` `    ``reachTheNums(nums, k, d1, d2, n);``    ``}``    ``// This code is contributed by Ryuga``}`

## PHP

 ``

## Javascript

 ``

Output

`1 1 `

Complexity Analysis:

• Time Complexity: O(N), since there runs a loop from 0 to (n – 1).
• Auxiliary Space: O(N), since N extra space has been taken.

My Personal Notes arrow_drop_up