 GFG App
Open App Browser
Continue

# Minimize given flips required to reduce N to 0

Given an integer N, the task is to reduce the value of N to 0 by performing the following operations minimum number of times:

• Flip the rightmost (0th) bit in the binary representation of N.
• If (i – 1)th bit is set, then flip the ith bit and clear all the bits from (i – 2)th to 0th bit.

Examples:

Input: N = 3
Output:
Explanation:
The binary representation of N (= 3) is 11
Since 0th bit in binary representation of N(= 3) is set, flipping the 1st bit of binary representation of N modifies N to 1(01).
Flipping the rightmost bit of binary representation of N(=1) modifies N to 0(00).
Therefore, the required output is 2

Input: N = 4
Output: 7

Approach: The problem can be solved based on the following observations:

1 -> 0 => 1
10 -> 11 -> 01 -> 00 => 2 + 1 = 3
100 -> 101 -> 111 -> 110 -> 010 -> … => 4 + 2 + 1 = 7
1000 -> 1001 -> 1011 -> 1010 -> 1110 -> 1111 -> 1101 -> 1100 -> 0100 -> … => 8 + 7 = 15
Therefore, for N = 2N total (2(N + 1) – 1) operations required.
If N is not a power of 2, then the recurrence relation is:
MinOp(N) = MinOp((1 << cntBit) – 1) – MinOp(N – (1 << (cntBit – 1)))
cntBit = total count of bits in binary representation of N.
MinOp(N) denotes minimum count of operations required to reduce N to 0.

Follow the steps below to solve the problem:

• Calculate the count of bits in binary representation of N using log2(N) + 1.
• Use the above recurrence relation and calculate the minimum count of operations required to reduce N to 0.

Below is the implementation of the above approach.

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the minimum count of` `// operations required to Reduce N to 0` `int` `MinOp(``int` `N)` `{`   `    ``if` `(N <= 1)` `        ``return` `N;`   `    ``// Stores count of` `    ``// bits in N` `    ``int` `bit = log2(N) + 1;`   `    ``// Recurrence relation` `    ``return` `((1 << bit) - 1)` `           ``- MinOp(N - (1 << (bit - 1)));` `}`   `// Driver Code` `int` `main()` `{`   `    ``int` `N = 4;` `    ``cout << MinOp(N);` `    ``return` `0;` `}`

## Java

 `// Java program to implement ` `// the above approach ` `class` `GFG{` `    `  `// Function to find the minimum count of ` `// operations required to Reduce N to 0 ` `public` `static` `int` `MinOp(``int` `N) ` `{ ` `    ``if` `(N <= ``1``) ` `        ``return` `N; ` `  `  `    ``// Stores count of ` `    ``// bits in N ` `    ``int` `bit = (``int``)(Math.log(N) / ` `                    ``Math.log(``2``)) + ``1``; ` `  `  `    ``// Recurrence relation ` `    ``return` `((``1` `<< bit) - ``1``) - MinOp(` `        ``N - (``1` `<< (bit - ``1``))); ` `} `   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``4``; ` `    `  `    ``System.out.println(MinOp(N));` `}` `}`   `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python program to implement` `# the above approach`   `# Function to find the minimum count of` `# operations required to Reduce N to 0` `import` `math` `def` `MinOp(N):` `    ``if` `(N <``=` `1``):` `        ``return` `N;`   `    ``# Stores count of` `    ``# bits in N` `    ``bit ``=` `(``int``)(math.log(N) ``/` `math.log(``2``)) ``+` `1``;`   `    ``# Recurrence relation` `    ``return` `((``1` `<< bit) ``-` `1``) ``-` `MinOp(N ``-` `(``1` `<< (bit ``-` `1``)));`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `4``;`   `    ``print``(MinOp(N));`   `# This code is contributed by 29AjayKumar `

## C#

 `// C# program to implement` `// the above approach  ` `using` `System;`   `class` `GFG{` `    `  `// Function to find the minimum count of ` `// operations required to Reduce N to 0 ` `public` `static` `int` `MinOp(``int` `N) ` `{ ` `    ``if` `(N <= 1) ` `        ``return` `N; ` `        `  `    ``// Stores count of ` `    ``// bits in N ` `    ``int` `bit = (``int``)(Math.Log(N) / ` `                    ``Math.Log(2)) + 1; ` `                    `  `    ``// Recurrence relation ` `    ``return` `((1 << bit) - 1) - MinOp(` `        ``N - (1 << (bit - 1))); ` `} ` ` `  `// Driver code` `public` `static` `void` `Main()` `{` `    ``int` `N = 4; ` `    `  `    ``Console.WriteLine(MinOp(N));` `}` `}`   `// This code is contributed by sanjoy_62`

## Javascript

 ``

Output:

`7`

Time Complexity: O(log(N)) //since the logarithm function is used, hence the time complexity is logarithmic
Auxiliary Space: O(1) // since no extra variable is used hence the space is taken by the algorithm is constant

My Personal Notes arrow_drop_up