Merge branch 'main' into problems-3583-3772-3771-3770-3769-3768-3767-3766-3765-3764-3762-3761-3760

Author: romankurnovskii

data/book-sets.json

@@ -61,9 +61,9 @@
       1304, 1318, 1337, 1372, 1423, 1431, 1448, 1456, 1466, 1480, 1493, 1515, 1523, 1528, 1557, 1584, 1657, 1672, 1679, 1704, 1732, 1768, 1798, 1920,
       1925, 1926, 1929, 1957, 1963, 2011, 2095, 2119, 2130, 2211, 2215, 2300, 2336, 2352, 2390, 2419, 2462, 2542, 2627, 2703, 2723, 2769, 2807, 2862,
       2879, 2884, 2888, 2894, 2942, 3100, 3110, 3133, 3164, 3190, 3197, 3228, 3291, 3320, 3351, 3380, 3381, 3413, 3424, 3432, 3444, 3471, 3512, 3522,
-      3583, 3602, 3603, 3606, 3607, 3608, 3622, 3623, 3625, 3663, 3668, 3678, 3683, 3688, 3692, 3697, 3701, 3707, 3712, 3718, 3722, 3723, 3724, 3726,
-      3727, 3728, 3731, 3736, 3737, 3738, 3739, 3740, 3741, 3742, 3743, 3745, 3747, 3748, 3750, 3751, 3752, 3753, 3754, 3755, 3756, 3757, 3759, 3760,
-      3761, 3764, 3765, 3766, 3767, 3768, 3770, 3771, 3772
+      3602, 3603, 3606, 3607, 3608, 3622, 3623, 3625, 3663, 3668, 3678, 3683, 3688, 3692, 3697, 3701, 3707, 3712, 3718, 3722, 3723, 3724, 3726, 3727,
+      3728, 3731, 3736, 3737, 3738, 3739, 3740, 3741, 3742, 3743, 3745, 3747, 3748, 3750, 3751, 3752, 3753, 3754, 3755, 3756, 3757, 3759, 3760, 3761,
+      3762, 3764, 3765, 3766, 3767, 3768, 3769, 3770, 3771, 3772
     ]
   },
   {"title": "Visualization", "description": "", "tags": [], "problems": [1, 2, 11, 1431, 1679, 1768, 1798, 2215, 3603, 3622, 3623]},

explanations/1071/en.md

@@ -1,69 +1,69 @@
-## 1071. Greatest Common Divisor of Strings [Easy]
+## Explanation
 
-https://leetcode.com/problems/greatest-common-divisor-of-strings
+### Strategy (The "Why")
 
-## Description
-For two strings `s` and `t`, we say "t divides s" if and only if `s = t + t + ... + t` (i.e., t is concatenated with itself one or more times).
+Given two strings `str1` and `str2`, we need to find the largest string `x` such that `x` divides both `str1` and `str2`. A string `t` divides `s` if `s` can be formed by concatenating `t` multiple times.
 
-Given two strings `str1` and `str2`, return the largest string `x` such that `x` divides both `str1` and `str2`.
+**1.1 Constraints & Complexity:**
 
-**Examples**
-```text
-Input: str1 = "ABCABC", str2 = "ABC"
-Output: "ABC"
+- **Input Size:** Each string can have length between 1 and 1000.
+- **Value Range:** Strings consist of English uppercase letters.
+- **Time Complexity:** O(n + m) where n and m are the lengths of str1 and str2. We check string equality and compute GCD of lengths.
+- **Space Complexity:** O(min(n, m)) - We store the GCD string, which is at most the length of the shorter string.
+- **Edge Case:** If the strings don't share a common divisor pattern (str1 + str2 ≠ str2 + str1), return empty string.
 
-Input: str1 = "ABABAB", str2 = "ABAB"
-Output: "AB"
+**1.2 High-level approach:**
 
-Input: str1 = "LEET", str2 = "CODE"
-Output: ""
-```
+The goal is to find the longest string that can be repeated to form both str1 and str2. This is analogous to finding the greatest common divisor (GCD) of two numbers, but for strings.
 
-**Constraints**
-- 1 <= str1.length, str2.length <= 1000
-- str1 and str2 consist of English uppercase letters.
+![Greatest Common Divisor of Strings](https://assets.leetcode.com/uploads/2020/01/31/gcd-of-strings.png)
 
-> Try to find the greatest common divisor (GCD) of the lengths of the two strings, and check if the substring of that length divides both strings.
+The key insight is that if a common divisor exists, then `str1 + str2` must equal `str2 + str1`. The length of the GCD string will be the GCD of the lengths of the two strings.
 
-## Explanation
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Try all possible prefixes of the shorter string, check if each divides both strings. This would be O(n² × m) where we check each prefix and verify it divides both strings.
+- **Optimized Strategy (GCD of Lengths):** First verify that str1 + str2 == str2 + str1. If true, compute the GCD of the string lengths, and return the prefix of that length. This is O(n + m) for the check plus O(log(min(n, m))) for GCD computation.
+- **Why it's better:** We avoid checking every possible prefix by using the mathematical property that the GCD string length must be the GCD of the two string lengths.
+
+**1.4 Decomposition:**
+
+1. Check if str1 + str2 equals str2 + str1. If not, return empty string (no common divisor exists).
+2. Compute the GCD of the lengths of str1 and str2 using the Euclidean algorithm.
+3. Return the prefix of str1 (or str2) with length equal to the GCD.
 
-### Strategy
-Let's restate the problem: Given two strings, find the largest string that can be repeated to form both strings exactly. This is a string manipulation problem with a mathematical twist (using the greatest common divisor, or GCD).
+### Steps (The "How")
 
-- **What is given?** Two strings, `str1` and `str2`.
-- **What is being asked?** Find the largest string x such that both str1 and str2 are made by repeating x some number of times.
-- **Constraints:** Both strings are non-empty, up to 1000 characters, and only contain uppercase English letters.
-- **Edge cases:** If the strings cannot be built from the same repeating substring, the answer is an empty string.
+**2.1 Initialization & Example Setup:**
 
-Suppose you have two strings, and you want to find the biggest chunk that can be repeated to make both strings. Think of it like finding the biggest building block that fits perfectly into **both**.
+Let's use the example: `str1 = "ABABAB"`, `str2 = "ABAB"`
 
-First, you check if both strings can be built by repeating the same substring, because if they can't, there's no **common divisor** string. You do this by comparing `str1 + str2` and `str2 + str1` — if they're not the same, it means the order of repetition doesn't match, so no common divisor exists. This check is important because it quickly rules out impossible cases, saving you time and effort.
+We first check: `str1 + str2 = "ABABABABAB"` and `str2 + str1 = "ABABABABAB"`. They are equal, so a common divisor exists.
 
-Next, you use the greatest common divisor (GCD) of the lengths of the two strings. You do this because the largest possible repeating substring must fit evenly into both strings, and the GCD gives you the largest length that divides both. This is a mathematical shortcut that ensures you only check the most promising candidate.
+**2.2 Start Checking:**
 
-Finally, you take the substring of that length from the start of either string and check if repeating it forms both strings. This works because if a substring can build both strings by repetition, it must be the answer. 
+We compute the GCD of the lengths:
+- `len(str1) = 6`
+- `len(str2) = 4`
+- GCD(6, 4) = 2
 
-**High-level plan:**
-1. If `str1 + str2 != str2 + str1`, there is no common divisor string. Return "".
-2. Otherwise, the answer is the substring of length gcd(len(str1), len(str2)) from the start of either string.
+**2.3 Trace Walkthrough:**
 
-> Try to find the greatest common divisor (GCD) of the lengths of the two strings, and check if the substring of that length divides both strings.
+| Step | Operation | a | b | Result |
+|------|-----------|---|---|--------|
+| 1 | Initial | 6 | 4 | - |
+| 2 | GCD(6, 4) | 6 | 4 | GCD(4, 6 % 4 = 2) |
+| 3 | GCD(4, 2) | 4 | 2 | GCD(2, 4 % 2 = 0) |
+| 4 | GCD(2, 0) | 2 | 0 | Return 2 |
 
-### Steps
-1. **Check for a valid repeating pattern:**
-   - Concatenate `str1 + str2` and `str2 + str1`. If they are not equal, it means the two strings cannot be built from the same repeating substring. For example:
-     - `str1 = "ABCABC", str2 = "ABC"` → `"ABCABCABC" == "ABCABCABC"` (valid)
-     - `str1 = "LEET", str2 = "CODE"` → `"LEETCODE" != "CODELEET"` (invalid)
+**2.4 Explanation:**
 
-2. **Find the GCD of the lengths:**
-   - If the pattern is valid, compute the greatest common divisor (GCD) of the lengths of str1 and str2. This gives the largest possible length for the repeating substring.
-   - Example: `str1 = "ABABAB"` (length 6), `str2 = "ABAB"` (length 4). GCD(6, 4) = 2.
+- The GCD of 6 and 4 is 2, so the GCD string has length 2.
+- We return `str1[:2] = "AB"`.
+- Verification: "AB" × 3 = "ABABAB" = str1, and "AB" × 2 = "ABAB" = str2.
 
-3. **Extract the substring:**
-   - Take the substring of length GCD from the start of either string. This is the candidate for the greatest common divisor string.
-   - Example: `str1 = "ABABAB", str2 = "ABAB"`. GCD = 2, so substring = "AB".
+**2.5 Return Result:**
 
-4. **Return the result:**
-   - If the above checks pass, return the substring. Otherwise, return an empty string.
+We return `"AB"`, which is the largest string that divides both str1 and str2.
 
-> The key insight is that if two strings are made by repeating the same substring, their concatenations in both orders must be equal. This is a quick way to check for a common divisor string.
+> **Note:** The condition `str1 + str2 == str2 + str1` is necessary and sufficient for a common divisor to exist. This is a mathematical property of string divisibility.

explanations/1431/en.md

@@ -1,48 +1,71 @@
-## 1431. Kids With the Greatest Number of Candies [Easy]
+## Explanation
 
-https://leetcode.com/problems/kids-with-the-greatest-number-of-candies
+### Strategy (The "Why")
 
-## Description
-There are `n` kids with candies. You are given an integer array `candies`, where each `candies[i]` represents the number of candies the `i`th kid has, and an integer `extraCandies`, denoting the number of extra candies that you have.
+Given an array `candies` representing the number of candies each kid has, and `extraCandies` extra candies, we need to determine for each kid whether giving them all the extra candies would make them have the greatest number of candies.
 
-Return a boolean array `result` of length `n`, where `result[i]` is `true` if, after giving the `i`th kid all the `extraCandies`, they will have the greatest number of candies among all the kids, or false otherwise.
+**1.1 Constraints & Complexity:**
 
-Note that multiple kids can have the greatest number of candies.
+- **Input Size:** The number of kids n is between 2 and 100.
+- **Value Range:** Each kid has between 1 and 100 candies, and extraCandies is between 1 and 50.
+- **Time Complexity:** O(n) - We iterate through the candies array twice: once to find the maximum, and once to build the result.
+- **Space Complexity:** O(n) - We create a result list of length n.
+- **Edge Case:** If all kids have the same number of candies, all will be true (since adding extraCandies to any will make them have the most).
 
-**Examples**
+**1.2 High-level approach:**
 
-```text
-Input: candies = [2,3,5,1,3], extraCandies = 3
-Output: [true,true,true,false,true]
-Explanation: If you give all extraCandies to:
-- Kid 1, they will have 2 + 3 = 5 candies, which is the greatest among the kids.
-- Kid 2, they will have 3 + 3 = 6 candies, which is the greatest among the kids.
-- Kid 3, they will have 5 + 3 = 8 candies, which is the greatest among the kids.
-- Kid 4, they will have 1 + 3 = 4 candies, which is not the greatest among the kids.
-- Kid 5, they will have 3 + 3 = 6 candies, which is the greatest among the kids.
+The goal is to check, for each kid, if their current candies plus the extra candies would be greater than or equal to the maximum number of candies any kid currently has.
 
-Input: candies = [4,2,1,1,2], extraCandies = 1
-Output: [true,false,false,false,false]
+![Kids With Candies](https://assets.leetcode.com/uploads/2020/06/14/kids-with-candies.png)
 
-Input: candies = [12,1,12], extraCandies = 10
-Output: [true,false,true]
-```
+We first find the maximum number of candies, then for each kid, we check if `candies[i] + extraCandies >= max_candies`.
 
-**Constraints**
+**1.3 Brute force vs. optimized strategy:**
 
-```text
-- n == candies.length
-- 2 <= n <= 100
-- 1 <= candies[i] <= 100
-- 1 <= extraCandies <= 50
-```
+- **Brute Force:** For each kid, add extraCandies to their count, then check if this new count is greater than all other kids' counts. This would be O(n²) because for each kid we compare with all others.
+- **Optimized Strategy (Two-Pass):** First pass: find the maximum number of candies. Second pass: for each kid, check if their candies plus extraCandies is >= the maximum. This is O(n).
+- **Why it's better:** By finding the maximum first, we only need one comparison per kid in the second pass, reducing time complexity from O(n²) to O(n).
 
-## Hint
-For each kid, check if their candies plus `extraCandies` is at least as much as the current maximum.
+**1.4 Decomposition:**
 
-## Explanation
-First, you want to know the highest number of candies any kid currently has. This is important because you need a reference point to see if giving extra candies to a kid will make them "the greatest."
+1. Find the maximum number of candies in the array.
+2. Initialize an empty result list.
+3. For each kid, check if their candies plus extraCandies is greater than or equal to the maximum.
+4. Append True or False to the result list accordingly.
+5. Return the result list.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `candies = [2, 3, 5, 1, 3]`, `extraCandies = 3`
+
+We initialize:
+- `max_candies = 0` (will find maximum)
+- `res = []` (result list)
+
+**2.2 Start Checking:**
+
+First, we find the maximum: `max_candies = max(candies) = 5`
+
+**2.3 Trace Walkthrough:**
+
+| Kid Index | Current Candies | Current + Extra | >= Max (5)? | res |
+|-----------|----------------|-----------------|-------------|-----|
+| 0 | 2 | 2 + 3 = 5 | Yes (5 >= 5) | [True] |
+| 1 | 3 | 3 + 3 = 6 | Yes (6 >= 5) | [True, True] |
+| 2 | 5 | 5 + 3 = 8 | Yes (8 >= 5) | [True, True, True] |
+| 3 | 1 | 1 + 3 = 4 | No (4 < 5) | [True, True, True, False] |
+| 4 | 3 | 3 + 3 = 6 | Yes (6 >= 5) | [True, True, True, False, True] |
+
+**2.4 Increment and Loop:**
+
+- For each kid, we calculate `candies[i] + extraCandies`.
+- We compare this sum with `max_candies`.
+- If the sum is >= max_candies, we append True; otherwise, we append False.
+
+**2.5 Return Result:**
 
-For each kid, you add the `extraCandies` to their current amount. You do this because you want to see if, after the bonus, they can reach or beat the current maximum. If they do, you mark them as `True` in our answer list; otherwise, False.
+We return `[True, True, True, False, True]`, indicating that kids at indices 0, 1, 2, and 4 would have the greatest number of candies after receiving the extra candies.
 
-You only need to find the maximum once, and then just compare each kid's total to it. Don't need to recalculate the maximum for every kid. 
+> **Note:** We compare with the original maximum, not the maximum after giving extra candies. This is correct because if a kid's candies plus extraCandies is >= the original maximum, they will have at least as many as the kid who originally had the most.