Fix table formatting in explanations

vikahaze · vikahaze · commit 64f72bdb8135 · 2025-12-11T12:25:25.000+02:00
diff --git a/explanations/3531/en.md b/explanations/3531/en.md
@@ -48,13 +48,13 @@ We check each building to see if it's covered.
 
 **2.3 Trace Walkthrough:**
 
-| Step | Building | x-group | y-group | Above? | Below? | Left? | Right? | Covered? |
-|------|----------|---------|---------|--------|--------|-------|--------|----------|
-| 1    | [1,2]    | [2]     | [1,2,3] | No (min=2) | No (max=2) | No (min=1) | Yes (max=3) | No |
-| 2    | [2,2]    | [1,2,3] | [1,2,3] | Yes (min=1<2) | Yes (max=3>2) | Yes (min=1<2) | Yes (max=3>2) | Yes |
-| 3    | [3,2]    | [2]     | [1,2,3] | No (min=2) | No (max=2) | Yes (min=1<3) | No (max=3) | No |
-| 4    | [2,1]    | [1,2,3] | [2]     | No (min=1) | Yes (max=3>1) | No (min=2) | No (max=2) | No |
-| 5    | [2,3]    | [1,2,3] | [2]     | Yes (min=1<3) | No (max=3) | No (min=2) | No (max=2) | No |
+| Step | Building | x-group | y-group | Above?        | Below?        | Left?         | Right?        | Covered? |
+| ---- | -------- | ------- | ------- | ------------- | ------------- | ------------- | ------------- | -------- |
+| 1    | [1,2]    | [2]     | [1,2,3] | No (min=2)    | No (max=2)    | No (min=1)    | Yes (max=3)   | No       |
+| 2    | [2,2]    | [1,2,3] | [1,2,3] | Yes (min=1<2) | Yes (max=3>2) | Yes (min=1<2) | Yes (max=3>2) | Yes      |
+| 3    | [3,2]    | [2]     | [1,2,3] | No (min=2)    | No (max=2)    | Yes (min=1<3) | No (max=3)    | No       |
+| 4    | [2,1]    | [1,2,3] | [2]     | No (min=1)    | Yes (max=3>1) | No (min=2)    | No (max=2)    | No       |
+| 5    | [2,3]    | [1,2,3] | [2]     | Yes (min=1<3) | No (max=3)    | No (min=2)    | No (max=2)    | No       |
 
 At step 2, building [2,2] is covered because it has buildings in all four directions.
 
diff --git a/explanations/3702/en.md b/explanations/3702/en.md
@@ -47,11 +47,11 @@ We calculate the XOR of all elements: `total_xor = 1 XOR 2 XOR 3 = 0`.
 
 **2.3 Trace Walkthrough:**
 
-| Step | Action | total_xor | Result |
-|------|--------|-----------|--------|
-| 1    | Calculate total XOR | 1 XOR 2 XOR 3 = 0 | - |
-| 2    | Check if non-zero | 0 (zero) | Try removing elements |
-| 3    | Remove nums[0]=1 | 0 XOR 1 = 1 | Found! Return 2 |
+| Step | Action              | total_xor         | Result                |
+| ---- | ------------------- | ----------------- | --------------------- |
+| 1    | Calculate total XOR | 1 XOR 2 XOR 3 = 0 | -                     |
+| 2    | Check if non-zero   | 0 (zero)          | Try removing elements |
+| 3    | Remove nums[0]=1    | 0 XOR 1 = 1       | Found! Return 2       |
 
 At step 3, we find that removing element 1 gives XOR = 1 (non-zero), so we return n-1 = 2.
 
diff --git a/explanations/3703/en.md b/explanations/3703/en.md
@@ -46,10 +46,10 @@ We process each character in the string, grouping consecutive characters.
 
 **2.3 Trace Walkthrough:**
 
-| Step | char | st before | st after | Action |
-|------|------|-----------|----------|--------|
-| 1    | '('  | []        | [['(',1]] | Add new group |
-| 2    | '('  | [['(',1]] | [['(',2]] | Increment count |
+| Step | char | st before | st after          | Action                                                |
+| ---- | ---- | --------- | ----------------- | ----------------------------------------------------- |
+| 1    | '('  | []        | [['(',1]]         | Add new group                                         |
+| 2    | '('  | [['(',1]] | [['(',2]]         | Increment count                                       |
 | 3    | ')'  | [['(',2]] | [['(',2],[')',1]] | Add new group, check: remove k=1 from '(', remove ')' |
 | 4    | ')'  | [['(',1]] | [['(',1],[')',1]] | Add new group, check: remove k=1 from '(', remove ')' |
 
diff --git a/explanations/3708/en.md b/explanations/3708/en.md
@@ -48,14 +48,14 @@ We iterate from index 2 onwards, checking if each element extends the Fibonacci
 
 **2.3 Trace Walkthrough:**
 
-| Step | i | nums[i] | nums[i-1]+nums[i-2] | Match? | current_length | res |
-|------|---|---------|---------------------|--------|----------------|-----|
-| 1    | 2 | 1       | 1+1=2               | No     | 2              | 2   |
-| 2    | 3 | 1       | 1+1=2               | No     | 2              | 2   |
-| 3    | 4 | 2       | 1+1=2               | Yes    | 3              | 2   |
-| 4    | 5 | 3       | 2+1=3               | Yes    | 4              | 2   |
-| 5    | 6 | 5       | 3+2=5               | Yes    | 5              | 2   |
-| 6    | 7 | 1       | 5+3=8               | No     | 2              | 5   |
+| Step | i   | nums[i] | nums[i-1]+nums[i-2] | Match? | current_length | res |
+| ---- | --- | ------- | ------------------- | ------ | -------------- | --- |
+| 1    | 2   | 1       | 1+1=2               | No     | 2              | 2   |
+| 2    | 3   | 1       | 1+1=2               | No     | 2              | 2   |
+| 3    | 4   | 2       | 1+1=2               | Yes    | 3              | 2   |
+| 4    | 5   | 3       | 2+1=3               | Yes    | 4              | 2   |
+| 5    | 6   | 5       | 3+2=5               | Yes    | 5              | 2   |
+| 6    | 7   | 1       | 5+3=8               | No     | 2              | 5   |
 
 At step 5, we find the longest Fibonacci subarray [1, 1, 2, 3, 5] with length 5.
 
diff --git a/explanations/3709/en.md b/explanations/3709/en.md
@@ -52,11 +52,11 @@ We record exams and update our data structures.
 
 **2.3 Trace Walkthrough:**
 
-| Step | Operation | times | scores | prefix_sum | Result |
-|------|-----------|-------|--------|------------|--------|
-| 1    | record(1,98) | [1] | [98] | [0,98] | - |
-| 2    | totalScore(1,1) | [1] | [98] | [0,98] | 98 (prefix_sum[1]-prefix_sum[0]) |
-| 3    | record(5,99) | [1,5] | [98,99] | [0,98,197] | - |
+| Step | Operation       | times | scores  | prefix_sum | Result                            |
+| ---- | --------------- | ----- | ------- | ---------- | --------------------------------- |
+| 1    | record(1,98)    | [1]   | [98]    | [0,98]     | -                                 |
+| 2    | totalScore(1,1) | [1]   | [98]    | [0,98]     | 98 (prefix_sum[1]-prefix_sum[0])  |
+| 3    | record(5,99)    | [1,5] | [98,99] | [0,98,197] | -                                 |
 | 4    | totalScore(1,5) | [1,5] | [98,99] | [0,98,197] | 197 (prefix_sum[2]-prefix_sum[0]) |
 
 At step 4, binary search finds left=0 (first time >= 1) and right=2 (first time > 5), so we return prefix_sum[2] - prefix_sum[0] = 197.
diff --git a/explanations/3713/en.md b/explanations/3713/en.md
@@ -47,13 +47,13 @@ We iterate through each starting position i from 0 to n-1.
 
 **2.3 Trace Walkthrough:**
 
-| Step | i | j | s[j] | char_count | distinct_chars | counts | Balanced? | res |
-|------|---|---|------|------------|----------------|--------|-----------|-----|
-| 1    | 0 | 0 | 'a'  | {a:1}      | ['a']          | [1]    | Yes       | 1   |
-| 2    | 0 | 1 | 'b'  | {a:1,b:1}  | ['a','b']      | [1,1]  | Yes       | 2   |
-| 3    | 0 | 2 | 'b'  | {a:1,b:2}  | ['a','b']      | [1,2]  | No        | 2   |
-| 4    | 0 | 3 | 'a'  | {a:2,b:2}  | ['a','b']      | [2,2]  | Yes       | 4   |
-| 5    | 0 | 4 | 'c'  | {a:2,b:2,c:1} | ['a','b','c'] | [2,2,1] | No        | 4   |
+| Step | i   | j   | s[j] | char_count    | distinct_chars | counts  | Balanced? | res |
+| ---- | --- | --- | ---- | ------------- | -------------- | ------- | --------- | --- |
+| 1    | 0   | 0   | 'a'  | {a:1}         | ['a']          | [1]     | Yes       | 1   |
+| 2    | 0   | 1   | 'b'  | {a:1,b:1}     | ['a','b']      | [1,1]   | Yes       | 2   |
+| 3    | 0   | 2   | 'b'  | {a:1,b:2}     | ['a','b']      | [1,2]   | No        | 2   |
+| 4    | 0   | 3   | 'a'  | {a:2,b:2}     | ['a','b']      | [2,2]   | Yes       | 4   |
+| 5    | 0   | 4   | 'c'  | {a:2,b:2,c:1} | ['a','b','c']  | [2,2,1] | No        | 4   |
 
 At step 4, we find the longest balanced substring "abba" with length 4, where both 'a' and 'b' appear twice.
 
diff --git a/explanations/3714/en.md b/explanations/3714/en.md
@@ -48,14 +48,14 @@ We iterate through each prefix position i from 0 to n.
 
 **2.3 Trace Walkthrough:**
 
-| Step | i | (a,b,c) | Case | Key | Check first | res |
-|------|---|---------|------|-----|-------------|-----|
-| 1    | 0 | (0,0,0) | All  | ("abc",0,0) | i=0 stored | 0   |
-| 2    | 1 | (1,0,0) | All  | ("abc",1,1) | i=1 stored | 0   |
-| 3    | 2 | (1,1,0) | All  | ("abc",0,1) | i=2 stored | 0   |
-| 4    | 3 | (1,2,0) | All  | ("abc",-1,1) | i=3 stored | 0   |
-| 5    | 4 | (2,2,0) | All  | ("abc",0,2) | Found i=2 | 2   |
-| 6    | 4 | (2,2,0) | ab   | ("ab",0,0) | Found i=0 | 4   |
+| Step | i   | (a,b,c) | Case | Key          | Check first | res |
+| ---- | --- | ------- | ---- | ------------ | ----------- | --- |
+| 1    | 0   | (0,0,0) | All  | ("abc",0,0)  | i=0 stored  | 0   |
+| 2    | 1   | (1,0,0) | All  | ("abc",1,1)  | i=1 stored  | 0   |
+| 3    | 2   | (1,1,0) | All  | ("abc",0,1)  | i=2 stored  | 0   |
+| 4    | 3   | (1,2,0) | All  | ("abc",-1,1) | i=3 stored  | 0   |
+| 5    | 4   | (2,2,0) | All  | ("abc",0,2)  | Found i=2   | 2   |
+| 6    | 4   | (2,2,0) | ab   | ("ab",0,0)   | Found i=0   | 4   |
 
 At step 6, we find that positions 0 and 4 have the same (a-b, c) = (0, 0), meaning substring s[0:4] = "abba" is balanced for 'a' and 'b'.
 
diff --git a/explanations/3719/en.md b/explanations/3719/en.md
@@ -47,15 +47,15 @@ We iterate through each starting position i from 0 to n-1.
 
 **2.3 Trace Walkthrough:**
 
-| Step | i | j | nums[j] | even_set | odd_set | Balanced? | res |
-|------|---|---|---------|----------|---------|-----------|-----|
-| 1    | 0 | 0 | 2       | {2}      | {}      | No        | 0   |
-| 2    | 0 | 1 | 5       | {2}      | {5}     | Yes (1==1)| 2   |
-| 3    | 0 | 2 | 4       | {2,4}    | {5}     | No        | 2   |
-| 4    | 0 | 3 | 3       | {2,4}    | {5,3}   | Yes (2==2)| 4   |
-| 5    | 1 | 1 | 5       | {}       | {5}     | No        | 4   |
-| 6    | 1 | 2 | 4       | {4}      | {5}     | Yes (1==1)| 4   |
-| 7    | 1 | 3 | 3       | {4}      | {5,3}   | No        | 4   |
+| Step | i   | j   | nums[j] | even_set | odd_set | Balanced?  | res |
+| ---- | --- | --- | ------- | -------- | ------- | ---------- | --- |
+| 1    | 0   | 0   | 2       | {2}      | {}      | No         | 0   |
+| 2    | 0   | 1   | 5       | {2}      | {5}     | Yes (1==1) | 2   |
+| 3    | 0   | 2   | 4       | {2,4}    | {5}     | No         | 2   |
+| 4    | 0   | 3   | 3       | {2,4}    | {5,3}   | Yes (2==2) | 4   |
+| 5    | 1   | 1   | 5       | {}       | {5}     | No         | 4   |
+| 6    | 1   | 2   | 4       | {4}      | {5}     | Yes (1==1) | 4   |
+| 7    | 1   | 3   | 3       | {4}      | {5,3}   | No         | 4   |
 
 At step 4, we find the longest balanced subarray [2, 5, 4, 3] with length 4.
 
diff --git a/explanations/3720/en.md b/explanations/3720/en.md
@@ -48,14 +48,14 @@ We call `backtrack([], cnt, False)` to start building the permutation.
 
 **2.3 Trace Walkthrough:**
 
-| Step | pos | char tried | big | path | Action |
-|------|-----|------------|-----|------|--------|
-| 1    | 0   | 'a'        | False | ['a'] | Skip (a < 'b') |
-| 2    | 0   | 'b'        | False | ['b'] | Continue (b == 'b') |
-| 3    | 1   | 'a'        | False | ['b','a'] | Skip (ba < bba) |
-| 4    | 1   | 'b'        | False | ['b','b'] | Continue (bb == bb) |
+| Step | pos | char tried | big   | path          | Action               |
+| ---- | --- | ---------- | ----- | ------------- | -------------------- |
+| 1    | 0   | 'a'        | False | ['a']         | Skip (a < 'b')       |
+| 2    | 0   | 'b'        | False | ['b']         | Continue (b == 'b')  |
+| 3    | 1   | 'a'        | False | ['b','a']     | Skip (ba < bba)      |
+| 4    | 1   | 'b'        | False | ['b','b']     | Continue (bb == bb)  |
 | 5    | 2   | 'a'        | False | ['b','b','a'] | Skip (bba not > bba) |
-| 6    | 2   | 'c'        | True  | ['b','c'] | Found! Return "bca" |
+| 6    | 2   | 'c'        | True  | ['b','c']     | Found! Return "bca"  |
 
 At step 6, we find that "bca" > "bba", so we return it.
 
diff --git a/explanations/3724/en.md b/explanations/3724/en.md
@@ -48,10 +48,10 @@ We try each possible position j to append.
 
 **2.3 Trace Walkthrough:**
 
-| Step | j | nums1[j] | nums2[j] | last_target | current | median | adjust_cost | total | res |
-|------|---|----------|----------|-------------|---------|--------|-------------|-------|-----|
-| 1    | 0 | 2        | 1        | 3           | 2-1=1   | 2      | |2-2|+|1-2|+|3-2|=2 | 1+2+1=4 | 4 |
-| 2    | 1 | 8        | 7        | 3           | 2-1=1   | 7      | |8-7|+|7-7|+|3-7|=8 | 1+8+1=10 | 4 |
+| Step | j   | nums1[j] | nums2[j] | last_target | current | median | adjust_cost | total | res |
+| ---- | --- | -------- | -------- | ----------- | ------- | ------ | ----------- | ----- | --- |
+| 1    | 0   | 2        | 1        | 3           | 2-1=1   | 2      |             | 2-2   | +   | 1-2 | + | 3-2 | =2 | 1+2+1=4  | 4 |
+| 2    | 1   | 8        | 7        | 3           | 2-1=1   | 7      |             | 8-7   | +   | 7-7 | + | 3-7 | =8 | 1+8+1=10 | 4 |
 
 At step 1, we find the optimal cost is 4: adjust 2 to 2 (median), then adjust to 1 at position 0 and 3 at the end.
 
diff --git a/explanations/3728/en.md b/explanations/3728/en.md
@@ -48,13 +48,13 @@ We iterate through each position r from 0 to n-1, processing it as a potential r
 
 **2.3 Trace Walkthrough:**
 
-| Step | r | capacity[r] | Add to map? | required_prefix | Check map | res |
-|------|---|-------------|-------------|-----------------|-----------|-----|
-| 0    | 0 | 9           | No (r < 2)  | -               | -         | 0   |
-| 1    | 1 | 3           | No (r < 2)  | -               | -         | 0   |
-| 2    | 2 | 3           | Yes (l=0)   | 9 - 3 = 6       | (9, 9)?   | 0   |
-| 3    | 3 | 3           | Yes (l=1)   | 12 - 3 = 9      | (3, 9)?   | 0   |
-| 4    | 4 | 9           | Yes (l=2)   | 15 - 9 = 6      | (9, 6)?   | 1   |
+| Step | r   | capacity[r] | Add to map? | required_prefix | Check map | res |
+| ---- | --- | ----------- | ----------- | --------------- | --------- | --- |
+| 0    | 0   | 9           | No (r < 2)  | -               | -         | 0   |
+| 1    | 1   | 3           | No (r < 2)  | -               | -         | 0   |
+| 2    | 2   | 3           | Yes (l=0)   | 9 - 3 = 6       | (9, 9)?   | 0   |
+| 3    | 3   | 3           | Yes (l=1)   | 12 - 3 = 9      | (3, 9)?   | 0   |
+| 4    | 4   | 9           | Yes (l=2)   | 15 - 9 = 6      | (9, 6)?   | 1   |
 
 At step 4, we find that capacity[0] = 9 and prefix[1] = 9, which matches (9, 6) after rearranging. The subarray [0, 4] is stable: 9 == 9 and 9 == 3+3+3.
 
