Related Articles

# Minimum number of given moves required to reach (1, 1) from (X, Y)

• Last Updated : 11 May, 2021

Given two integers X and Y, the task is to count the minimum number of moves required to reach the point (1, 1), starting from the point (1, 1), if the allowed moves from any point, say (a, b) are either (a – b, b) or (a, b – a).

Examples:

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.

Input: X = 3, Y = 1
Output: 2
Explanation: Required sequence of moves are (3, 1) → (2, 1) → (1, 1)

Input: X = 2, Y = 2
Output: -1

Naive Approach: The simplest approach to solve the problem is to keep subtracting the smaller number from the greater number, until they become equal. If at any instant, either X or Y becomes less than 1, print -1. Otherwise, print the number of subtractions performed as the minimum number of operations required.

Time Complexity: O(max(X, Y))
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to replace the repetitive subtractions by modulo operation, which is similar to calculating GCD using the Euclidean algorithm. Follow the steps below to solve the problem:

• Initialize a variable, say cnt with 0, for storing the minimum number of steps.
• Iterate while X and Y are both non-zero and perform the following operations:
• If the value of X > Y, then add X/Y to cnt. Update X to X%Y
• If the value of Y > X, then add Y/X to cnt. Update Y to Y%X
• Check if one of them is greater than 1, then print -1.
• Otherwise, decrease the value of cnt by 1, because one extra step is taken to make one of them equal to 0.
• Print the value of cnt as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count the number of steps``// required to convert (x, y) to (1, 1)``int` `minimumSteps(``int` `x, ``int` `y)``{``    ``// Store the required result``    ``int` `cnt = 0;` `    ``// Iterate while both x``    ``// and y are not equal to 0``    ``while` `(x != 0 && y != 0) {` `        ``// If x is greater than y``        ``if` `(x > y) {` `            ``// Update count and value of x``            ``cnt += x / y;``            ``x %= y;``        ``}` `        ``// Otherwise``        ``else` `{` `            ``// Update count and value of y``            ``cnt += y / x;``            ``y %= x;``        ``}``    ``}``    ``cnt--;` `    ``// If both x and y > 1``    ``if` `(x > 1 || y > 1)``        ``cnt = -1;` `    ``// Print the result``    ``cout << cnt;``}` `// Driver Code``int` `main()``{``    ``// Given X and Y``    ``int` `x = 3, y = 1;``    ``minimumSteps(x, y);` `    ``return` `0;``}`

## Java

 `// Java program for above approach``import` `java.util.*;` `class` `GFG{` `// Function to count the number of steps``// required to convert (x, y) to (1, 1)``static` `void` `minimumSteps(``int` `x, ``int` `y)``{``    ` `    ``// Store the required result``    ``int` `cnt = ``0``;` `    ``// Iterate while both x``    ``// and y are not equal to 0``    ``while` `(x != ``0` `&& y != ``0``)``    ``{``        ` `        ``// If x is greater than y``        ``if` `(x > y)``        ``{``            ` `            ``// Update count and value of x``            ``cnt += x / y;``            ``x %= y;``        ``}` `        ``// Otherwise``        ``else``        ``{``            ` `            ``// Update count and value of y``            ``cnt += y / x;``            ``y %= x;``        ``}``    ``}``    ``cnt--;` `    ``// If both x and y > 1``    ``if` `(x > ``1` `|| y > ``1``)``        ``cnt = -``1``;` `    ``// Print the result``    ``System.out.println(cnt);``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ` `    ``// Given X and Y``    ``int` `x = ``3``, y = ``1``;``    ` `    ``minimumSteps(x, y);``}``}` `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program for the above approach` `# Function to count the number of steps``# required to convert (x, y) to (1, 1)``def` `minimumSteps(x, y):``    ` `    ``# Store the required result``    ``cnt ``=` `0` `    ``# Iterate while both x``    ``# and y are not equal to 0``    ``while` `(x !``=` `0` `and` `y !``=` `0``):``        ` `        ``# If x is greater than y``        ``if` `(x > y):``            ` `            ``# Update count and value of x``            ``cnt ``+``=` `x ``/` `y``            ``x ``%``=` `y` `        ``# Otherwise``        ``else``:``            ` `            ``# Update count and value of y``            ``cnt ``+``=` `y ``/` `x``            ``y ``%``=` `x``            ` `    ``cnt ``-``=` `1` `    ``# If both x and y > 1``    ``if` `(x > ``1` `or` `y > ``1``):``        ``cnt ``=` `-``1` `    ``# Print the result``    ``print``(``int``(cnt))` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given X and Y``    ``x ``=` `3``    ``y ``=` `1``    ` `    ``minimumSteps(x, y)``    ` `# This code is contributed by ipg2016107`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to count the number of steps``// required to convert (x, y) to (1, 1)``public` `static` `void` `minimumSteps(``int` `x, ``int` `y)``{``    ` `    ``// Store the required result``    ``int` `cnt = 0;` `    ``// Iterate while both x``    ``// and y are not equal to 0``    ``while` `(x != 0 && y != 0)``    ``{``        ` `        ``// If x is greater than y``        ``if` `(x > y)``        ``{``            ` `            ``// Update count and value of x``            ``cnt += x / y;``            ``x %= y;``        ``}` `        ``// Otherwise``        ``else``        ``{``            ` `            ``// Update count and value of y``            ``cnt += y / x;``            ``y %= x;``        ``}``    ``}``    ``cnt--;` `    ``// If both x and y > 1``    ``if` `(x > 1 || y > 1)``        ``cnt = -1;` `    ``// Print the result``    ``Console.WriteLine(cnt);``}` `// Driver Code``public` `static` `void` `Main()``{``    ` `    ``// Given X and Y``    ``int` `x = 3, y = 1;``    ` `    ``minimumSteps(x, y);``}``}` `// This code is contributed by mohit kumar 29`

## Javascript

 ``
Output:
`2`

Time Complexity: O(log(max(X, Y)))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up