To determine the number of operations required to reduce a non-negative integer to zero, specific rules apply based on parity. If the value is even, perform division by two. If the value is odd, subtract one. The process repeats until the value reaches zero.

Consider the input 14. The sequence involves dividing by two to get 7, subtracting one to get 6, dividing to get 3, subtracting to get 2, dividing to get 1, and finally subtracting to reach 0. This sequence totals six operations. Similarly, an input of 8 requires four operations, while 123 requires twelve.

Iterative Simulation Approach

This method directly mimics the problem statement using a loop. A counter tracks the operations performed. The loop continues as long as the target value remains positive. In side the loop, check the least significant bit to determine parity. If the bit is set, decrement the value; othewrise, perform a bitwise right shift. Increment the counter after each modification.

public class Solution {
    public int calculateSteps(int target) {
        int operationCount = 0;
        while (target > 0) {
            if ((target & 1) == 1) {
                target -= 1;
            } else {
                target >>>= 1;
            }
            operationCount++;
        }
        return operationCount;
    }
}

Bitwise Analysis Approach

A more efficient solution analyzes the binary representation of the number. Each '1' bit necessitates a subtraction operation, and every bit position (except the most significant one leading to zero) requires a division operation (shift). Consequently, the total steps equal the number of set bits plus the position of the most significant bit, minus one.

public class Solution {
    public int calculateSteps(int target) {
        if (target == 0) {
            return 0;
        }
        int bitLength = 32 - Integer.numberOfLeadingZeros(target);
        int setBits = Integer.bitCount(target);
        return bitLength + setBits - 1;
    }
}