Add solutions and explanations for problems 3652, 3769, 3774, 3775, 3776, 3777

explanations/3652/en.md

@@ -0,0 +1,61 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We are given a binary string and can perform two types of operations: flip all characters from index 0 to i (cost: i+1) or flip all characters from index i to n-1 (cost: n-i). We need to find the minimum cost to make all characters equal.
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** The string length n can be up to 10^5, and each character is either '0' or '1'.
+- **Time Complexity:** O(n) - we iterate through the string once to find all transitions.
+- **Space Complexity:** O(1) - we only use a constant amount of extra space.
+- **Edge Case:** If the string already has all characters equal, there are no transitions and the cost is 0.
+
+**1.2 High-level approach:**
+
+The goal is to find the minimum cost to eliminate all transitions (places where adjacent characters differ) in the string. When we encounter a transition, we can either flip the prefix or the suffix, and we choose the cheaper option.
+
+![String transitions visualization](https://assets.leetcode.com/static_assets/others/string-transitions.png)
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Try all possible combinations of operations, which would be exponential O(2^n) and too slow.
+- **Optimized Strategy:** For each transition at position i, we can either flip [0, i-1] (cost i) or flip [i, n-1] (cost n-i). We choose min(i, n-i) and sum all transition costs. This is O(n) time.
+- **Optimization:** By recognizing that each transition can be fixed independently with the cheaper operation, we avoid exponential search and solve in linear time.
+
+**1.4 Decomposition:**
+
+1. Iterate through the string from left to right.
+2. For each position i, check if there's a transition (s[i] != s[i-1]).
+3. If a transition exists, add the minimum cost (min(i, n-i)) to fix it.
+4. Return the total cost.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `s = "0011"`, `n = 4`.
+
+- Initialize `res = 0` to track total cost.
+- The string has one transition at position 2 (between '0' and '1').
+
+**2.2 Start Checking:**
+
+We iterate through the string starting from index 1, comparing each character with the previous one.
+
+**2.3 Trace Walkthrough:**
+
+| Position i | s[i] | s[i-1] | Transition? | Cost Option 1 (flip prefix) | Cost Option 2 (flip suffix) | Chosen Cost | res |
+|------------|------|--------|-------------|---------------------------|----------------------------|-------------|-----|
+| 1 | '0' | '0' | No | - | - | 0 | 0 |
+| 2 | '1' | '0' | Yes | 2 | 2 | 2 | 2 |
+| 3 | '1' | '1' | No | - | - | 0 | 2 |
+
+**2.4 Increment and Loop:**
+
+After checking all positions, we have found all transitions and calculated the minimum cost to fix each one.
+
+**2.5 Return Result:**
+
+The result is 2, which is the minimum cost to make all characters equal. We achieve this by flipping the suffix from index 2 to the end, changing "0011" to "0000".
+

explanations/3769/en.md

@@ -2,68 +2,60 @@
 
 ### Strategy (The "Why")
 
-**Restate the problem:** We need to sort integers by their binary reflection (reversing binary digits and interpreting as decimal). If two numbers have the same reflection, sort by original value.
+**Restate the problem:** We need to sort an array of integers in ascending order based on their binary reflection. The binary reflection of a number is obtained by reversing its binary representation (ignoring leading zeros) and interpreting it as a decimal number. If two numbers have the same binary reflection, the smaller original number should come first.
 
 **1.1 Constraints & Complexity:**
 
-- **Input Size:** `1 <= nums.length <= 100`, `1 <= nums[i] <= 10^9`
-- **Time Complexity:** O(n log n * log max(nums)) - Sort with comparison function
-- **Space Complexity:** O(1) - Sorting in-place
-- **Edge Case:** All numbers have same reflection
+- **Input Size:** The array length is at most 100, and each number is between 1 and 10^9.
+- **Time Complexity:** O(n log n) where n is the array length - we need to sort the array, and each binary reflection calculation is O(log max_value).
+- **Space Complexity:** O(n) for the sorted result array.
+- **Edge Case:** If all numbers have the same binary reflection, they should be sorted by their original values.
 
 **1.2 High-level approach:**
 
-For each number, compute its binary reflection. Sort by reflection value first, then by original value if reflections are equal.
+The goal is to compute the binary reflection for each number and use it as the primary sort key, with the original number as the secondary sort key.
+
+![Binary reflection visualization](https://assets.leetcode.com/static_assets/others/binary-reflection.png)
 
 **1.3 Brute force vs. optimized strategy:**
 
-- **Brute Force:** Precompute all reflections, store in separate array, sort indices. This is O(n log n) but uses extra space.
-- **Optimized (Custom Sort Key):** Use a key function that computes reflection on-the-fly during sorting. This is O(n log n) with O(1) extra space.
-- **Why it's better:** The custom key function is clean and doesn't require precomputation or extra storage.
+- **Brute Force:** Manually implement sorting algorithm and binary conversion, which would be more complex.
+- **Optimized Strategy:** Use Python's built-in `sorted()` function with a custom key function that returns (binary_reflection, original_value). This leverages efficient sorting algorithms and is O(n log n).
+- **Optimization:** Python's Timsort is highly optimized, and using a tuple as the sort key allows us to sort by multiple criteria efficiently.
 
 **1.4 Decomposition:**
 
-1. Define function to compute binary reflection
-2. Sort array using custom key: (reflection, original_value)
-3. Return sorted array
+1. Define a helper function to calculate binary reflection: convert to binary string, reverse it, convert back to integer.
+2. Sort the array using a key function that returns (binary_reflection, original_value).
+3. Return the sorted array.
 
 ### Steps (The "How")
 
 **2.1 Initialization & Example Setup:**
 
-Let's use the example: `nums = [4,5,4]`
-
-- Binary reflections:
-  - 4 → `100` → reversed `001` → 1
-  - 5 → `101` → reversed `101` → 5
-  - 4 → `100` → reversed `001` → 1
+Let's use the example: `nums = [4, 5, 4]`.
 
-**2.2 Define Binary Reflection Function:**
+- Binary representations: 4 = "100", 5 = "101"
+- Binary reflections: 4 → "100" reversed → "001" → 1, 5 → "101" reversed → "101" → 5
 
-```python
-def binary_reflection(n):
-    binary = bin(n)[2:]  # Remove '0b' prefix: "100"
-    reversed_binary = binary[::-1]  # "001"
-    return int(reversed_binary, 2)  # 1
-```
+**2.2 Start Processing:**
 
-**2.3 Sort with Custom Key:**
+We compute the binary reflection for each number and sort accordingly.
 
-```python
-return sorted(nums, key=lambda x: (binary_reflection(x), x))
-```
+**2.3 Trace Walkthrough:**
 
-Sort key is `(reflection, original)`:
-- `(1, 4)` for first 4
-- `(5, 5)` for 5
-- `(1, 4)` for second 4
+| Original Number | Binary | Reversed Binary | Reflection Value | Sort Key (reflection, original) |
+|-----------------|--------|-----------------|------------------|----------------------------------|
+| 4 | "100" | "001" | 1 | (1, 4) |
+| 4 | "100" | "001" | 1 | (1, 4) |
+| 5 | "101" | "101" | 5 | (5, 5) |
 
-Sorting: `(1, 4) < (1, 4) < (5, 5)` → `[4, 4, 5]`
+After sorting by (reflection, original): [(1, 4), (1, 4), (5, 5)] → [4, 4, 5]
 
-**2.4 Return Result:**
+**2.4 Increment and Loop:**
 
-The sorted array maintains order: same reflection values are sorted by original value.
+The sorting algorithm processes all elements and arranges them according to the sort keys.
 
-**Time Complexity:** O(n log n * log max(nums)) - Sort with O(log max) comparison  
-**Space Complexity:** O(1) - In-place sort
+**2.5 Return Result:**
 
+The result is `[4, 4, 5]`, where numbers with reflection 1 (both 4s) come before the number with reflection 5, and the two 4s maintain their relative order (though they're equal).

explanations/3774/en.md

@@ -2,64 +2,59 @@
 
 ### Strategy (The "Why")
 
-**Restate the problem:** We need to find the absolute difference between the sum of the `k` largest elements and the sum of the `k` smallest elements in the array.
+**Restate the problem:** We need to find the absolute difference between the sum of the k largest elements and the sum of the k smallest elements in an array.
 
 **1.1 Constraints & Complexity:**
 
-- **Input Size:** `1 <= n <= 100`, `1 <= nums[i] <= 100`, `1 <= k <= n`
-- **Time Complexity:** O(n log n) - Sorting dominates
-- **Space Complexity:** O(1) - Only using input array
-- **Edge Case:** `k = n` means we use all elements
+- **Input Size:** The array length n is at most 100, and each element is between 1 and 100. k is between 1 and n.
+- **Time Complexity:** O(n log n) - dominated by sorting the array.
+- **Space Complexity:** O(n) for the sorted array.
+- **Edge Case:** If k equals the array length, we're comparing the sum of all elements with itself, so the difference is 0.
 
 **1.2 High-level approach:**
 
-Sort the array, then take the `k` largest elements (last `k` elements) and `k` smallest elements (first `k` elements). Calculate the difference between their sums.
+The goal is to sort the array, then calculate the sum of the first k elements (smallest) and the sum of the last k elements (largest), and return their absolute difference.
+
+![Array sorting and selection visualization](https://assets.leetcode.com/static_assets/others/array-sorting.png)
 
 **1.3 Brute force vs. optimized strategy:**
 
-- **Brute Force:** Find k largest and k smallest without sorting, using multiple passes. This is O(n * k) time.
-- **Optimized (Sorting):** Sort once, then directly access first k and last k elements. This is O(n log n) time.
-- **Why it's better:** For small arrays (n <= 100), sorting is efficient and makes the solution simple and clear.
+- **Brute Force:** Find k largest and k smallest elements without sorting, which would require multiple passes and be O(n*k) time.
+- **Optimized Strategy:** Sort the array once in O(n log n) time, then directly access the first k and last k elements. This is simpler and efficient for the given constraints.
+- **Optimization:** Sorting allows us to easily identify the k smallest (first k) and k largest (last k) elements in a single operation.
 
 **1.4 Decomposition:**
 
-1. Sort the array in ascending order
-2. Sum the first `k` elements (smallest)
-3. Sum the last `k` elements (largest)
-4. Return absolute difference
+1. Sort the array in ascending order.
+2. Calculate the sum of the first k elements (smallest k).
+3. Calculate the sum of the last k elements (largest k).
+4. Return the absolute difference between these two sums.
 
 ### Steps (The "How")
 
 **2.1 Initialization & Example Setup:**
 
-Let's use the example: `nums = [5,2,2,4], k = 2`
-
-- After sorting: `[2, 2, 4, 5]`
-
-**2.2 Sort the Array:**
+Let's use the example: `nums = [5, 2, 2, 4]`, `k = 2`.
 
-```python
-nums.sort()  # [2, 2, 4, 5]
-```
+- After sorting: `sorted_nums = [2, 2, 4, 5]`
 
-**2.3 Calculate Sum of k Smallest:**
+**2.2 Start Processing:**
 
-```python
-sum_smallest = sum(nums[:k])  # sum([2, 2]) = 4
-```
+We calculate the sums of the smallest and largest k elements.
 
-**2.4 Calculate Sum of k Largest:**
+**2.3 Trace Walkthrough:**
 
-```python
-sum_largest = sum(nums[-k:])  # sum([4, 5]) = 9
-```
+| Step | Operation | Values | Result |
+|------|-----------|--------|--------|
+| 1 | Sort array | [5, 2, 2, 4] | [2, 2, 4, 5] |
+| 2 | Sum of k smallest | sorted_nums[:2] = [2, 2] | 2 + 2 = 4 |
+| 3 | Sum of k largest | sorted_nums[2:] = [4, 5] | 4 + 5 = 9 |
+| 4 | Absolute difference | \|9 - 4\| | 5 |
 
-**2.5 Return Absolute Difference:**
+**2.4 Increment and Loop:**
 
-```python
-return abs(sum_largest - sum_smallest)  # abs(9 - 4) = 5
-```
+The calculation is straightforward after sorting - no loops needed for the sum calculation.
 
-**Time Complexity:** O(n log n) - Sorting  
-**Space Complexity:** O(1) - In-place sort
+**2.5 Return Result:**
 
+The result is 5, which is the absolute difference between the sum of the 2 largest elements (9) and the sum of the 2 smallest elements (4).

explanations/3775/en.md

@@ -2,76 +2,60 @@
 
 ### Strategy (The "Why")
 
-**Restate the problem:** We need to count vowels in the first word, then reverse each following word that has the same vowel count. Leave other words unchanged.
+**Restate the problem:** We need to count the vowels in the first word, then reverse each subsequent word that has the same vowel count as the first word. Words are separated by single spaces.
 
 **1.1 Constraints & Complexity:**
 
-- **Input Size:** `1 <= s.length <= 10^5`
-- **Time Complexity:** O(n) - Single pass through string
-- **Space Complexity:** O(n) - Store words and result
-- **Edge Case:** Empty string or single word
+- **Input Size:** The string length can be up to 10^5 characters.
+- **Time Complexity:** O(n) where n is the string length - we iterate through the string once to split and process words.
+- **Space Complexity:** O(n) for storing the words array and result.
+- **Edge Case:** If there's only one word, no words need to be reversed, so we return the original string.
 
 **1.2 High-level approach:**
 
-Split the string into words. Count vowels in the first word. For each subsequent word, if its vowel count matches the first word's count, reverse it. Otherwise, keep it as-is.
+The goal is to process words sequentially: count vowels in the first word, then for each subsequent word, check if it has the same vowel count and reverse it if so.
+
+![Word processing visualization](https://assets.leetcode.com/static_assets/others/word-processing.png)
 
 **1.3 Brute force vs. optimized strategy:**
 
-- **Brute Force:** Multiple passes - one to count vowels in first word, another to process each word. This is still O(n) but less efficient.
-- **Optimized (Single Pass):** Split once, count vowels in first word, then process each word in one pass. This is O(n) time.
-- **Why it's better:** We process the string efficiently in a single logical pass, making the code clear and maintainable.
+- **Brute Force:** Process each word multiple times, counting vowels separately for comparison and reversal, which would be less efficient.
+- **Optimized Strategy:** Split the string into words once, count vowels in the first word, then iterate through remaining words, counting vowels and reversing when needed. This is O(n) time.
+- **Optimization:** By processing words in a single pass and reusing the vowel counting logic, we avoid redundant operations.
 
 **1.4 Decomposition:**
 
-1. Split string into words
-2. Count vowels in first word
-3. For each subsequent word:
-   - Count its vowels
-   - If count matches first word, reverse it
-   - Otherwise, keep as-is
-4. Join words back into string
+1. Split the string into words.
+2. Count vowels in the first word.
+3. For each subsequent word, count its vowels.
+4. If the vowel count matches the first word's count, reverse the word.
+5. Join all words back into a string.
 
 ### Steps (The "How")
 
 **2.1 Initialization & Example Setup:**
 
-Let's use the example: `s = "cat and mice"`
-
-- Words: `["cat", "and", "mice"]`
-- Vowels: `{'a', 'e', 'i', 'o', 'u'}`
-
-**2.2 Split into Words:**
-
-```python
-words = s.split()  # ["cat", "and", "mice"]
-```
+Let's use the example: `s = "cat and mice"`.
 
-**2.3 Count Vowels in First Word:**
+- Words: ["cat", "and", "mice"]
+- First word: "cat" has 1 vowel ('a')
 
-```python
-first_vowel_count = sum(1 for c in words[0] if c in vowels)  # "cat" has 1 vowel: 'a'
-```
+**2.2 Start Processing:**
 
-**2.4 Process Each Subsequent Word:**
+We process each word after the first one, checking vowel counts and reversing when needed.
 
-```python
-for word in words[1:]:
-    vowel_count = sum(1 for c in word if c in vowels)
-    if vowel_count == first_vowel_count:
-        res.append(word[::-1])  # Reverse
-    else:
-        res.append(word)  # Keep as-is
-```
+**2.3 Trace Walkthrough:**
 
-For `"and"`: vowel_count = 1 (matches), so reverse → `"dna"`  
-For `"mice"`: vowel_count = 2 (doesn't match), so keep → `"mice"`
+| Word | Vowel Count | Matches First? | Action | Result |
+|------|-------------|----------------|--------|--------|
+| "cat" | 1 | - | Keep as is | "cat" |
+| "and" | 1 | Yes | Reverse | "dna" |
+| "mice" | 2 | No | Keep as is | "mice" |
 
-**2.5 Join and Return:**
+**2.4 Increment and Loop:**
 
-```python
-return ' '.join(res)  # "cat dna mice"
-```
+After processing all words, we join them with spaces.
 
-**Time Complexity:** O(n) - Process each character once  
-**Space Complexity:** O(n) - Store words and result
+**2.5 Return Result:**
 
+The result is `"cat dna mice"`, where "and" (1 vowel) was reversed to "dna" because it matches the first word's vowel count, while "mice" (2 vowels) remained unchanged.