chore(docs): sync doc metadata [skip ci]

Author: longsizhuo

app/docs/CommunityShare/Leetcode/9021_TUT_3_25T1.md

@@ -2,22 +2,24 @@
 title: 9021_TUT_3_25T1.md
 date: 2025/3/07
 tags:
-  - '9021'
+  - "9021"
   - lab
 abbrlink: 974decd3
+docId: s0cadbu09dgu54q0zxttkx7z
 ---
 
 # Exercise 1
 
 ### Problem Description:
+
 You are given two integers, `m` and `n`, where:
 
 - `m` represents the number of repeated units (patterns).
 - `n` represents the number of elements (underscores) within each unit.
 
 The goal is to generate a string where:
 
-- Each unit contains `n` underscores (_), separated by `|`.
+- Each unit contains `n` underscores (\_), separated by `|`.
 - These units are then concatenated together, separated by `*`.
 
 ### My Solution:
@@ -57,7 +59,6 @@ In summary, my solution focuses on modularity by breaking down the problem into
 
 # Exercise 2
 
-
 ### Problem Description:
 
 The goal is to generate a pattern based on the digits of a given number n. Specifically:
@@ -82,19 +83,17 @@ def f2(n):
 #### My Thought Process:
 
 1. Loop through each digit:
-Convert the number n to a string to iterate over each digit individually.
+   Convert the number n to a string to iterate over each digit individually.
 
 2. Check if the digit is even or odd:
-Convert each digit back to an integer and use the modulus operator (% 2) to check if the digit is even or odd.
+   Convert each digit back to an integer and use the modulus operator (% 2) to check if the digit is even or odd.
 
 3. Append the corresponding square:
    - If the digit is even, append a white square (⬜) to the result string.
    - If the digit is odd, append a black square (⬛).
 
 4. Print the final string:
-After processing all the digits, print the final string containing black and white squares.
-
-
+   After processing all the digits, print the final string containing black and white squares.
 
 ### Standard Solution:
 
@@ -104,6 +103,7 @@ def f2(n):
 ```
 
 Dr.Martin's solution is:
+
 1. More compact and Pythonic.
 2. Uses a dictionary and list comprehension for brevity and efficiency.
 3. The Unicode characters for the squares are referenced directly using their escape sequences (`\u2b1c` for white, `\u2b1b` for black).
@@ -115,9 +115,10 @@ Dr.Martin's solution is:
 In this task, the number `n` is treated as a number expressed in different bases (ranging from 2 to 10), and we aim to convert it into its corresponding base 10 value for each of these bases, where the conversion is valid.
 
 For n = 2143:
-   - `2143` in base `5` is equivalent to `298` in base `10`.
-   - `2143` in base `6` is equivalent to `495` in base `10`.
-   - And so on.
+
+- `2143` in base `5` is equivalent to `298` in base `10`.
+- `2143` in base `6` is equivalent to `495` in base `10`.
+- And so on.
 
 The goal is to iterate over different base systems from 2 to 10, treat the input number `n` as if it is expressed in each base, and then convert it to base 10.
 
@@ -133,7 +134,9 @@ def f3(n: int):
         except ValueError:
             pass
 ```
+
 #### My Thought Process:
+
 1. Iterating over Bases (2 to 10):
    - We loop through the base values i ranging from 2 to 10.
 
@@ -146,16 +149,16 @@ def f3(n: int):
    - The `try-except` block ensures that invalid bases are skipped, allowing us to handle cases where the digits in `n` are not valid for a particular base.
 
 ### Standard Solution:
-    
+
 ```python
 def f3(n):
     n_as_string = str(n)
     min_base = max(2, max({int(d) for d in n_as_string}) + 1)
     for b in range(min_base, 11):
         print(f'{n} is {int(n_as_string, b)} in base {b}')
 ```
-It skips the bases where the digits in n are not valid, and it uses a set comprehension to extract the unique digits from n_as_string. The maximum digit is then used to determine the minimum base to start iterating from.
 
+It skips the bases where the digits in n are not valid, and it uses a set comprehension to extract the unique digits from n_as_string. The maximum digit is then used to determine the minimum base to start iterating from.
 
 # Exercise 4
 
@@ -194,23 +197,25 @@ def f4(n: int, base: int):
    - After collecting all digits, we reverse the list and return it as a string.
 
 2. Main Function `f4(n, base)`:
-We initialize an empty dictionary `D`.
-For each number `i` from `0` to `n`, we convert `i` to the given base using `convert_to_base()`.
-The converted base digits are then mapped to integers and stored in a tuple as the value for each key `i` in the dictionary.
+   We initialize an empty dictionary `D`.
+   For each number `i` from `0` to `n`, we convert `i` to the given base using `convert_to_base()`.
+   The converted base digits are then mapped to integers and stored in a tuple as the value for each key `i` in the dictionary.
 
 ### Explanation of Why `map()` is not Pythonic:
+
 In the function f4, the use of `map(int, convert_to_base(i, base))` applies the `int` function
 to each element of the result from `convert_to_base`, effectively converting each character to an integer.
 
 However, it's worth noting that the `map()` function, which originates from functional programming,
 has largely been superseded by more Pythonic constructs such as list comprehensions.
 
 These comprehensions are generally considered superior for several reasons:
-  - They are more elegant and concise.
-  - They tend to be shorter in terms of syntax, making the code easier to read.
-  - They are easier to understand for most people, especially those who are more familiar with Python's
-    standard syntax rather than functional programming constructs.
-  - In many cases, they are also more efficient in terms of performance.
+
+- They are more elegant and concise.
+- They tend to be shorter in terms of syntax, making the code easier to read.
+- They are easier to understand for most people, especially those who are more familiar with Python's
+  standard syntax rather than functional programming constructs.
+- In many cases, they are also more efficient in terms of performance.
 
 For example, instead of using `map(int, ...)`, the same functionality could be achieved with a
 list comprehension, like so:
@@ -240,9 +245,11 @@ whereas the standard solution is more concise and directly integrates the conver
 # Exercise 5
 
 At the first, try to run this:
+
 ```python
 print(0.1 + 0.2)
 ```
+
 What happened? The result is not 0.3, but 0.30000000000000004. Why?
 
 ### Problem Description:
@@ -252,6 +259,7 @@ The approach we are using in this exercise is designed to expose the limitations
 This problem can seem complex, and it's designed to highlight the subtleties of floating-point arithmetic. Let's walk through the logic using the test cases to figure out what the function does.
 
 ### Key Concepts:
+
 - **Floating-point numbers**: Computers store floating-point numbers using a binary format, which often introduces precision errors.
 - **Precision**: We’re working with two types of precision in this function—simple precision (same as the length of the fractional part) and double precision (twice that length).
 
@@ -261,22 +269,22 @@ This problem can seem complex, and it's designed to highlight the subtleties of
 def f5(integral_part, fractional_part):
     # Calculate the number of digits in the fractional part
     precision = len(str(fractional_part))
-    
+
     # Concatenate the integral and fractional parts as strings, then convert to a float
     a_float = float(str(integral_part) + '.' + str(fractional_part))
-    
+
     # Format the float with precision equal to the number of digits in the fractional part (simple precision)
     simple_precision = f'{a_float:.{precision}f}'
-    
+
     # Append a number of zeros equal to the fractional part length to the simple precision value (extended precision)
     extended_simple_precision = simple_precision + '0' * precision
-    
+
     # Format the float with precision equal to twice the number of fractional digits (double precision)
     double_precision = f'{a_float:.{precision * 2}f}'
-    
+
     # Print the first part of the output
     print('With', precision * 2, 'digits after the decimal point, ', end='')
-    
+
     # Compare if extended precision and double precision values are the same
     if extended_simple_precision == double_precision:
         # If they are the same, it means the float is precise and has trailing zeros
@@ -307,6 +315,7 @@ We are required to sort the list L by using a multi-key sorting mechanism, where
 - Finally, if required, the sorting proceeds up to the last field in `fields`.
 
 ### Example of Fields Explanation:
+
 If `fields = [2, 1]`, it means:
 
 1. First, sort based on the second element of each sublist.
@@ -320,39 +329,43 @@ def f6(L, fields):
 ```
 
 1. Sorting with sorted():
-The `sorted()` function is used to sort the list `L`.
-The key parameter defines how the sorting will be performed.
+   The `sorted()` function is used to sort the list `L`.
+   The key parameter defines how the sorting will be performed.
 
 2. Lambda Function:
-The lambda function defines how the sublists will be sorted. It generates a list of values for each sublist based on the positions specified in `fields`.
-For example, if `fields = [2, 1]`, the lambda function will extract the second and first elements from each sublist in that order, and sorting will be done based on this new list.
+   The lambda function defines how the sublists will be sorted. It generates a list of values for each sublist based on the positions specified in `fields`.
+   For example, if `fields = [2, 1]`, the lambda function will extract the second and first elements from each sublist in that order, and sorting will be done based on this new list.
 
 3. Key Structure:
-The key is a list of elements from each sublist, indexed by the positions specified in fields. We use `x[i - 1]` because fields is `1-based`, and list indexing in Python is `0-based`.
+   The key is a list of elements from each sublist, indexed by the positions specified in fields. We use `x[i - 1]` because fields is `1-based`, and list indexing in Python is `0-based`.
 
 4. What is Lambda Function?
 
 For example:
 
 We have:
+
 ```python
 f = lambda x: x * x
 ```
 
 This is equivalent to:
+
 ```python
 def f(x):
     return x * x
 ```
 
 And lambda function in a sorted function is used to define a custom sorting key.
+
 ```python
 L = [(1,2), (3,1), (5,0)]
 
 SortedL = sorted(L, key=lambda x: x[1])
 
 print(SortedL)
 ```
+
 The result is: `[(5, 0), (3, 1), (1, 2)]`, it sorts the list based on the second element of each tuple.
 
 ### Standard Solution:

generated/doc-contributors.json

@@ -1,8 +1,8 @@
 {
   "repo": "InvolutionHell/involutionhell",
-  "generatedAt": "2025-11-26T03:06:32.553Z",
+  "generatedAt": "2025-11-27T03:05:27.753Z",
   "docsDir": "app/docs",
-  "totalDocs": 124,
+  "totalDocs": 125,
   "results": [
     {
       "docId": "ue27z7z95yzw3lhhfj7nit1c",
@@ -2123,13 +2123,13 @@
       "docId": "chb8ee5s38v8gh751n9e5znj",
       "path": "app/docs/CommunityShare/Leetcode/1828统计一个圆中点的数目_translated.md",
       "contributorStats": {
-        "114939201": 1
+        "114939201": 2
       },
       "contributors": [
         {
           "githubId": "114939201",
-          "contributions": 1,
-          "lastContributedAt": "2025-11-26T03:00:05.000Z",
+          "contributions": 2,
+          "lastContributedAt": "2025-11-26T03:06:33.000Z",
           "login": "longsizhuo",
           "avatarUrl": "https://avatars.githubusercontent.com/u/114939201?v=4",
           "htmlUrl": "https://github.com/longsizhuo"
@@ -2272,6 +2272,23 @@
         }
       ]
     },
+    {
+      "docId": "s0cadbu09dgu54q0zxttkx7z",
+      "path": "app/docs/CommunityShare/Leetcode/9021_TUT_3_25T1.md",
+      "contributorStats": {
+        "114939201": 1
+      },
+      "contributors": [
+        {
+          "githubId": "114939201",
+          "contributions": 1,
+          "lastContributedAt": "2025-11-27T03:00:16.000Z",
+          "login": "longsizhuo",
+          "avatarUrl": "https://avatars.githubusercontent.com/u/114939201?v=4",
+          "htmlUrl": "https://github.com/longsizhuo"
+        }
+      ]
+    },
     {
       "docId": "d5evrnoglwjvmyginjq84bl0",
       "path": "app/docs/CommunityShare/Leetcode/93复原Ip地址.md",