3750x

Author: romankurnovskii

data/book-sets.json

@@ -0,0 +1,51 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Binary Representation:** We are working with the bits of an integer $n$. The length of the binary string depends on the magnitude of $n$ (up to $\approx 30$ bits for standard integers).
+  * **Time Complexity:** Since the number of bits is small ($\log_2 n$), the solution will be very fast, effectively $O(\log n)$.
+  * **Edge Case:** If $n=0$ or $n$ is a single bit (e.g., 1), the reverse is identical to the original, so the answer is 0.
+
+**High-level approach**
+The problem asks for the minimum flips to make a number equal to its **original** binary reverse.
+Imagine the binary string as a row of lights. We compare the light at the very start (left) with the light at the very end (right).
+
+  * If the left bit is `1` and the right bit is `0`, we have a mismatch.
+  * To make the number equal to its reverse, the left position *must* become what the right position was, and the right position *must* become what the left position was. This requires flipping **both** bits.
+  * Therefore, every mismatching symmetric pair costs exactly **2 flips**.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** Calculate the reverse of $n$ separately, then iterate through every bit of $n$ and the reverse to count differences.
+  * **Optimized (Two Pointers):** We extract the binary string once. We place pointers at the start and end. We move them inward, counting mismatches. This is efficient and requires only one pass over the bits.
+
+**Decomposition**
+
+1.  **Bit Extraction:** Convert the integer $n$ into its binary string format (removing the '0b' prefix).
+2.  **Two-Pointer Scan:** Initialize `left` at index 0 and `right` at the last index.
+3.  **Check Pairs:** If `s[left] != s[right]`, we found a mismatch. Add 2 to our result (1 flip for each side).
+4.  **Converge:** Move `left` forward and `right` backward until they meet.
+
+### Steps
+
+1.  **Convert to Binary**
+    Turn the integer $n$ into a string of bits. For example, if $n=10$, we get the string `"1010"`.
+
+2.  **Initialize Pointers**
+    Set a variable `res` to 0. Set `l` to the start of the string and `r` to the end.
+
+3.  **Iterate and Compare**
+    While `l` is less than `r`:
+
+      * Check if the bit at `l` is different from the bit at `r`.
+      * **Why?** If the bits are different (e.g., `1` and `0`), then to swap their values effectively (so the number equals its reverse), both positions must be flipped.
+      * If they differ, add **2** to `res`.
+
+4.  **Close the Window**
+    Increment `l` and decrement `r` to check the next pair of bits. Continue until the pointers meet in the middle.
+
+-----
+
+See the solution code in `solutions/3750/01.py`.

explanations/3750/en.md

@@ -0,0 +1,53 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Range Size:** The input numbers go up to 100,000.
+  * **Performance:** If we calculate the waviness for every number in the range `[num1, num2]` every time the function is called, we will likely hit a Time Limit Exceeded (TLE) error. The constraints imply we need a faster way to query.
+  * **Edge Case:** Numbers less than 100 (0-99) have fewer than 3 digits. You cannot have a "middle" digit with neighbors on both sides, so their waviness is always 0.
+
+**High-level approach**
+We will use the **Prefix Sum** technique (also called Cumulative Sum). Instead of calculating the waviness on the fly, we will **precompute** the waviness for every possible number up to the maximum limit (100,000) once. We then store the cumulative totals in an array.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** Loop from `num1` to `num2`. For each number, convert to string, check digits, count peaks/valleys, and add to total. This repeats the same heavy work for every query.
+  * **Optimized:** Create a lookup table `P`.
+    `P[i]` stores the total waviness of *all* numbers from `0` to `i`.
+    To find the waviness between `num1` and `num2`, we simply do `P[num2] - P[num1 - 1]`. This answers any query in $O(1)$ time.
+
+**Decomposition**
+
+1.  **Helper Logic:** Define how to calculate waviness for a single number (check neighbors).
+2.  **Precomputation:** Build an array where we store the cumulative waviness.
+3.  **Range Query:** Use the array to answer the user's request instantly.
+
+### Steps
+
+1.  **Define Waviness**
+    A digit is part of a "wave" if it is strictly greater than its neighbors (Peak) or strictly smaller than its neighbors (Valley).
+
+      * *Visual Peak:* `1 -> 5 -> 2` (5 is a peak)
+      * *Visual Valley:* `9 -> 0 -> 4` (0 is a valley)
+      * We ignore the first and last digits because they don't have neighbors on both sides.
+
+2.  **Initialize the Prefix Array**
+    We create an array `prefix` of size 100,001 (covering 0 to 100,000).
+    We define `running_total` to keep track of the sum as we build the array.
+
+3.  **Populate the Array**
+    We loop through every number `i` from 0 to 100,000.
+
+      * Convert `i` to a string (or use math) to access digits.
+      * Count the peaks and valleys for `i`.
+      * Add this count to `running_total`.
+      * Store `running_total` in `prefix[i]`.
+
+4.  **Answer the Query**
+    When the user asks for the range `[num1, num2]`:
+
+      * Take the total waviness up to `num2` (`prefix[num2]`).
+      * Subtract the total waviness before the range starts (`prefix[num1 - 1]`).
+      * Return the result.

explanations/3751/en.md

@@ -0,0 +1,32 @@
+## Explanation
+
+### Strategy
+
+**The Bug Analysis**
+Your current logic checks two things for feasibility:
+
+1.  Is `target` greater than the maximum possible sum (`total_sum`)? (Handled by `diff < 0`)
+2.  Is the parity correct? (Handled by `diff % 2 != 0`)
+
+However, it misses the **Lower Bound** check.
+In your failing test case:
+
+  * `n = 1`
+  * `target = -3`
+  * Max possible sum (all positive) = $1$.
+  * Min possible sum (all negative) = $-1$.
+
+The target $-3$ is smaller than the minimum possible sum $-1$. Your code calculates a `negative_budget` of 2 (meaning we need to flip numbers summing to 2), but we only have the number 1 available. The greedy loop runs, subtracts 1, leaves the budget at 1, and returns `[-1]` (which sums to -1, not -3).
+
+**The Fix**
+We must verify that the `target` is not smaller than the purely negative sum.
+Alternatively, and more robustly, we can check if `negative_budget` is exactly `0` after our greedy loop. If the budget isn't 0, it means we couldn't find enough numbers to flip to satisfy the target.
+
+### Steps
+
+1.  **Calculate Total Sum:** Same as before ($n(n+1)/2$).
+2.  **Expanded Feasibility Check:**
+      * Check `abs(target) > total_sum`. If the target is outside the range `[-total_sum, total_sum]`, return `[]`.
+      * Check parity (`diff % 2 != 0`).
+3.  **Greedy Loop:** Same as before.
+4.  **Final Verification:** (Optional if bounds check is strict, but good practice) Ensure `negative_budget` reached 0.

explanations/3752/en.md

@@ -0,0 +1,42 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Input Size:** This is the "easy" version of the problem, meaning $n$ is likely a standard integer. The number of digits ($D$) is small enough that we can process them directly without complex prefix arrays.
+  * **Zeros:** The core constraint is ignoring zeros.
+  * **Edge Case:** If $n = 0$, filtering out zeros leaves an empty set. We must handle this to avoid conversion errors or returning an incorrect result (the answer should be 0).
+
+**High-level approach**
+The most readable way to handle digits is to treat the number as a string. We convert the number to text, filter out the characters equal to `'0'`, and then perform two parallel operations on the remaining digits: concatenate them to form a new number $x$, and sum them to form $s$.
+
+**Brute force vs. optimized strategy**
+
+  * **Mathematical Approach:** We could use a loop with `% 10` and `/ 10` to extract digits. While memory-efficient, this logic is verbose because we extract digits in reverse order (right-to-left), requiring us to reverse them back for concatenation.
+  * **String Approach:** Converting to a string allows strictly left-to-right processing using Python's powerful list comprehensions. This is $O(\log n)$ (proportional to the number of digits) and extremely clean.
+
+**Decomposition**
+
+1.  **String Conversion:** Turn integer $n$ into string `s`.
+2.  **Filter:** Create a list of digits excluding `'0'`.
+3.  **Reconstruct:** Join the list to form the integer $x$.
+4.  **Sum:** Calculate the sum of the digits.
+5.  **Compute:** Return $x \times \text{sum}$.
+
+### Steps
+
+1.  **Convert and Filter**
+    Convert the input integer `n` to a string. Iterate through this string and collect only the characters that are not `'0'`.
+
+2.  **Handle Zeros**
+    Check if our list of filtered digits is empty. This happens if the input was `0`. In this case, return `0` immediately.
+
+3.  **Form the Number (Concatenation)**
+    Use the string `join` method to combine the filtered characters back into a single string, then convert that string into an integer. Let's call this `x`.
+
+4.  **Calculate Digit Sum**
+    Iterate through the filtered list again (or use a generator), convert each character to an integer, and sum them up.
+
+5.  **Return Result**
+    Multiply `x` by the sum and return the result.

explanations/3754/en.md

@@ -0,0 +1,51 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Array Size:** Typically up to $10^5$.
+  * **Time Complexity:** Since we are looking for a subarray, a nested loop approach (Brute Force) would be $O(N^2)$, which is too slow. We need a linear $O(N)$ pass.
+  * **Edge Case:** A valid subarray might start from the very beginning (index 0). We need to handle this by initializing our state tracking with a "dummy" start point.
+
+**High-level approach**
+We are looking for a subarray that satisfies two conditions simultaneously: `XOR sum == 0` and `Odd Count == Even Count`.
+We can track the "state" of the array at every index using **Prefix Logic**. If the state at index `i` is identical to the state at index `j` (where `j < i`), then the subarray between them (`j+1` to `i`) has "zeroed out" the changes, satisfying our conditions.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** Iterate through every possible starting point `i` and ending point `j`, calculate the XOR and count odds/evens. This is inefficient.
+  * **Optimized:** We use a Hash Map (Dictionary) to store the **first time** we encounter a specific state. As we iterate, if we see that state again, the distance between the current index and the stored index is a candidate for the maximum length.
+
+**Decomposition**
+
+1.  **Track XOR:** Maintain a running XOR of all numbers seen so far.
+2.  **Track Balance:** Maintain a running "balance" score. Add 1 for an odd number, subtract 1 for an even number. If the balance doesn't change between two indices, the number of odds and evens added in between must be equal.
+3.  **Map States:** Store the tuple `(current_xor, current_balance)` in a dictionary mapping to its index.
+
+### Steps
+
+1.  **Initialize Variables**
+    We need `curr_xor` (starts at 0) and `balance` (starts at 0).
+    We create a dictionary `seen` to store the first index where a specific state occurred.
+
+      * *Crucial Step:* Initialize `seen[(0, 0)] = -1`. This represents the state before we start reading the array. It ensures that if a valid subarray starts at index 0, we can calculate its length correctly (`current_index - (-1)`).
+
+2.  **Iterate Through the Array**
+    Loop through `nums` using the index `i` and the value `num`.
+
+3.  **Update State**
+
+      * Update `curr_xor` by XORing it with `num`.
+      * Check if `num` is odd or even:
+          * If **Odd**: Increment `balance` (+1).
+          * If **Even**: Decrement `balance` (-1).
+      * *Concept:* The specific value of `balance` doesn't matter (it could be -5 or +100). What matters is that `balance` at index `i` equals `balance` at index `j`. This proves that between `j` and `i`, the net change in odd/even ratio is zero.
+
+4.  **Check Dictionary**
+    Create a key: `state = (curr_xor, balance)`.
+
+      * **If `state` is already in `seen`:** This means we have encountered this exact scenario before. The subarray between the previous occurrence and now is valid.
+          * Calculate `length = i - seen[state]`.
+          * Update our result `res` if this length is the new maximum.
+      * **If `state` is NOT in `seen`:** This is the first time we've encountered this particular combination of XOR and Balance. Store it: `seen[state] = i`.

explanations/3755/en.md

@@ -0,0 +1,54 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+We are dealing with string lengths ($n$) and query counts ($q$) up to 100,000.
+
+  * **Time Complexity:** A solution that loops through the substring for every query will be $O(n \cdot q)$, which is far too slow. We need an $O(1)$ solution per query.
+  * **Large Numbers:** The resulting numbers can be massive. We must apply modulo $10^9 + 7$ at every addition or multiplication step.
+  * **Zeros:** The problem asks us to ignore zeros. If a range contains only zeros, our logic needs to handle returning 0 gracefully.
+
+**High-level approach**
+We will use the **Prefix Sum** technique, adapted for string concatenation. Instead of just summing numbers, we will maintain a "rolling hash" or "prefix value" that represents the integer formed by the string up to index $i$. To get a specific substring's value, we take the total value up to the end of the range and mathematically "subtract" the prefix before the range.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** For each query, slice the string `s[l:r+1]`, filter out '0', parse to int, and multiply. This involves heavy string manipulation inside a loop.
+  * **Optimized:** Precompute three arrays: one for the concatenated value, one for the count of non-zero digits, and one for the simple sum of digits. We can then solve any query instantly using modular arithmetic.
+
+**Decomposition**
+
+1.  **Map the Data:** Create prefix arrays that track the state of the string (value, count, sum) at every index.
+2.  **Precompute Powers:** Calculate powers of 10 beforehand so we can "shift" numbers left efficiently.
+3.  **Query Logic:** For each query, use the prefix arrays to isolate the target number and calculate the final result.
+
+### Steps
+
+1.  **Initialize Prefix Arrays**
+    We need three arrays of size $N+1$. We use $N+1$ to make 1-based indexing easier (index $i$ represents the state *after* processing character $i-1$).
+
+      * `p_val`: The integer value of all non-zero digits concatenated so far.
+      * `p_cnt`: The total count of non-zero digits encountered so far.
+      * `p_sum`: The simple arithmetic sum of non-zero digits so far.
+
+2.  **Build the Prefixes**
+    Iterate through the string `s`.
+
+      * If the character is `'0'`, the state doesn't change. Copy the values from index $i$ to $i+1$.
+      * If it's a non-zero digit $d$:
+          * Update sum: `new_sum = old_sum + d`.
+          * Update count: `new_cnt = old_count + 1`.
+          * Update value: Append the digit by shifting the old value left (multiply by 10) and adding $d$. Formula: `(old_val * 10 + d) % MOD`.
+
+3.  **Precompute Powers of 10**
+    To perform the "subtraction" logic later, we need to know what $10^k$ is for any $k$. Since we are working with modular arithmetic, we cannot just use `10 ** k` inside the loop (it's too slow). We precompute an array `pow10` where `pow10[k]` holds $10^k \pmod M$.
+
+4.  **Calculate Query Results**
+    For each query `[l, r]`:
+
+      * **Step A (Simple Stats):** Calculate the number of non-zero digits (`cnt`) and their sum (`d_sum`) by subtracting the value at index $l$ from the value at index $r+1$.
+      * **Step B (Extract Number):** We have the full prefix ending at `r` (`full`) and the prefix ending before `l` (`prev`). To isolate the middle part, we must subtract `prev` from `full`.
+      * *Crucial Logic:* To align them correctly, `prev` must be shifted left by `cnt` positions.
+      * Formula: `target = (full - (prev * pow10[cnt])) % MOD`.
+      * **Step C:** Multiply `target` by `d_sum` and store it in `res`.

explanations/3756/en.md

@@ -0,0 +1,20 @@
+class Solution:
+    def minimumFlips(self, n: int) -> int:
+        # Convert n to binary string, slicing off the "0b" prefix
+        s = bin(n)[2:]
+
+        res = 0
+        l = 0
+        r = len(s) - 1
+
+        # Use two pointers to compare symmetric bits
+        while l < r:
+            # If the bits at the symmetric positions are different
+            # we need to flip both to make the number equal to its reverse.
+            if s[l] != s[r]:
+                res += 2
+
+            l += 1
+            r -= 1
+
+        return res

solutions/3750/01.py

@@ -0,0 +1,39 @@
+class Solution:
+    def __init__(self):
+        # We precompute the values up to 100,000 (limit from problem constraints)
+        MAX_N = 100000
+        self.prefix = [0] * (MAX_N + 1)
+
+        running_total = 0
+
+        for i in range(MAX_N + 1):
+            waviness = 0
+            s = str(i)
+
+            # Only numbers with 3 or more digits can have waviness
+            if len(s) >= 3:
+                for j in range(1, len(s) - 1):
+                    prev_d = int(s[j-1])
+                    curr_d = int(s[j])
+                    next_d = int(s[j+1])
+
+                    # Check for Peak (prev < curr > next)
+                    if prev_d < curr_d and curr_d > next_d:
+                        waviness += 1
+                    # Check for Valley (prev > curr < next)
+                    elif prev_d > curr_d and curr_d < next_d:
+                        waviness += 1
+
+            running_total += waviness
+            self.prefix[i] = running_total
+
+    def totalWaviness(self, num1: int, num2: int) -> int:
+        # Standard prefix sum range query formula:
+        # Sum(L, R) = Prefix[R] - Prefix[L-1]
+
+        upper = self.prefix[num2]
+        lower = self.prefix[num1 - 1] if num1 > 0 else 0
+
+        res = upper - lower
+        return res
+

solutions/3751/01.py

@@ -0,0 +1,44 @@
+class Solution:
+    def lexSmallestNegatedPerm(self, n: int, target: int) -> list[int]:
+        # 1. Calculate the maximum possible sum (all positives)
+        total_sum = n * (n + 1) // 2
+
+        # 2. Check Feasibility (Bounds AND Parity)
+        # BUG FIX: We must check if target is smaller than the minimum possible sum (-total_sum)
+        if target < -total_sum or target > total_sum:
+            return []
+
+        diff = total_sum - target
+
+        if diff % 2 != 0:
+            return []
+
+        # 3. Calculate "Negative Budget"
+        # This is the sum of the subset of numbers we must flip to negative
+        negative_budget = diff // 2
+
+        is_negative = [False] * (n + 1)
+
+        # 4. Greedy Selection: Pick largest numbers first
+        for i in range(n, 0, -1):
+            if i <= negative_budget:
+                is_negative[i] = True
+                negative_budget -= i
+
+        # Safety check: If we couldn't spend the full budget, it's impossible
+        # (Though with the bounds check above, this is mathematically guaranteed for 1..n)
+        if negative_budget != 0:
+            return []
+
+        res = []
+        for i in range(1, n + 1):
+            if is_negative[i]:
+                res.append(-i)
+            else:
+                res.append(i)
+
+        # 5. Sort to ensure lexicographically smallest order
+        res.sort()
+
+        return res
+