diff --git a/src/main/python/g0001_0100/s0001_two_sum/readme.md b/src/main/python/g0001_0100/s0001_two_sum/readme.md
index e515ee9..a0051f3 100644
--- a/src/main/python/g0001_0100/s0001_two_sum/readme.md
+++ b/src/main/python/g0001_0100/s0001_two_sum/readme.md
@@ -40,8 +40,6 @@ You can return the answer in any order.
 
 **Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code> time complexity?
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0002_add_two_numbers/readme.md b/src/main/python/g0001_0100/s0002_add_two_numbers/readme.md
index 749dadb..6336e49 100644
--- a/src/main/python/g0001_0100/s0002_add_two_numbers/readme.md
+++ b/src/main/python/g0001_0100/s0002_add_two_numbers/readme.md
@@ -37,8 +37,6 @@ You may assume the two numbers do not contain any leading zero, except the numbe
 *   `0 <= Node.val <= 9`
 *   It is guaranteed that the list represents a number that does not have leading zeros.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0003_longest_substring_without_repeating_characters/readme.md b/src/main/python/g0001_0100/s0003_longest_substring_without_repeating_characters/readme.md
index c4c0ac7..b6336af 100644
--- a/src/main/python/g0001_0100/s0003_longest_substring_without_repeating_characters/readme.md
+++ b/src/main/python/g0001_0100/s0003_longest_substring_without_repeating_characters/readme.md
@@ -42,8 +42,6 @@ Given a string `s`, find the length of the **longest substring** without repeati
 *   <code>0 <= s.length <= 5 * 10<sup>4</sup></code>
 *   `s` consists of English letters, digits, symbols and spaces.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0004_median_of_two_sorted_arrays/readme.md b/src/main/python/g0001_0100/s0004_median_of_two_sorted_arrays/readme.md
index 252f5ea..8ecf2f2 100644
--- a/src/main/python/g0001_0100/s0004_median_of_two_sorted_arrays/readme.md
+++ b/src/main/python/g0001_0100/s0004_median_of_two_sorted_arrays/readme.md
@@ -52,8 +52,6 @@ The overall run time complexity should be `O(log (m+n))`.
 *   `1 <= m + n <= 2000`
 *   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0005_longest_palindromic_substring/readme.md b/src/main/python/g0001_0100/s0005_longest_palindromic_substring/readme.md
index e814ffc..5f1948a 100644
--- a/src/main/python/g0001_0100/s0005_longest_palindromic_substring/readme.md
+++ b/src/main/python/g0001_0100/s0005_longest_palindromic_substring/readme.md
@@ -36,8 +36,6 @@ Given a string `s`, return _the longest palindromic substring_ in `s`.
 *   `1 <= s.length <= 1000`
 *   `s` consist of only digits and English letters.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0006_zigzag_conversion/readme.md b/src/main/python/g0001_0100/s0006_zigzag_conversion/readme.md
index 75daaad..d68463a 100644
--- a/src/main/python/g0001_0100/s0006_zigzag_conversion/readme.md
+++ b/src/main/python/g0001_0100/s0006_zigzag_conversion/readme.md
@@ -41,8 +41,6 @@ string convert(string s, int numRows);
 *   `s` consists of English letters (lower-case and upper-case), `','` and `'.'`.
 *   `1 <= numRows <= 1000`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0007_reverse_integer/readme.md b/src/main/python/g0001_0100/s0007_reverse_integer/readme.md
index d75307f..0c659c9 100644
--- a/src/main/python/g0001_0100/s0007_reverse_integer/readme.md
+++ b/src/main/python/g0001_0100/s0007_reverse_integer/readme.md
@@ -37,8 +37,6 @@ Given a signed 32-bit integer `x`, return `x` _with its digits reversed_. If rev
 
 *   <code>-2<sup>31</sup> <= x <= 2<sup>31</sup> - 1</code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0008_string_to_integer_atoi/readme.md b/src/main/python/g0001_0100/s0008_string_to_integer_atoi/readme.md
index 2fb9c18..a09bda8 100644
--- a/src/main/python/g0001_0100/s0008_string_to_integer_atoi/readme.md
+++ b/src/main/python/g0001_0100/s0008_string_to_integer_atoi/readme.md
@@ -115,8 +115,6 @@ Since -91283472332 is less than the lower bound of the range [-2<sup>31</sup>, 2
 *   `0 <= s.length <= 200`
 *   `s` consists of English letters (lower-case and upper-case), digits (`0-9`), `' '`, `'+'`, `'-'`, and `'.'`.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0009_palindrome_number/readme.md b/src/main/python/g0001_0100/s0009_palindrome_number/readme.md
index 98bee6f..ce8ef8d 100644
--- a/src/main/python/g0001_0100/s0009_palindrome_number/readme.md
+++ b/src/main/python/g0001_0100/s0009_palindrome_number/readme.md
@@ -43,8 +43,6 @@ An integer is a **palindrome** when it reads the same backward as forward. For e
 
 **Follow up:** Could you solve it without converting the integer to a string?
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0010_regular_expression_matching/readme.md b/src/main/python/g0001_0100/s0010_regular_expression_matching/readme.md
index 4b3bec7..6b88f99 100644
--- a/src/main/python/g0001_0100/s0010_regular_expression_matching/readme.md
+++ b/src/main/python/g0001_0100/s0010_regular_expression_matching/readme.md
@@ -58,8 +58,6 @@ The matching should cover the **entire** input string (not partial).
 *   `p` contains only lowercase English letters, `'.'`, and `'*'`.
 *   It is guaranteed for each appearance of the character `'*'`, there will be a previous valid character to match.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0011_container_with_most_water/readme.md b/src/main/python/g0001_0100/s0011_container_with_most_water/readme.md
index 37925ef..bfa8287 100644
--- a/src/main/python/g0001_0100/s0011_container_with_most_water/readme.md
+++ b/src/main/python/g0001_0100/s0011_container_with_most_water/readme.md
@@ -43,8 +43,6 @@ Given `n` non-negative integers <code>a<sub>1</sub>, a<sub>2</sub>, ..., a<sub>n
 *   <code>2 <= n <= 10<sup>5</sup></code>
 *   <code>0 <= height[i] <= 10<sup>4</sup></code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0015_3sum/readme.md b/src/main/python/g0001_0100/s0015_3sum/readme.md
index 6178b83..1fc94b6 100644
--- a/src/main/python/g0001_0100/s0015_3sum/readme.md
+++ b/src/main/python/g0001_0100/s0015_3sum/readme.md
@@ -32,8 +32,6 @@ Notice that the solution set must not contain duplicate triplets.
 *   `0 <= nums.length <= 3000`
 *   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0017_letter_combinations_of_a_phone_number/readme.md b/src/main/python/g0001_0100/s0017_letter_combinations_of_a_phone_number/readme.md
index a6b7aac..bf13ee9 100644
--- a/src/main/python/g0001_0100/s0017_letter_combinations_of_a_phone_number/readme.md
+++ b/src/main/python/g0001_0100/s0017_letter_combinations_of_a_phone_number/readme.md
@@ -34,8 +34,6 @@ A mapping of digit to letters (just like on the telephone buttons) is given belo
 *   `0 <= digits.length <= 4`
 *   `digits[i]` is a digit in the range `['2', '9']`.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0019_remove_nth_node_from_end_of_list/readme.md b/src/main/python/g0001_0100/s0019_remove_nth_node_from_end_of_list/readme.md
index 657ef21..1f485b9 100644
--- a/src/main/python/g0001_0100/s0019_remove_nth_node_from_end_of_list/readme.md
+++ b/src/main/python/g0001_0100/s0019_remove_nth_node_from_end_of_list/readme.md
@@ -36,8 +36,6 @@ Given the `head` of a linked list, remove the `nth` node from the end of the lis
 
 **Follow up:** Could you do this in one pass?
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0020_valid_parentheses/readme.md b/src/main/python/g0001_0100/s0020_valid_parentheses/readme.md
index 4137fdc..1fa364b 100644
--- a/src/main/python/g0001_0100/s0020_valid_parentheses/readme.md
+++ b/src/main/python/g0001_0100/s0020_valid_parentheses/readme.md
@@ -47,8 +47,6 @@ An input string is valid if:
 *   <code>1 <= s.length <= 10<sup>4</sup></code>
 *   `s` consists of parentheses only `'()[]{}'`.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0021_merge_two_sorted_lists/readme.md b/src/main/python/g0001_0100/s0021_merge_two_sorted_lists/readme.md
index e5ed0c3..3a4afb1 100644
--- a/src/main/python/g0001_0100/s0021_merge_two_sorted_lists/readme.md
+++ b/src/main/python/g0001_0100/s0021_merge_two_sorted_lists/readme.md
@@ -33,8 +33,6 @@ Merge two sorted linked lists and return it as a **sorted** list. The list shoul
 *   `-100 <= Node.val <= 100`
 *   Both `l1` and `l2` are sorted in **non-decreasing** order.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0022_generate_parentheses/readme.md b/src/main/python/g0001_0100/s0022_generate_parentheses/readme.md
index 0f3ced6..9f2545e 100644
--- a/src/main/python/g0001_0100/s0022_generate_parentheses/readme.md
+++ b/src/main/python/g0001_0100/s0022_generate_parentheses/readme.md
@@ -23,8 +23,6 @@ Given `n` pairs of parentheses, write a function to _generate all combinations o
 
 *   `1 <= n <= 8`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0023_merge_k_sorted_lists/readme.md b/src/main/python/g0001_0100/s0023_merge_k_sorted_lists/readme.md
index cf72ead..cbe96af 100644
--- a/src/main/python/g0001_0100/s0023_merge_k_sorted_lists/readme.md
+++ b/src/main/python/g0001_0100/s0023_merge_k_sorted_lists/readme.md
@@ -38,8 +38,6 @@ _Merge all the linked-lists into one sorted linked-list and return it._
 *   `lists[i]` is sorted in **ascending order**.
 *   The sum of `lists[i].length` won't exceed `10^4`.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0024_swap_nodes_in_pairs/readme.md b/src/main/python/g0001_0100/s0024_swap_nodes_in_pairs/readme.md
index e8c581f..9a3ed52 100644
--- a/src/main/python/g0001_0100/s0024_swap_nodes_in_pairs/readme.md
+++ b/src/main/python/g0001_0100/s0024_swap_nodes_in_pairs/readme.md
@@ -32,8 +32,6 @@ Given a linked list, swap every two adjacent nodes and return its head. You must
 *   The number of nodes in the list is in the range `[0, 100]`.
 *   `0 <= Node.val <= 100`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md b/src/main/python/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md
index 1765484..67c7566 100644
--- a/src/main/python/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md
+++ b/src/main/python/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md
@@ -48,8 +48,6 @@ You may not alter the values in the list's nodes, only nodes themselves may be c
 
 **Follow-up:** Can you solve the problem in O(1) extra memory space?
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0031_next_permutation/readme.md b/src/main/python/g0001_0100/s0031_next_permutation/readme.md
index e9ba5b2..55a8e1c 100644
--- a/src/main/python/g0001_0100/s0031_next_permutation/readme.md
+++ b/src/main/python/g0001_0100/s0031_next_permutation/readme.md
@@ -40,8 +40,6 @@ The replacement must be **[in place](http://en.wikipedia.org/wiki/In-place_algor
 *   `1 <= nums.length <= 100`
 *   `0 <= nums[i] <= 100`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0032_longest_valid_parentheses/readme.md b/src/main/python/g0001_0100/s0032_longest_valid_parentheses/readme.md
index f5c4af9..4506b9c 100644
--- a/src/main/python/g0001_0100/s0032_longest_valid_parentheses/readme.md
+++ b/src/main/python/g0001_0100/s0032_longest_valid_parentheses/readme.md
@@ -34,8 +34,6 @@ Given a string containing just the characters `'('` and `')'`, find the length o
 *   <code>0 <= s.length <= 3 * 10<sup>4</sup></code>
 *   `s[i]` is `'('`, or `')'`.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md b/src/main/python/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md
index 00e5ec8..b3712fc 100644
--- a/src/main/python/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md
+++ b/src/main/python/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md
@@ -39,8 +39,6 @@ You must write an algorithm with `O(log n)` runtime complexity.
 *   `nums` is an ascending array that is possibly rotated.
 *   <code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md b/src/main/python/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md
index 9543897..aa7be82 100644
--- a/src/main/python/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md
+++ b/src/main/python/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md
@@ -36,7 +36,73 @@ You must write an algorithm with `O(log n)` runtime complexity.
 *   `nums` is a non-decreasing array.
 *   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
 
-To solve this problem efficiently with a runtime complexity of O(log n), we can use binary search to find the starting and ending positions of the target value in the sorted array. 
+To solve this problem efficiently with a runtime complexity of O(log n), we can use binary search to find the starting and ending positions of the target value in the sorted array. Here are the steps:
+
+### Approach:
+
+1. **Binary Search for Starting Position:**
+   - Use binary search to find the starting position of the target value.
+   - When the target value is found, continue searching towards the left to find the leftmost occurrence.
+   - Update the left boundary to narrow down the search space.
+
+2. **Binary Search for Ending Position:**
+   - Use binary search to find the ending position of the target value.
+   - When the target value is found, continue searching towards the right to find the rightmost occurrence.
+   - Update the right boundary to narrow down the search space.
+
+3. **Handle Missing Target:**
+   - If the target value is not found, return [-1, -1].
+
+### Python Code:
+
+```python
+class Solution:
+    def searchRange(self, nums, target):
+        def search_boundary(nums, target, is_left):
+            left, right = 0, len(nums) - 1
+            boundary = -1
+
+            while left <= right:
+                mid = (left + right) // 2
+
+                if nums[mid] == target:
+                    boundary = mid
+                    if is_left:
+                        right = mid - 1
+                    else:
+                        left = mid + 1
+                elif nums[mid] < target:
+                    left = mid + 1
+                else:
+                    right = mid - 1
+
+            return boundary
+
+        left_boundary = search_boundary(nums, target, is_left=True)
+        right_boundary = search_boundary(nums, target, is_left=False)
+
+        return [left_boundary, right_boundary]
+
+# Example Usage:
+solution = Solution()
+
+# Example 1:
+nums1 = [5, 7, 7, 8, 8, 10]
+target1 = 8
+print(solution.searchRange(nums1, target1))  # Output: [3, 4]
+
+# Example 2:
+nums2 = [5, 7, 7, 8, 8, 10]
+target2 = 6
+print(solution.searchRange(nums2, target2))  # Output: [-1, -1]
+
+# Example 3:
+nums3 = []
+target3 = 0
+print(solution.searchRange(nums3, target3))  # Output: [-1, -1]
+```
+
+This code defines a `Solution` class with a `searchRange` method to find the starting and ending positions of the target value in the given array. The example usage demonstrates how to create an instance of the `Solution` class and call the `searchRange` method with different inputs.
 
 ## Solution
 
diff --git a/src/main/python/g0001_0100/s0035_search_insert_position/readme.md b/src/main/python/g0001_0100/s0035_search_insert_position/readme.md
index b6fc102..7a6ddb6 100644
--- a/src/main/python/g0001_0100/s0035_search_insert_position/readme.md
+++ b/src/main/python/g0001_0100/s0035_search_insert_position/readme.md
@@ -46,7 +46,65 @@ You must write an algorithm with `O(log n)` runtime complexity.
 *   `nums` contains **distinct** values sorted in **ascending** order.
 *   <code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code>
 
-To solve this problem efficiently with a runtime complexity of O(log n), we can use binary search to find the insertion position of the target value in the sorted array. 
+To solve this problem efficiently with a runtime complexity of O(log n), we can use binary search to find the insertion position of the target value in the sorted array. Here are the steps:
+
+### Approach:
+
+1. **Binary Search:**
+   - Implement binary search to find the insertion position of the target value.
+   - If the target value is found, return its index.
+   - If the target value is not found, binary search will determine the index where the target would be inserted to maintain the sorted order.
+
+### Python Code:
+
+```python
+class Solution:
+    def searchInsert(self, nums, target):
+        left, right = 0, len(nums) - 1
+
+        while left <= right:
+            mid = (left + right) // 2
+
+            if nums[mid] == target:
+                return mid
+            elif nums[mid] < target:
+                left = mid + 1
+            else:
+                right = mid - 1
+
+        # If the target is not found, return the insertion position (left).
+        return left
+
+# Example Usage:
+solution = Solution()
+
+# Example 1:
+nums1 = [1, 3, 5, 6]
+target1 = 5
+print(solution.searchInsert(nums1, target1))  # Output: 2
+
+# Example 2:
+nums2 = [1, 3, 5, 6]
+target2 = 2
+print(solution.searchInsert(nums2, target2))  # Output: 1
+
+# Example 3:
+nums3 = [1, 3, 5, 6]
+target3 = 7
+print(solution.searchInsert(nums3, target3))  # Output: 4
+
+# Example 4:
+nums4 = [1, 3, 5, 6]
+target4 = 0
+print(solution.searchInsert(nums4, target4))  # Output: 0
+
+# Example 5:
+nums5 = [1]
+target5 = 0
+print(solution.searchInsert(nums5, target5))  # Output: 0
+```
+
+This code defines a `Solution` class with a `searchInsert` method to find the insertion position of the target value in the given sorted array. The example usage demonstrates how to create an instance of the `Solution` class and call the `searchInsert` method with different inputs.
 
 ## Solution
 
diff --git a/src/main/python/g0001_0100/s0039_combination_sum/readme.md b/src/main/python/g0001_0100/s0039_combination_sum/readme.md
index 083d91c..a03f7ed 100644
--- a/src/main/python/g0001_0100/s0039_combination_sum/readme.md
+++ b/src/main/python/g0001_0100/s0039_combination_sum/readme.md
@@ -54,8 +54,6 @@ It is **guaranteed** that the number of unique combinations that sum up to `targ
 *   All elements of `candidates` are **distinct**.
 *   `1 <= target <= 500`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0041_first_missing_positive/readme.md b/src/main/python/g0001_0100/s0041_first_missing_positive/readme.md
index 7774a8f..ba09f8d 100644
--- a/src/main/python/g0001_0100/s0041_first_missing_positive/readme.md
+++ b/src/main/python/g0001_0100/s0041_first_missing_positive/readme.md
@@ -32,8 +32,6 @@ You must implement an algorithm that runs in `O(n)` time and uses constant extra
 *   <code>1 <= nums.length <= 5 * 10<sup>5</sup></code>
 *   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0042_trapping_rain_water/readme.md b/src/main/python/g0001_0100/s0042_trapping_rain_water/readme.md
index 0236d69..3a20c00 100644
--- a/src/main/python/g0001_0100/s0042_trapping_rain_water/readme.md
+++ b/src/main/python/g0001_0100/s0042_trapping_rain_water/readme.md
@@ -29,8 +29,6 @@ Given `n` non-negative integers representing an elevation map where the width of
 *   <code>1 <= n <= 2 * 10<sup>4</sup></code>
 *   <code>0 <= height[i] <= 10<sup>5</sup></code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0045_jump_game_ii/readme.md b/src/main/python/g0001_0100/s0045_jump_game_ii/readme.md
index 463670d..596c9fa 100644
--- a/src/main/python/g0001_0100/s0045_jump_game_ii/readme.md
+++ b/src/main/python/g0001_0100/s0045_jump_game_ii/readme.md
@@ -32,8 +32,6 @@ You can assume that you can always reach the last index.
 *   <code>1 <= nums.length <= 10<sup>4</sup></code>
 *   `0 <= nums[i] <= 1000`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0046_permutations/readme.md b/src/main/python/g0001_0100/s0046_permutations/readme.md
index bdb36f9..6fa77ff 100644
--- a/src/main/python/g0001_0100/s0046_permutations/readme.md
+++ b/src/main/python/g0001_0100/s0046_permutations/readme.md
@@ -31,8 +31,6 @@ Given an array `nums` of distinct integers, return _all the possible permutation
 *   `-10 <= nums[i] <= 10`
 *   All the integers of `nums` are **unique**.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0048_rotate_image/readme.md b/src/main/python/g0001_0100/s0048_rotate_image/readme.md
index 72f99f1..d73d748 100644
--- a/src/main/python/g0001_0100/s0048_rotate_image/readme.md
+++ b/src/main/python/g0001_0100/s0048_rotate_image/readme.md
@@ -44,8 +44,6 @@ You have to rotate the image [**in-place**](https://en.wikipedia.org/wiki/In-pla
 *   `1 <= n <= 20`
 *   `-1000 <= matrix[i][j] <= 1000`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0049_group_anagrams/readme.md b/src/main/python/g0001_0100/s0049_group_anagrams/readme.md
index 23a891d..ed601b0 100644
--- a/src/main/python/g0001_0100/s0049_group_anagrams/readme.md
+++ b/src/main/python/g0001_0100/s0049_group_anagrams/readme.md
@@ -33,8 +33,6 @@ An **Anagram** is a word or phrase formed by rearranging the letters of a differ
 *   `0 <= strs[i].length <= 100`
 *   `strs[i]` consists of lowercase English letters.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0051_n_queens/readme.md b/src/main/python/g0001_0100/s0051_n_queens/readme.md
index 467dacb..48421dc 100644
--- a/src/main/python/g0001_0100/s0051_n_queens/readme.md
+++ b/src/main/python/g0001_0100/s0051_n_queens/readme.md
@@ -31,8 +31,6 @@ Each solution contains a distinct board configuration of the n-queens' placement
 
 *   `1 <= n <= 9`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0053_maximum_subarray/readme.md b/src/main/python/g0001_0100/s0053_maximum_subarray/readme.md
index 8536b28..9d74127 100644
--- a/src/main/python/g0001_0100/s0053_maximum_subarray/readme.md
+++ b/src/main/python/g0001_0100/s0053_maximum_subarray/readme.md
@@ -36,8 +36,6 @@ A **subarray** is a **contiguous** part of an array.
 
 **Follow up:** If you have figured out the `O(n)` solution, try coding another solution using the **divide and conquer** approach, which is more subtle.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0055_jump_game/readme.md b/src/main/python/g0001_0100/s0055_jump_game/readme.md
index c1fc238..e27ee01 100644
--- a/src/main/python/g0001_0100/s0055_jump_game/readme.md
+++ b/src/main/python/g0001_0100/s0055_jump_game/readme.md
@@ -30,8 +30,6 @@ Return `true` _if you can reach the last index, or_ `false` _otherwise_.
 *   <code>1 <= nums.length <= 10<sup>4</sup></code>
 *   <code>0 <= nums[i] <= 10<sup>5</sup></code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0001_0100/s0056_merge_intervals/readme.md b/src/main/python/g0001_0100/s0056_merge_intervals/readme.md
index 9baa3f1..c04d613 100644
--- a/src/main/python/g0001_0100/s0056_merge_intervals/readme.md
+++ b/src/main/python/g0001_0100/s0056_merge_intervals/readme.md
@@ -29,8 +29,6 @@ Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end
 *   `intervals[i].length == 2`
 *   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>4</sup></code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0101_0200/s0101_symmetric_tree/readme.md b/src/main/python/g0101_0200/s0101_symmetric_tree/readme.md
index 78ce4ea..18150d4 100644
--- a/src/main/python/g0101_0200/s0101_symmetric_tree/readme.md
+++ b/src/main/python/g0101_0200/s0101_symmetric_tree/readme.md
@@ -30,8 +30,6 @@ Given the `root` of a binary tree, _check whether it is a mirror of itself_ (i.e
 
 **Follow up:** Could you solve it both recursively and iteratively?
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0101_0200/s0102_binary_tree_level_order_traversal/readme.md b/src/main/python/g0101_0200/s0102_binary_tree_level_order_traversal/readme.md
index cf0805f..a63dfcd 100644
--- a/src/main/python/g0101_0200/s0102_binary_tree_level_order_traversal/readme.md
+++ b/src/main/python/g0101_0200/s0102_binary_tree_level_order_traversal/readme.md
@@ -32,8 +32,6 @@ Given the `root` of a binary tree, return _the level order traversal of its node
 *   The number of nodes in the tree is in the range `[0, 2000]`.
 *   `-1000 <= Node.val <= 1000`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0101_0200/s0104_maximum_depth_of_binary_tree/readme.md b/src/main/python/g0101_0200/s0104_maximum_depth_of_binary_tree/readme.md
index 5fde804..403abea 100644
--- a/src/main/python/g0101_0200/s0104_maximum_depth_of_binary_tree/readme.md
+++ b/src/main/python/g0101_0200/s0104_maximum_depth_of_binary_tree/readme.md
@@ -40,8 +40,6 @@ A binary tree's **maximum depth** is the number of nodes along the longest path
 *   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
 *   `-100 <= Node.val <= 100`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/readme.md b/src/main/python/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/readme.md
index dc9db6f..b27566a 100644
--- a/src/main/python/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/readme.md
+++ b/src/main/python/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/readme.md
@@ -31,8 +31,6 @@ Given two integer arrays `preorder` and `inorder` where `preorder` is the preord
 *   `preorder` is **guaranteed** to be the preorder traversal of the tree.
 *   `inorder` is **guaranteed** to be the inorder traversal of the tree.
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0101_0200/s0114_flatten_binary_tree_to_linked_list/readme.md b/src/main/python/g0101_0200/s0114_flatten_binary_tree_to_linked_list/readme.md
index 4ae68aa..b712deb 100644
--- a/src/main/python/g0101_0200/s0114_flatten_binary_tree_to_linked_list/readme.md
+++ b/src/main/python/g0101_0200/s0114_flatten_binary_tree_to_linked_list/readme.md
@@ -37,8 +37,6 @@ Given the `root` of a binary tree, flatten the tree into a "linked list":
 
 **Follow up:** Can you flatten the tree in-place (with `O(1)` extra space)?
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0101_0200/s0121_best_time_to_buy_and_sell_stock/readme.md b/src/main/python/g0101_0200/s0121_best_time_to_buy_and_sell_stock/readme.md
index a5d5b87..e473383 100644
--- a/src/main/python/g0101_0200/s0121_best_time_to_buy_and_sell_stock/readme.md
+++ b/src/main/python/g0101_0200/s0121_best_time_to_buy_and_sell_stock/readme.md
@@ -32,8 +32,6 @@ Return _the maximum profit you can achieve from this transaction_. If you cannot
 *   <code>1 <= prices.length <= 10<sup>5</sup></code>
 *   <code>0 <= prices[i] <= 10<sup>4</sup></code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0101_0200/s0124_binary_tree_maximum_path_sum/readme.md b/src/main/python/g0101_0200/s0124_binary_tree_maximum_path_sum/readme.md
index e040408..c0a698b 100644
--- a/src/main/python/g0101_0200/s0124_binary_tree_maximum_path_sum/readme.md
+++ b/src/main/python/g0101_0200/s0124_binary_tree_maximum_path_sum/readme.md
@@ -36,8 +36,6 @@ Given the `root` of a binary tree, return _the maximum **path sum** of any **non
 *   The number of nodes in the tree is in the range <code>[1, 3 * 10<sup>4</sup>]</code>.
 *   `-1000 <= Node.val <= 1000`
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0101_0200/s0128_longest_consecutive_sequence/readme.md b/src/main/python/g0101_0200/s0128_longest_consecutive_sequence/readme.md
index 58a9f11..451c9d3 100644
--- a/src/main/python/g0101_0200/s0128_longest_consecutive_sequence/readme.md
+++ b/src/main/python/g0101_0200/s0128_longest_consecutive_sequence/readme.md
@@ -28,8 +28,6 @@ You must write an algorithm that runs in `O(n)` time.
 *   <code>0 <= nums.length <= 10<sup>5</sup></code>
 *   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
 
-
-
 ## Solution
 
 ```python
diff --git a/src/main/python/g0101_0200/s0131_palindrome_partitioning/readme.md b/src/main/python/g0101_0200/s0131_palindrome_partitioning/readme.md
index 2d624f2..07ebd9d 100644
--- a/src/main/python/g0101_0200/s0131_palindrome_partitioning/readme.md
+++ b/src/main/python/g0101_0200/s0131_palindrome_partitioning/readme.md
@@ -26,7 +26,45 @@ A **palindrome** string is a string that reads the same backward as forward.
 *   `1 <= s.length <= 16`
 *   `s` contains only lowercase English letters.
 
-To solve this task, we can use a backtracking approach. 
+To solve this task, we can use a backtracking approach. Here are the steps to solve the problem using the `Solution` class:
+
+1. Define the `Solution` class with a method `partition` that takes a string `s` as input and returns a list of lists containing all possible palindrome partitions of `s`.
+2. Within the `partition` method, initialize an empty list to store the result.
+3. Define a helper function, let's name it `dfs`, which will perform depth-first search to generate all possible partitions.
+4. In the `dfs` function, if the current partition `start` is equal to the length of the string `s`, append the current partition to the result list.
+5. Otherwise, iterate through each possible end index of the substring starting from `start` to the end of the string.
+6. Check if the substring from `start` to the current end index is a palindrome. If it is, recursively call the `dfs` function with the updated start index and add the current palindrome substring to the current partition.
+7. After exploring all possible partitions, backtrack by removing the last added substring to explore other possibilities.
+8. Finally, return the result list containing all possible palindrome partitions.
+
+Here's how the `Solution` class would look like in Python:
+
+```python
+class Solution:
+    def partition(self, s: str) -> List[List[str]]:
+        result = []
+        
+        def dfs(start, partition):
+            if start == len(s):
+                result.append(partition[:])
+                return
+            
+            for end in range(start + 1, len(s) + 1):
+                if s[start:end] == s[start:end][::-1]:
+                    partition.append(s[start:end])
+                    dfs(end, partition)
+                    partition.pop()
+        
+        dfs(0, [])
+        return result
+
+# Example usage:
+solution = Solution()
+print(solution.partition("aab"))  # Output: [["a","a","b"],["aa","b"]]
+print(solution.partition("a"))     # Output: [["a"]]
+```
+
+This solution utilizes backtracking to efficiently generate all possible palindrome partitions of the given string `s`.
 
 ## Solution
 
diff --git a/src/main/python/g0101_0200/s0136_single_number/readme.md b/src/main/python/g0101_0200/s0136_single_number/readme.md
index 4e295b6..c1e077d 100644
--- a/src/main/python/g0101_0200/s0136_single_number/readme.md
+++ b/src/main/python/g0101_0200/s0136_single_number/readme.md
@@ -33,7 +33,33 @@ You must implement a solution with a linear runtime complexity and use only cons
 *   <code>-3 * 10<sup>4</sup> <= nums[i] <= 3 * 10<sup>4</sup></code>
 *   Each element in the array appears twice except for one element which appears only once.
 
-To solve this problem with the `Solution` class, which requires linear runtime complexity and constant extra space, we can utilize the bitwise XOR operation. 
+To solve this problem with the `Solution` class, which requires linear runtime complexity and constant extra space, we can utilize the bitwise XOR operation. Here are the steps:
+
+1. Define the `Solution` class with a method `singleNumber` that takes a list of integers `nums` as input and returns the single number that appears only once.
+2. Within the `singleNumber` method, initialize a variable `result` to 0.
+3. Iterate through each element in the `nums` list.
+4. Perform bitwise XOR operation between `result` and the current element.
+5. After iterating through all elements, `result` will contain the single number that appears only once due to the properties of XOR operation.
+6. Finally, return the `result`.
+
+Here's how the `Solution` class would look like in Python:
+
+```python
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        result = 0
+        for num in nums:
+            result ^= num
+        return result
+
+# Example usage:
+solution = Solution()
+print(solution.singleNumber([2, 2, 1]))      # Output: 1
+print(solution.singleNumber([4, 1, 2, 1, 2]))# Output: 4
+print(solution.singleNumber([1]))            # Output: 1
+```
+
+This solution leverages the bitwise XOR operation to find the single number that appears only once in the array, achieving linear runtime complexity and constant extra space usage.
 
 ## Solution
 
diff --git a/src/main/python/g0101_0200/s0138_copy_list_with_random_pointer/readme.md b/src/main/python/g0101_0200/s0138_copy_list_with_random_pointer/readme.md
index 50a8fb5..c4a2eb1 100644
--- a/src/main/python/g0101_0200/s0138_copy_list_with_random_pointer/readme.md
+++ b/src/main/python/g0101_0200/s0138_copy_list_with_random_pointer/readme.md
@@ -58,7 +58,43 @@ Your code will **only** be given the `head` of the original linked list.
 *   `-10000 <= Node.val <= 10000`
 *   `Node.random` is `null` or is pointing to some node in the linked list.
 
-To solve this problem with the `Solution` class, we can use a hashmap to keep track of the mapping between original nodes and their corresponding copied nodes. 
+To solve this problem with the `Solution` class, we can use a hashmap to keep track of the mapping between original nodes and their corresponding copied nodes. Here are the steps:
+
+1. Define the `Solution` class with a method `copyRandomList` that takes the head of the original linked list as input and returns the head of the copied linked list.
+2. Within the `copyRandomList` method, if the input `head` is `None`, return `None` as the copied list is empty.
+3. Initialize an empty hashmap to store the mapping between original nodes and copied nodes.
+4. Iterate through the original linked list and create a copied node for each original node. Set the value of the copied node to be the same as the original node and set both `next` and `random` pointers of the copied node to `None`.
+5. Store the mapping between original nodes and copied nodes in the hashmap.
+6. Iterate through the original linked list again and update the `next` and `random` pointers of copied nodes according to the mapping stored in the hashmap.
+7. Finally, return the head of the copied linked list.
+
+Here's how the `Solution` class would look like in Python:
+
+```python
+class Solution:
+    def copyRandomList(self, head: 'Node') -> 'Node':
+        if not head:
+            return None
+        
+        mapping = {}
+        
+        # Create copies of nodes without pointers
+        current = head
+        while current:
+            mapping[current] = Node(current.val)
+            current = current.next
+        
+        # Assign pointers for each copied node
+        current = head
+        while current:
+            mapping[current].next = mapping.get(current.next)
+            mapping[current].random = mapping.get(current.random)
+            current = current.next
+        
+        return mapping[head]
+```
+
+Make sure to define the `Node` class before using it in the `copyRandomList` method. This solution constructs a deep copy of the original linked list while maintaining the relationships between nodes as specified.
 
 ## Solution
 
diff --git a/src/main/python/g0101_0200/s0139_word_break/readme.md b/src/main/python/g0101_0200/s0139_word_break/readme.md
index 1839a99..f06b335 100644
--- a/src/main/python/g0101_0200/s0139_word_break/readme.md
+++ b/src/main/python/g0101_0200/s0139_word_break/readme.md
@@ -39,7 +39,40 @@ Given a string `s` and a dictionary of strings `wordDict`, return `true` if `s`
 *   `s` and `wordDict[i]` consist of only lowercase English letters.
 *   All the strings of `wordDict` are **unique**.
 
-To solve this problem with the `Solution` class, we can use dynamic programming to efficiently determine whether the string `s` can be segmented into words from the dictionary `wordDict`. 
+To solve this problem with the `Solution` class, we can use dynamic programming to efficiently determine whether the string `s` can be segmented into words from the dictionary `wordDict`. Here are the steps:
+
+1. Define the `Solution` class with a method `wordBreak` that takes a string `s` and a list of strings `wordDict` as input and returns a boolean indicating whether `s` can be segmented into words from `wordDict`.
+2. Initialize a boolean list `dp` of size `len(s) + 1`, where `dp[i]` represents whether the substring `s[:i]` can be segmented into words from `wordDict`.
+3. Set `dp[0]` to `True` since an empty string can always be segmented.
+4. Iterate `i` from 1 to `len(s)`, and for each index `i`, iterate `j` from 0 to `i`.
+5. Check if the substring `s[j:i]` exists in `wordDict` and if `dp[j]` is `True`. If both conditions are met, set `dp[i]` to `True`.
+6. After completing the iterations, return `dp[len(s)]`, which represents whether the entire string `s` can be segmented into words from `wordDict`.
+
+Here's how the `Solution` class would look like in Python:
+
+```python
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        word_set = set(wordDict)
+        dp = [False] * (len(s) + 1)
+        dp[0] = True
+        
+        for i in range(1, len(s) + 1):
+            for j in range(i):
+                if dp[j] and s[j:i] in word_set:
+                    dp[i] = True
+                    break
+        
+        return dp[len(s)]
+
+# Example usage:
+solution = Solution()
+print(solution.wordBreak("leetcode", ["leet", "code"]))         # Output: True
+print(solution.wordBreak("applepenapple", ["apple", "pen"]))    # Output: True
+print(solution.wordBreak("catsandog", ["cats", "dog", "sand", "and", "cat"]))  # Output: False
+```
+
+This solution effectively utilizes dynamic programming to determine whether the string `s` can be segmented into words from the dictionary `wordDict`, satisfying the constraints provided in the problem statement.
 
 ## Solution
 
diff --git a/src/main/python/g0101_0200/s0141_linked_list_cycle/readme.md b/src/main/python/g0101_0200/s0141_linked_list_cycle/readme.md
index cfe20e9..edd7c86 100644
--- a/src/main/python/g0101_0200/s0141_linked_list_cycle/readme.md
+++ b/src/main/python/g0101_0200/s0141_linked_list_cycle/readme.md
@@ -49,7 +49,59 @@ Return `true` _if there is a cycle in the linked list_. Otherwise, return `false
 
 **Follow up:** Can you solve it using `O(1)` (i.e. constant) memory?
 
-To solve this problem with the `Solution` class, we can use Floyd's Tortoise and Hare algorithm, also known as the "slow and fast pointers" approach. 
+To solve this problem with the `Solution` class, we can use Floyd's Tortoise and Hare algorithm, also known as the "slow and fast pointers" approach. Here are the steps:
+
+1. Define the `Solution` class with a method `hasCycle` that takes the head of a linked list as input and returns a boolean indicating whether the linked list has a cycle.
+2. Initialize two pointers, `slow` and `fast`, both pointing to the head of the linked list.
+3. Iterate through the linked list using the slow and fast pointers.
+4. Move the slow pointer one step at a time and the fast pointer two steps at a time.
+5. If there is a cycle in the linked list, eventually the fast pointer will meet the slow pointer at some point.
+6. If the fast pointer reaches the end of the list (`None`), it means there is no cycle, so return `False`.
+7. If the fast and slow pointers meet, it means there is a cycle, so return `True`.
+
+Here's how the `Solution` class would look like in Python:
+
+```python
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+class Solution:
+    def hasCycle(self, head: ListNode) -> bool:
+        if not head or not head.next:
+            return False
+        
+        slow = head
+        fast = head.next
+        
+        while slow != fast:
+            if not fast or not fast.next:
+                return False
+            slow = slow.next
+            fast = fast.next.next
+        
+        return True
+
+# Example usage:
+solution = Solution()
+head1 = ListNode(3)
+head1.next = ListNode(2)
+head1.next.next = ListNode(0)
+head1.next.next.next = ListNode(-4)
+head1.next.next.next.next = head1.next  # creates a cycle
+print(solution.hasCycle(head1))  # Output: True
+
+head2 = ListNode(1)
+head2.next = ListNode(2)
+head2.next.next = head2  # creates a cycle
+print(solution.hasCycle(head2))  # Output: True
+
+head3 = ListNode(1)
+print(solution.hasCycle(head3))  # Output: False
+```
+
+This solution effectively uses Floyd's Tortoise and Hare algorithm to detect whether there is a cycle in the linked list, satisfying the constraints provided in the problem statement.
 
 ## Solution
 
