 Open in App
Not now

# Reduce a number to 1 by performing given operations | Set 3

• Last Updated : 27 Dec, 2021

Given an integer N, the task is to find the number of steps required to reduce the given number N to 1 by performing the following operations:

1. If the number is a power of 2, then divide the number by 2.
2. Otherwise, subtract the greatest power of 2 smaller than N from N.

Examples:

Input: N = 2
Output: 1
Explanation: The given number can be reduced to 1 by following the following steps:
Divide the number by 2 as N is a power of 2 which modifies the N to 1.
Therefore, the N can be reduced to 1 in only 1 step.

Input: N = 7
Output: 2
Explanation: The given number can be reduced to 1 by following the following steps:
Subtract 4 the greatest power of 2 less than N. After the step the N modifies to N = 7-4 = 3.
Subtract 2 the greatest power of 2 less than N. After the step the N modifies to N = 3-2 = 1.
Therefore, the N can be reduced to 1 in 2 steps.

Method 1 –

Approach: The idea is to recursively compute the minimum number of steps required.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Utility function to check ` `// if n is power of 2` `int` `highestPowerof2(``int` `n)` `{` `   ``int` `p = (``int``)log2(n);` `   ``return` `(``int``)``pow``(2, p);` `}`   `// Utility function to find highest` `// power of 2 less than or equal ` `// to given number` `bool` `isPowerOfTwo(``int` `n)` `{` `   ``if``(n==0)` `   ``return` `false``;` `  `  `   ``return` `(``ceil``(log2(n)) == ``floor``(log2(n)));` `}`   `// Recursive function to find ` `// steps needed to reduce` `// a given integer to 1` `int` `reduceToOne(``int` `N)` `{` `    ``// Base Condition` `    ``if``(N == 1){` `        ``return` `0;` `    ``}` `    ``// If the number is a power of 2` `    ``if``(isPowerOfTwo(N) == ``true``){` `        ``return` `1 + reduceToOne(N/2);` `    ``}` `    ``// Else subtract the greatest` `    ``//power of 2 smaller than N ` `    ``//from N` `    ``else``{` `        ``return` `1 + reduceToOne(N - highestPowerof2(N));` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``// Input` `    ``int` `N = 7;` `    ``// Function call` `    ``cout << reduceToOne(N) << endl;` `}`

## Java

 `// java program for the above approach`   `class` `GFG {` `  `  `  ``// Utility function to check ` `  ``// if n is power of 2` `  ``static` `int` `highestPowerof2(``int` `n)` `  ``{` `     ``int` `p = (``int``)(Math.log(n) / Math.log(``2``));` `     ``return` `(``int``)Math.pow(``2``, p);` `  ``}`   `  ``// Utility function to find highest` `  ``// power of 2 less than or equal ` `  ``// to given number` `  ``static` `boolean` `isPowerOfTwo(``int` `n)` `  ``{` `     ``if``(n==``0``)` `     ``return` `false``;`   `     ``return` `(``int``)(Math.ceil((Math.log(n) / Math.log(``2``)))) ==` `       ``(``int``)(Math.floor(((Math.log(n) / Math.log(``2``)))));` `  ``}`   `  ``// Recursive function to find ` `  ``// steps needed to reduce` `  ``// a given integer to 1` `  ``static` `int` `reduceToOne(``int` `N)` `  ``{` `      ``// Base Condition` `      ``if``(N == ``1``){` `          ``return` `0``;` `      ``}` `      ``// If the number is a power of 2` `      ``if``(isPowerOfTwo(N) == ``true``){` `          ``return` `1` `+ reduceToOne(N/``2``);` `      ``}` `      ``// Else subtract the greatest` `      ``//power of 2 smaller than N ` `      ``//from N` `      ``else``{` `          ``return` `1` `+ reduceToOne(N - highestPowerof2(N));` `      ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String [] args)` `  ``{` `      ``// Input` `      ``int` `N = ``7``;` `      ``// Function call` `      ``System.out.println(reduceToOne(N));` `  ``}` `  `  `}`     `// This code is contributed by ihritik`

## Python

 `# Python program for the above approach` `import` `math`   `# Utility function to check` `# Log base 2` `def` `Log2(x):` `    ``if` `x ``=``=` `0``:` `        ``return` `false;` ` `  `    ``return` `(math.log10(x) ``/` `            ``math.log10(``2``));` ` `  `# Utility function to check` `# if x is power of 2` `def` `isPowerOfTwo(n):` `    ``return` `(math.ceil(Log2(n)) ``=``=` `            ``math.floor(Log2(n)));`   `# Utility function to find highest` `# power of 2 less than or equal ` `# to given number` `def` `highestPowerof2(n):` ` `  `    ``p ``=` `int``(math.log(n, ``2``));` `    ``return` `int``(``pow``(``2``, p));`   `# Recursive function to find ` `# steps needed to reduce` `# a given integer to 1` `def` `reduceToOne(N):` `    `  `    ``# Base Condition` `    ``if``(N ``=``=` `1``):` `        ``return` `0` `        `  `    ``# If the number is a power of 2` `    ``if``(isPowerOfTwo(N) ``=``=` `True``):` `        ``return` `1` `+` `reduceToOne(N``/``2``)` `        `  `    ``# Else subtract the greatest` `    ``# power of 2 smaller than N ` `    ``# from N` `    ``else``:` `        ``return` `1` `+` `reduceToOne(N ``-` `highestPowerof2(N))`   `# Driver Code`   `# Input` `N ``=` `7``;`   `#Function call` `print``(reduceToOne(N))`   `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG {` `  `  `  ``// Utility function to check ` `  ``// if n is power of 2` `  ``static` `int` `highestPowerof2(``int` `n)` `  ``{` `     ``int` `p = (``int``)(Math.Log(n) / Math.Log(2));` `     ``return` `(``int``)Math.Pow(2, p);` `  ``}`   `  ``// Utility function to find highest` `  ``// power of 2 less than or equal ` `  ``// to given number` `  ``static` `bool` `isPowerOfTwo(``int` `n)` `  ``{` `     ``if``(n == 0)` `     ``return` `false``;`   `     ``return` `(``int``)(Math.Ceiling((Math.Log(n) / Math.Log(2)))) ==` `       ``(``int``)(Math.Floor(((Math.Log(n) / Math.Log(2)))));` `  ``}`   `  ``// Recursive function to find ` `  ``// steps needed to reduce` `  ``// a given integer to 1` `  ``static` `int` `reduceToOne(``int` `N)` `  ``{` `    `  `      ``// Base Condition` `      ``if``(N == 1){` `          ``return` `0;` `      ``}` `    `  `      ``// If the number is a power of 2` `      ``if``(isPowerOfTwo(N) == ``true``){` `          ``return` `1 + reduceToOne(N/2);` `      ``}` `    `  `      ``// Else subtract the greatest` `      ``//power of 2 smaller than N ` `      ``//from N` `      ``else``{` `          ``return` `1 + reduceToOne(N - highestPowerof2(N));` `      ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main()` `  ``{` `    `  `      ``// Input` `      ``int` `N = 7;` `    `  `      ``// Function call` `      ``Console.Write(reduceToOne(N));` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`2`

Method 2 –

Approach: The given problem can be solved using bitwise operators. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find steps needed to` `// reduce a given integer to 1` `int` `reduceToOne(``int` `N)` `{` `    ``// Stores the most` `    ``// significant bit of N` `    ``int` `MSB = log2(N);`   `    ``// Stores the number of steps` `    ``// required to reduce N to 1` `    ``int` `res = 0;`   `    ``// Iterates while N` `    ``// is not equal 1` `    ``while` `(N != 1) {`   `        ``// Increment res by 1` `        ``res++;`   `        ``// If N is power of 2` `        ``if` `(N & (N - 1) == 0) {`   `            ``// Divide N by 2` `            ``N /= 2;` `        ``}` `        ``// Otherwise` `        ``else` `{`   `            ``// Subtract 2 ^ MSB` `            ``// from N` `            ``N -= (1 << MSB);` `        ``}` `        ``// Decrement MSB by 1` `        ``MSB--;` `    ``}` `    ``// Returns res` `    ``return` `res;` `}`   `// Driver code` `int` `main()` `{` `    ``// Input` `    ``int` `N = 7;` `    ``// Function call` `    ``cout << reduceToOne(N) << endl;` `}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;`   `class` `GFG {` `    ``public` `static` `int` `logarithm(``int` `number, ``int` `base)` `    ``{` `        ``int` `res = (``int``)(Math.log(number) / Math.log(base));` `        ``return` `res;` `    ``}` `    ``public` `static` `int` `reduceToOne(``int` `N)` `    ``{` `      `  `        ``// Stores the most` `        ``// significant bit of N` `        ``int` `MSB = logarithm(N, ``2``);`   `        ``// Stores the number of steps` `        ``// required to reduce N to 1` `        ``int` `res = ``0``;`   `        ``// Iterates while N` `        ``// is not equal 1` `        ``while` `(N != ``1``) {`   `            ``// Increment res by 1` `            ``res++;`   `            ``// If N is power of 2` `            ``if` `((N & (N - ``1``)) == ``0``) {`   `                ``// Divide N by 2` `                ``N /= ``2``;` `            ``}` `            ``// Otherwise` `            ``else` `{`   `                ``// Subtract 2 ^ MSB` `                ``// from N` `                ``N -= (``1` `<< MSB);` `            ``}` `            ``// Decrement MSB by 1` `            ``MSB--;` `        ``}` `        ``// Returns res` `        ``return` `res;` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``7``;` `        ``int` `res = reduceToOne(N);` `        ``System.out.println(res);` `    ``}` `}`   `// This code is contributed by lokeshpotta20.`

## Python3

 `# Python program for the above approach` `import` `math`   `# Function to find steps needed to` `# reduce a given integer to 1` `def` `reduceToOne(N):` `    `  `    ``# Stores the most` `    ``# significant bit of N` `    ``MSB ``=` `math.floor(math.log2(N))` `    `  `    ``# Stores the number of steps` `    ``# required to reduce N to 1` `    ``res ``=` `0` `    `  `    ``# Iterates while N` `    ``# is not equal 1` `    ``while` `(N !``=` `1``):` `        `  `        ``# Increment res by 1` `        ``res ``+``=` `1` `        `  `        ``# If N is power of 2` `        ``if` `(N & (N ``-` `1``) ``=``=` `0``):` `            `  `            ``# Divide N by 2` `            ``N ``/``/``=` `2` `        `  `        ``# Otherwise` `        ``else``:` `            ``# Subtract 2 ^ MSB` `            ``# from N` `            ``N ``-``=` `(``1` `<< MSB)` `            `  `        ``# Decrement MSB by 1` `        ``MSB``-``=``1` `    `  `    ``# Returns res` `    ``return` `res` `    `  `# Driver code` `# Input` `N ``=` `7` `# Function call` `print``(reduceToOne(N))`   `# This code is contributed by shubham Singh`

## C#

 `// C# program for the above approach`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to find steps needed to` `// reduce a given integer to 1` `static` `int` `reduceToOne(``int` `N)` `{` `  `  `    ``// Stores the most` `    ``// significant bit of N` `    ``int` `MSB = (``int``)(Math.Log(N)/Math.Log(2));`   `    ``// Stores the number of steps` `    ``// required to reduce N to 1` `    ``int` `res = 0;`   `    ``// Iterates while N` `    ``// is not equal 1` `    ``while` `(N != 1) {`   `        ``// Increment res by 1` `        ``res++;`   `        ``// If N is power of 2` `        ``if` `((N & (N - 1)) == 0) {`   `            ``// Divide N by 2` `            ``N /= 2;` `        ``}` `        ``// Otherwise` `        ``else` `{`   `            ``// Subtract 2 ^ MSB` `            ``// from N` `            ``N -= (1 << MSB);` `        ``}` `      `  `        ``// Decrement MSB by 1` `        ``MSB--;` `    ``}` `  `  `    ``// Returns res` `    ``return` `res;` `}`   `// Driver code` `public` `static` `void` `Main()` `{` `    ``// Input` `    ``int` `N = 7;` `  `  `    ``// Function call` `    ``Console.Write(reduceToOne(N));` `}` `}`   `// This code is contributed by bgangwar59.`

## Javascript

 ``

Output

`2`

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

My Personal Notes arrow_drop_up
Related Articles