Open in App
Not now

# Stein’s Algorithm for finding GCD

• Difficulty Level : Hard
• Last Updated : 04 Jul, 2022

Stein’s algorithm or binary GCD algorithm is an algorithm that computes the greatest common divisor of two non-negative integers. Steinâ€™s algorithm replaces division with arithmetic shifts, comparisons, and subtraction.

Examples:

```Input: a = 17, b = 34
Output : 17

Input: a = 50, b = 49
Output: 1```

Algorithm to find GCD using Stein’s algorithm gcd(a, b)

1. If both a and b are 0, gcd is zero gcd(0, 0) = 0.
2. gcd(a, 0) = a and gcd(0, b) = b because everything divides 0.
3. If a and b are both even, gcd(a, b) = 2*gcd(a/2, b/2) because 2 is a common divisor. Multiplication with 2 can be done with bitwise shift operator.
4. If a is even and b is odd, gcd(a, b) = gcd(a/2, b). Similarly, if a is odd and b is even, then
gcd(a, b) = gcd(a, b/2). It is because 2 is not a common divisor.
5. If both a and b are odd, then gcd(a, b) = gcd(|a-b|/2, b). Note that difference of two odd numbers is even
6. Repeat steps 3â€“5 until a = b, or until a = 0. In either case, the GCD is power(2, k) * b, where power(2, k) is 2 raise to the power of k and k is the number of common factors of 2 found in step 3.

Iterative Implementation

## C++

 `// Iterative C++ program to` `// implement Stein's Algorithm` `#include ` `using` `namespace` `std;`   `// Function to implement` `// Stein's Algorithm` `int` `gcd(``int` `a, ``int` `b)` `{` `    ``/* GCD(0, b) == b; GCD(a, 0) == a,` `       ``GCD(0, 0) == 0 */` `    ``if` `(a == 0)` `        ``return` `b;` `    ``if` `(b == 0)` `        ``return` `a;`   `    ``/*Finding K, where K is the` `      ``greatest power of 2` `      ``that divides both a and b. */` `    ``int` `k;` `    ``for` `(k = 0; ((a | b) & 1) == 0; ++k) ` `    ``{` `        ``a >>= 1;` `        ``b >>= 1;` `    ``}`   `    ``/* Dividing a by 2 until a becomes odd */` `    ``while` `((a & 1) == 0)` `        ``a >>= 1;`   `    ``/* From here on, 'a' is always odd. */` `    ``do` `    ``{` `        ``/* If b is even, remove all factor of 2 in b */` `        ``while` `((b & 1) == 0)` `            ``b >>= 1;`   `        ``/* Now a and b are both odd.` `           ``Swap if necessary so a <= b,` `           ``then set b = b - a (which is even).*/` `        ``if` `(a > b)` `            ``swap(a, b); ``// Swap u and v.`   `        ``b = (b - a);` `    ``}``while` `(b != 0);`   `    ``/* restore common factors of 2 */` `    ``return` `a << k;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `a = 34, b = 17;` `    ``printf``(``"Gcd of given numbers is %d\n"``, gcd(a, b));` `    ``return` `0;` `}`

## Java

 `// Iterative Java program to` `// implement Stein's Algorithm` `import` `java.io.*;`   `class` `GFG {`   `    ``// Function to implement Stein's` `    ``// Algorithm` `    ``static` `int` `gcd(``int` `a, ``int` `b)` `    ``{` `        ``// GCD(0, b) == b; GCD(a, 0) == a,` `        ``// GCD(0, 0) == 0` `        ``if` `(a == ``0``)` `            ``return` `b;` `        ``if` `(b == ``0``)` `            ``return` `a;`   `        ``// Finding K, where K is the greatest` `        ``// power of 2 that divides both a and b` `        ``int` `k;` `        ``for` `(k = ``0``; ((a | b) & ``1``) == ``0``; ++k) ` `        ``{` `            ``a >>= ``1``;` `            ``b >>= ``1``;` `        ``}`   `        ``// Dividing a by 2 until a becomes odd` `        ``while` `((a & ``1``) == ``0``)` `            ``a >>= ``1``;`   `        ``// From here on, 'a' is always odd.` `        ``do` `        ``{` `            ``// If b is even, remove` `            ``// all factor of 2 in b` `            ``while` `((b & ``1``) == ``0``)` `                ``b >>= ``1``;`   `            ``// Now a and b are both odd. Swap` `            ``// if necessary so a <= b, then set` `            ``// b = b - a (which is even)` `            ``if` `(a > b) ` `            ``{` `                ``// Swap u and v.` `                ``int` `temp = a;` `                ``a = b;` `                ``b = temp;` `            ``}`   `            ``b = (b - a);` `        ``} ``while` `(b != ``0``);`   `        ``// restore common factors of 2` `        ``return` `a << k;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `a = ``34``, b = ``17``;`   `        ``System.out.println(``"Gcd of given "` `                           ``+ ``"numbers is "` `+ gcd(a, b));` `    ``}` `}`   `// This code is contributed by Nikita Tiwari`

## Python3

 `# Iterative Python 3 program to` `# implement Stein's Algorithm`   `# Function to implement` `# Stein's Algorithm`     `def` `gcd(a, b):`   `    ``# GCD(0, b) == b; GCD(a, 0) == a,` `    ``# GCD(0, 0) == 0` `    ``if` `(a ``=``=` `0``):` `        ``return` `b`   `    ``if` `(b ``=``=` `0``):` `        ``return` `a`   `    ``# Finding K, where K is the` `    ``# greatest power of 2 that` `    ``# divides both a and b.` `    ``k ``=` `0`   `    ``while``(((a | b) & ``1``) ``=``=` `0``):` `        ``a ``=` `a >> ``1` `        ``b ``=` `b >> ``1` `        ``k ``=` `k ``+` `1`   `    ``# Dividing a by 2 until a becomes odd` `    ``while` `((a & ``1``) ``=``=` `0``):` `        ``a ``=` `a >> ``1`   `    ``# From here on, 'a' is always odd.` `    ``while``(b !``=` `0``):`   `        ``# If b is even, remove all` `        ``# factor of 2 in b` `        ``while` `((b & ``1``) ``=``=` `0``):` `            ``b ``=` `b >> ``1`   `        ``# Now a and b are both odd. Swap if` `        ``# necessary so a <= b, then set` `        ``# b = b - a (which is even).` `        ``if` `(a > b):`   `            ``# Swap u and v.` `            ``temp ``=` `a` `            ``a ``=` `b` `            ``b ``=` `temp`   `        ``b ``=` `(b ``-` `a)`   `    ``# restore common factors of 2` `    ``return` `(a << k)`     `# Driver code` `a ``=` `34` `b ``=` `17`   `print``(``"Gcd of given numbers is "``, gcd(a, b))`   `# This code is contributed by Nikita Tiwari.`

## C#

 `// Iterative C# program to implement` `// Stein's Algorithm` `using` `System;`   `class` `GFG {`   `    ``// Function to implement Stein's` `    ``// Algorithm` `    ``static` `int` `gcd(``int` `a, ``int` `b)` `    ``{`   `        ``// GCD(0, b) == b; GCD(a, 0) == a,` `        ``// GCD(0, 0) == 0` `        ``if` `(a == 0)` `            ``return` `b;` `        ``if` `(b == 0)` `            ``return` `a;`   `        ``// Finding K, where K is the greatest` `        ``// power of 2 that divides both a and b` `        ``int` `k;` `        ``for` `(k = 0; ((a | b) & 1) == 0; ++k) ` `        ``{` `            ``a >>= 1;` `            ``b >>= 1;` `        ``}`   `        ``// Dividing a by 2 until a becomes odd` `        ``while` `((a & 1) == 0)` `            ``a >>= 1;`   `        ``// From here on, 'a' is always odd` `        ``do` `        ``{` `            ``// If b is even, remove` `            ``// all factor of 2 in b` `            ``while` `((b & 1) == 0)` `                ``b >>= 1;`   `            ``/* Now a and b are both odd. Swap` `            ``if necessary so a <= b, then set` `            ``b = b - a (which is even).*/` `            ``if` `(a > b) {`   `                ``// Swap u and v.` `                ``int` `temp = a;` `                ``a = b;` `                ``b = temp;` `            ``}`   `            ``b = (b - a);` `        ``} ``while` `(b != 0);`   `        ``/* restore common factors of 2 */` `        ``return` `a << k;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `a = 34, b = 17;`   `        ``Console.Write(``"Gcd of given "` `                      ``+ ``"numbers is "` `+ gcd(a, b));` `    ``}` `}`   `// This code is contributed by nitin mittal`

## PHP

 `>= 1;` `        ``\$b` `>>= 1;` `    ``}`   `    ``// Dividing a by 2 until a becomes odd ` `    ``while` `((``\$a` `& 1) == 0)` `        ``\$a` `>>= 1;`   `    ``// From here on, 'a' is always odd.` `    ``do` `    ``{` `        `  `        ``// If b is even, remove ` `        ``// all factor of 2 in b ` `        ``while` `((``\$b` `& 1) == 0)` `            ``\$b` `>>= 1;`   `        ``// Now a and b are both odd. Swap` `        ``// if necessary so a <= b, then set ` `        ``// b = b - a (which is even)` `        ``if` `(``\$a` `> ``\$b``)` `            ``swap(``\$a``, ``\$b``); ``// Swap u and v.`   `        ``\$b` `= (``\$b` `- ``\$a``);` `    ``} ``while` `(``\$b` `!= 0);`   `    ``// restore common factors of 2` `    ``return` `\$a` `<< ``\$k``;` `}`   `// Driver code` `\$a` `= 34; ``\$b` `= 17;` `echo` `"Gcd of given numbers is "` `. ` `                     ``gcd(``\$a``, ``\$b``);`   `// This code is contributed by ajit` `?>`

## Javascript

 ``

Output

`Gcd of given numbers is 17`

Time Complexity: O(N*N)
Auxiliary Space: O(1)

Recursive Implementation

## C++

 `// Recursive C++ program to` `// implement Stein's Algorithm` `#include ` `using` `namespace` `std;`   `// Function to implement` `// Stein's Algorithm` `int` `gcd(``int` `a, ``int` `b)` `{` `    ``if` `(a == b)` `        ``return` `a;`   `    ``// GCD(0, b) == b; GCD(a, 0) == a,` `    ``// GCD(0, 0) == 0` `    ``if` `(a == 0)` `        ``return` `b;` `    ``if` `(b == 0)` `        ``return` `a;`   `    ``// look for factors of 2` `    ``if` `(~a & 1) ``// a is even` `    ``{` `        ``if` `(b & 1) ``// b is odd` `            ``return` `gcd(a >> 1, b);` `        ``else` `// both a and b are even` `            ``return` `gcd(a >> 1, b >> 1) << 1;` `    ``}`   `    ``if` `(~b & 1) ``// a is odd, b is even` `        ``return` `gcd(a, b >> 1);`   `    ``// reduce larger number` `    ``if` `(a > b)` `        ``return` `gcd((a - b) >> 1, b);`   `    ``return` `gcd((b - a) >> 1, a);` `}`   `// Driver code` `int` `main()` `{` `    ``int` `a = 34, b = 17;` `    ``printf``(``"Gcd of given numbers is %d\n"``, gcd(a, b));` `    ``return` `0;` `}`

## Java

 `// Recursive Java program to` `// implement Stein's Algorithm` `import` `java.io.*;`   `class` `GFG {`   `    ``// Function to implement` `    ``// Stein's Algorithm` `    ``static` `int` `gcd(``int` `a, ``int` `b)` `    ``{` `        ``if` `(a == b)` `            ``return` `a;`   `        ``// GCD(0, b) == b; GCD(a, 0) == a,` `        ``// GCD(0, 0) == 0` `        ``if` `(a == ``0``)` `            ``return` `b;` `        ``if` `(b == ``0``)` `            ``return` `a;`   `        ``// look for factors of 2` `        ``if` `((~a & ``1``) == ``1``) ``// a is even` `        ``{` `            ``if` `((b & ``1``) == ``1``) ``// b is odd` `                ``return` `gcd(a >> ``1``, b);`   `            ``else` `// both a and b are even` `                ``return` `gcd(a >> ``1``, b >> ``1``) << ``1``;` `        ``}`   `        ``// a is odd, b is even` `        ``if` `((~b & ``1``) == ``1``)` `            ``return` `gcd(a, b >> ``1``);`   `        ``// reduce larger number` `        ``if` `(a > b)` `            ``return` `gcd((a - b) >> ``1``, b);`   `        ``return` `gcd((b - a) >> ``1``, a);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `a = ``34``, b = ``17``;` `        ``System.out.println(``"Gcd of given"` `                           ``+ ``"numbers is "` `+ gcd(a, b));` `    ``}` `}`   `// This code is contributed by Nikita Tiwari`

## Python3

 `# Recursive Python 3 program to` `# implement Stein's Algorithm`   `# Function to implement` `# Stein's Algorithm`     `def` `gcd(a, b):`   `    ``if` `(a ``=``=` `b):` `        ``return` `a`   `    ``# GCD(0, b) == b; GCD(a, 0) == a,` `    ``# GCD(0, 0) == 0` `    ``if` `(a ``=``=` `0``):` `        ``return` `b`   `    ``if` `(b ``=``=` `0``):` `        ``return` `a`   `    ``# look for factors of 2` `    ``# a is even` `    ``if` `((~a & ``1``) ``=``=` `1``):`   `        ``# b is odd` `        ``if` `((b & ``1``) ``=``=` `1``):` `            ``return` `gcd(a >> ``1``, b)` `        ``else``:` `            ``# both a and b are even` `            ``return` `(gcd(a >> ``1``, b >> ``1``) << ``1``)`   `    ``# a is odd, b is even` `    ``if` `((~b & ``1``) ``=``=` `1``):` `        ``return` `gcd(a, b >> ``1``)`   `    ``# reduce larger number` `    ``if` `(a > b):` `        ``return` `gcd((a ``-` `b) >> ``1``, b)`   `    ``return` `gcd((b ``-` `a) >> ``1``, a)`     `# Driver code` `a, b ``=` `34``, ``17` `print``(``"Gcd of given numbers is "``,` `      ``gcd(a, b))`   `# This code is contributed` `# by Nikita Tiwari.`

## C#

 `// Recursive C# program to` `// implement Stein's Algorithm` `using` `System;`   `class` `GFG {`   `    ``// Function to implement` `    ``// Stein's Algorithm` `    ``static` `int` `gcd(``int` `a, ``int` `b)` `    ``{` `        ``if` `(a == b)` `            ``return` `a;`   `        ``// GCD(0, b) == b;` `        ``// GCD(a, 0) == a,` `        ``// GCD(0, 0) == 0` `        ``if` `(a == 0)` `            ``return` `b;` `        ``if` `(b == 0)` `            ``return` `a;`   `        ``// look for factors of 2` `        ``// a is even` `        ``if` `((~a & 1) == 1) {`   `            ``// b is odd` `            ``if` `((b & 1) == 1)` `                ``return` `gcd(a >> 1, b);`   `            ``else`   `                ``// both a and b are even` `                ``return` `gcd(a >> 1, b >> 1) << 1;` `        ``}`   `        ``// a is odd, b is even` `        ``if` `((~b & 1) == 1)` `            ``return` `gcd(a, b >> 1);`   `        ``// reduce larger number` `        ``if` `(a > b)` `            ``return` `gcd((a - b) >> 1, b);`   `        ``return` `gcd((b - a) >> 1, a);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `a = 34, b = 17;` `        ``Console.Write(``"Gcd of given"` `                      ``+ ``"numbers is "` `+ gcd(a, b));` `    ``}` `}`   `// This code is contributed by nitin mittal.`

## PHP

 `> 1, ``\$b``);` `        ``else` `// both a and b are even` `            ``return` `gcd(``\$a` `>> 1, ``\$b` `>> 1) << 1;` `    ``}`   `    ``if` `(~``\$b` `& 1) ``// a is odd, b is even` `        ``return` `gcd(``\$a``, ``\$b` `>> 1);`   `    ``// reduce larger number` `    ``if` `(``\$a` `> ``\$b``)` `        ``return` `gcd((``\$a` `- ``\$b``) >> 1, ``\$b``);`   `    ``return` `gcd((``\$b` `- ``\$a``) >> 1, ``\$a``);` `}`   `// Driver code` `\$a` `= 34; ``\$b` `= 17;` `echo` `"Gcd of given numbers is: "``, ` `                     ``gcd(``\$a``, ``\$b``);`   `// This code is contributed by aj_36` `?>`

## Javascript

 ``

Output

`Gcd of given numbers is 17`

Time Complexity: O(N*N) where N is the number of bits in the larger number.
Auxiliary Space: O(N*N) where N is the number of bits in the larger number.

You may also like – Basic and Extended Euclidean Algorithm