# 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