chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-11-15-3234-Count-the-Number-of-Substrings-With-Dominant-Ones/explanation.md

@@ -0,0 +1,34 @@
+# Count the Number of Substrings With Dominant Ones (Medium)
+
+**Problem ID:** 3234  
+**Date:** 2025-11-15  
+**Link:** https://leetcode.com/problems/count-the-number-of-substrings-with-dominant-ones/
+
+## Approach
+
+To solve the problem of counting the number of substrings with dominant ones in a binary string, we can adopt a systematic approach that leverages the properties of the substring counts and the conditions for dominance.
+
+### Main Idea:
+A substring is considered to have dominant ones if the number of ones (`count_1`) is greater than or equal to the square of the number of zeros (`count_0`). This can be expressed mathematically as:
+\[ count_1 \geq count_0^2 \]
+
+Given this condition, we can derive a way to efficiently count valid substrings by iterating through the string and maintaining a running count of zeros and ones.
+
+### Approach:
+1. **Prefix Counts**: As we iterate through the string, we maintain cumulative counts of zeros and ones. This allows us to quickly calculate the number of zeros and ones in any substring defined by indices `i` and `j`.
+
+2. **Two-pointer Technique**: For each starting index `i`, we can use a second pointer `j` to extend the substring while checking the dominance condition. We will increment `j` until the condition fails, keeping track of valid substrings.
+
+3. **Count Valid Substrings**: For each valid starting index `i`, once we find the maximum index `j` where the condition holds, all substrings from `i` to any index up to `j` are valid. Thus, if `j` is the farthest index satisfying the condition, we can add `(j - i + 1)` to our count of dominant substrings.
+
+4. **Complexity Consideration**: The algorithm primarily involves iterating through the string with two pointers, leading to a time complexity of O(n), where n is the length of the string. This is efficient given the constraints.
+
+### Data Structures:
+- Two integers to keep track of the cumulative counts of zeros and ones.
+- A loop to iterate through the string, with a nested loop (or a two-pointer approach) to find valid substrings.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the string. Each character is processed a limited number of times.
+- **Space Complexity**: O(1) for maintaining counts, as we only need a fixed number of variables regardless of input size.
+
+By following this structured approach, we can efficiently count the number of dominant substrings in the binary string provided.

Medium/2025-11-15-3234-Count-the-Number-of-Substrings-With-Dominant-Ones/solution.java

@@ -0,0 +1,22 @@
+class Solution {
+    public int countSubstrings(String s) {
+        int n = s.length();
+        int count = 0;
+
+        for (int i = 0; i < n; i++) {
+            int ones = 0, zeros = 0;
+            for (int j = i; j < n; j++) {
+                if (s.charAt(j) == '1') {
+                    ones++;
+                } else {
+                    zeros++;
+                }
+                if (ones >= zeros * zeros) {
+                    count++;
+                }
+            }
+        }
+
+        return count;
+    }
+}

Medium/2025-11-15-3234-Count-the-Number-of-Substrings-With-Dominant-Ones/solution.js

@@ -0,0 +1,20 @@
+var countSubstrings = function(s) {
+    let n = s.length;
+    let count = 0;
+    
+    for (let i = 0; i < n; i++) {
+        let ones = 0, zeros = 0;
+        for (let j = i; j < n; j++) {
+            if (s[j] === '1') {
+                ones++;
+            } else {
+                zeros++;
+            }
+            if (ones >= zeros * zeros) {
+                count++;
+            }
+        }
+    }
+    
+    return count;
+};

Medium/2025-11-15-3234-Count-the-Number-of-Substrings-With-Dominant-Ones/solution.py

@@ -0,0 +1,18 @@
+class Solution:
+    def countSubstrings(self, s: str) -> int:
+        n = len(s)
+        total_substrings = n * (n + 1) // 2
+        non_dominant_count = 0
+        
+        for i in range(n):
+            zeros = 0
+            ones = 0
+            for j in range(i, n):
+                if s[j] == '0':
+                    zeros += 1
+                else:
+                    ones += 1
+                if ones < zeros * zeros:
+                    non_dominant_count += 1
+        
+        return total_substrings - non_dominant_count

README.md

@@ -279,3 +279,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-11-12 — [Minimum Number of Operations to Make All Array Elements Equal to 1](https://leetcode.com/problems/minimum-number-of-operations-to-make-all-array-elements-equal-to-1/) (Medium) → `Medium/2025-11-12-2654-Minimum-Number-of-Operations-to-Make-All-Array-Elements-Equal-to-1`
 - 2025-11-13 — [Maximum Number of Operations to Move Ones to the End](https://leetcode.com/problems/maximum-number-of-operations-to-move-ones-to-the-end/) (Medium) → `Medium/2025-11-13-3228-Maximum-Number-of-Operations-to-Move-Ones-to-the-End`
 - 2025-11-14 — [Increment Submatrices by One](https://leetcode.com/problems/increment-submatrices-by-one/) (Medium) → `Medium/2025-11-14-2536-Increment-Submatrices-by-One`
+- 2025-11-15 — [Count the Number of Substrings With Dominant Ones](https://leetcode.com/problems/count-the-number-of-substrings-with-dominant-ones/) (Medium) → `Medium/2025-11-15-3234-Count-the-Number-of-Substrings-With-Dominant-Ones`