chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-02-26-1404-Number-of-Steps-to-Reduce-a-Number-in-Binary-Representation-to-One/explanation.md

@@ -0,0 +1,43 @@
+# Number of Steps to Reduce a Number in Binary Representation to One (Medium)
+
+**Problem ID:** 1404  
+**Date:** 2026-02-26  
+**Link:** https://leetcode.com/problems/number-of-steps-to-reduce-a-number-in-binary-representation-to-one/
+
+## Approach
+
+To solve the problem of determining the number of steps to reduce a binary representation of a number to one, we can follow a systematic approach based on the properties of binary numbers.
+
+### Problem Breakdown:
+1. **Understanding the Operations**:
+   - If the number is **even** (last digit is '0'), we divide it by 2.
+   - If the number is **odd** (last digit is '1'), we add 1 to it.
+
+2. **Binary Representation**:
+   - The binary string represents a number in base-2. We can determine if the number is even or odd by checking the last character of the string.
+
+### Approach:
+1. **Initialization**:
+   - Start with a counter initialized to zero to track the number of steps.
+
+2. **Iterate through the Binary String**:
+   - While the binary string is not equal to "1":
+     - Check if the last character of the string is '0' or '1':
+       - If it is '0', it means the number is even. We can simply remove the last character (simulate division by 2) and increment the step counter.
+       - If it is '1', it means the number is odd. We need to add 1, which means we will effectively convert the last '1' to '0' and potentially change other bits. This can be simulated by:
+         - Incrementing the step counter.
+         - Changing the last '1' to '0' and then appending a '0' at the end (to represent the addition of 1).
+     - Repeat this until we reach "1".
+
+3. **Count Steps**:
+   - Each operation (either division or addition) increments the step counter by one.
+
+### Data Structures:
+- A simple string manipulation is sufficient for this problem. We can use a string to represent the binary number and utilize string slicing to simulate the operations.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the binary string. In the worst case, we may traverse the entire string.
+- **Space Complexity**: O(1), as we are using a constant amount of extra space for the counter and do not require additional data structures that grow with input size.
+
+### Conclusion:
+By systematically applying the rules for even and odd numbers based on the binary representation, we can efficiently count the number of steps needed to reduce the number to one. The approach leverages string manipulation to simulate the operations without needing to convert the binary string to its decimal equivalent explicitly.

Medium/2026-02-26-1404-Number-of-Steps-to-Reduce-a-Number-in-Binary-Representation-to-One/solution.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int numSteps(String s) {
+        int steps = 0;
+        int n = s.length();
+        
+        for (int i = n - 1; i > 0; i--) {
+            if (s.charAt(i) == '1') {
+                steps += 2; // Add 1 and then divide by 2
+            } else {
+                steps += 1; // Just divide by 2
+            }
+        }
+        
+        return steps;
+    }
+}

Medium/2026-02-26-1404-Number-of-Steps-to-Reduce-a-Number-in-Binary-Representation-to-One/solution.js

@@ -0,0 +1,14 @@
+var numSteps = function(s) {
+    let steps = 0;
+    let carry = 0;
+
+    for (let i = s.length - 1; i > 0; i--) {
+        if (s[i] === '0') {
+            steps++; // Even case: divide by 2
+        } else {
+            steps += 2; // Odd case: add 1 and then divide by 2
+        }
+    }
+
+    return steps + carry;
+};

Medium/2026-02-26-1404-Number-of-Steps-to-Reduce-a-Number-in-Binary-Representation-to-One/solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def numSteps(self, s: str) -> int:
+        steps = 0
+        while s != "1":
+            if s[-1] == '0':
+                s = s[:-1]  # Remove the last character (divide by 2)
+            else:
+                s = bin(int(s, 2) + 1)[2:]  # Add 1 and convert back to binary
+            steps += 1
+        return steps

README.md

@@ -376,3 +376,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-02-23 — [Check If a String Contains All Binary Codes of Size K](https://leetcode.com/problems/check-if-a-string-contains-all-binary-codes-of-size-k/) (Medium) → `Medium/2026-02-23-1461-Check-If-a-String-Contains-All-Binary-Codes-of-Size-K`
 - 2026-02-24 — [Sum of Root To Leaf Binary Numbers](https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers/) (Easy) → `Easy/2026-02-24-1022-Sum-of-Root-To-Leaf-Binary-Numbers`
 - 2026-02-25 — [Sort Integers by The Number of 1 Bits](https://leetcode.com/problems/sort-integers-by-the-number-of-1-bits/) (Easy) → `Easy/2026-02-25-1356-Sort-Integers-by-The-Number-of-1-Bits`
+- 2026-02-26 — [Number of Steps to Reduce a Number in Binary Representation to One](https://leetcode.com/problems/number-of-steps-to-reduce-a-number-in-binary-representation-to-one/) (Medium) → `Medium/2026-02-26-1404-Number-of-Steps-to-Reduce-a-Number-in-Binary-Representation-to-One`