chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-11-11-474-Ones-and-Zeroes/explanation.md

@@ -0,0 +1,37 @@
+# Ones and Zeroes (Medium)
+
+**Problem ID:** 474  
+**Date:** 2025-11-11  
+**Link:** https://leetcode.com/problems/ones-and-zeroes/
+
+## Approach
+
+To solve the "Ones and Zeroes" problem, we can utilize a dynamic programming approach similar to the "0/1 Knapsack" problem. The main idea is to maintain a 2D DP table that keeps track of the maximum size of the subset of binary strings that can be formed with a given number of zeros and ones.
+
+### Approach:
+
+1. **Count Zeros and Ones**: For each binary string in the input array, count the number of zeros and ones. This can be done using simple iteration over each string.
+
+2. **Dynamic Programming Table**: Create a 2D DP array `dp` where `dp[i][j]` represents the maximum size of the subset that can be formed with at most `i` zeros and `j` ones.
+
+3. **Initialization**: Initialize the DP table with zeros. The base case is `dp[0][0] = 0`, meaning with zero zeros and zero ones, the maximum subset size is zero.
+
+4. **Filling the DP Table**:
+   - Iterate over each string and its corresponding count of zeros (`zero_count`) and ones (`one_count`).
+   - Update the DP table in reverse order (from `m` to `zero_count` and from `n` to `one_count`). This prevents overwriting results of the current iteration.
+   - For each valid combination of zeros and ones, update the DP value as follows:
+     ```
+     dp[i][j] = max(dp[i][j], dp[i - zero_count][j - one_count] + 1)
+     ```
+   - This means we can either choose to include the current string (hence the `+1`) or not include it.
+
+5. **Result Extraction**: The result will be found at `dp[m][n]`, which gives the size of the largest subset that can be formed with at most `m` zeros and `n` ones.
+
+### Data Structures:
+- A 2D list (or array) for the DP table, where dimensions are `(m + 1) x (n + 1)`.
+
+### Complexity:
+- **Time Complexity**: O(S * m * n), where `S` is the number of strings in `strs`. This is due to iterating through each string and updating the DP table.
+- **Space Complexity**: O(m * n) for the DP table.
+
+This approach efficiently computes the maximum subset size while adhering to the constraints on the number of zeros and ones, leveraging the principles of dynamic programming to build up solutions from smaller subproblems.

Medium/2025-11-11-474-Ones-and-Zeroes/solution.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int findMaxForm(String[] strs, int m, int n) {
+        int[][] dp = new int[m + 1][n + 1];
+
+        for (String str : strs) {
+            int zeros = 0, ones = 0;
+            for (char c : str.toCharArray()) {
+                if (c == '0') zeros++;
+                else ones++;
+            }
+
+            for (int i = m; i >= zeros; i--) {
+                for (int j = n; j >= ones; j--) {
+                    dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
+                }
+            }
+        }
+
+        return dp[m][n];
+    }
+}

Medium/2025-11-11-474-Ones-and-Zeroes/solution.js

@@ -0,0 +1,16 @@
+var findMaxForm = function(strs, m, n) {
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+    for (const str of strs) {
+        const count0 = (str.match(/0/g) || []).length;
+        const count1 = str.length - count0;
+
+        for (let i = m; i >= count0; i--) {
+            for (let j = n; j >= count1; j--) {
+                dp[i][j] = Math.max(dp[i][j], dp[i - count0][j - count1] + 1);
+            }
+        }
+    }
+
+    return dp[m][n];
+};

Medium/2025-11-11-474-Ones-and-Zeroes/solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
+        dp = [[0] * (n + 1) for _ in range(m + 1)]
+        
+        for s in strs:
+            zeros = s.count('0')
+            ones = s.count('1')
+            for i in range(m, zeros - 1, -1):
+                for j in range(n, ones - 1, -1):
+                    dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1)
+        
+        return dp[m][n]

README.md

@@ -275,3 +275,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-11-08 — [Minimum One Bit Operations to Make Integers Zero](https://leetcode.com/problems/minimum-one-bit-operations-to-make-integers-zero/) (Hard) → `Hard/2025-11-08-1611-Minimum-One-Bit-Operations-to-Make-Integers-Zero`
 - 2025-11-09 — [Count Operations to Obtain Zero](https://leetcode.com/problems/count-operations-to-obtain-zero/) (Easy) → `Easy/2025-11-09-2169-Count-Operations-to-Obtain-Zero`
 - 2025-11-10 — [Minimum Operations to Convert All Elements to Zero](https://leetcode.com/problems/minimum-operations-to-convert-all-elements-to-zero/) (Medium) → `Medium/2025-11-10-3542-Minimum-Operations-to-Convert-All-Elements-to-Zero`
+- 2025-11-11 — [Ones and Zeroes](https://leetcode.com/problems/ones-and-zeroes/) (Medium) → `Medium/2025-11-11-474-Ones-and-Zeroes`