Improved racket

Author: javadev

src/main/racket/g0001_0100/s0001_two_sum/readme.md

@@ -43,10 +43,6 @@ You can return the answer in any order.
 ## Solution
 
 ```racket
-; #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table
-; #Data_Structure_I_Day_2_Array #Level_1_Day_13_Hashmap #Udemy_Arrays #Big_O_Time_O(n)_Space_O(n)
-; #AI_can_be_used_to_solve_the_task #2025_01_28_Time_0_(100.00%)_Space_102.07_(45.83%)
-
 (define (two-sum-iter nums target hash index)
   (cond
     ((null? nums) '())

src/main/racket/g0001_0100/s0002_add_two_numbers/readme.md

@@ -40,11 +40,6 @@ You may assume the two numbers do not contain any leading zero, except the numbe
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Math #Linked_List #Recursion
-; #Data_Structure_II_Day_10_Linked_List #Programming_Skills_II_Day_15
-; #Big_O_Time_O(max(N,M))_Space_O(max(N,M)) #AI_can_be_used_to_solve_the_task
-; #2025_01_28_Time_0_(100.00%)_Space_128.42_(12.50%)
-
 ; Definition for singly-linked list:
 #|
 

src/main/racket/g0001_0100/s0003_longest_substring_without_repeating_characters/readme.md

@@ -45,11 +45,6 @@ Given a string `s`, find the length of the **longest substring** without repeati
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Sliding_Window
-; #Algorithm_I_Day_6_Sliding_Window #Level_2_Day_14_Sliding_Window/Two_Pointer #Udemy_Strings
-; #Big_O_Time_O(n)_Space_O(1) #AI_can_be_used_to_solve_the_task
-; #2025_01_28_Time_134_(75.00%)_Space_132.36_(100.00%)
-
 ; Helper function to get the sublist up to 'v' excluded.
 (define (take-till q v)
   (define (take-till/helper q v acc)

src/main/racket/g0001_0100/s0004_median_of_two_sorted_arrays/readme.md

@@ -55,10 +55,6 @@ The overall run time complexity should be `O(log (m+n))`.
 ## Solution
 
 ```racket
-; #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search #Divide_and_Conquer
-; #Big_O_Time_O(log(min(N,M)))_Space_O(1) #AI_can_be_used_to_solve_the_task
-; #2025_01_28_Time_0_(100.00%)_Space_128.57_(100.00%)
-
 (define/contract (find-median-sorted-arrays nums1 nums2)
   (-> (listof exact-integer?) (listof exact-integer?) flonum?)
   

src/main/racket/g0001_0100/s0005_longest_palindromic_substring/readme.md

@@ -39,11 +39,6 @@ Given a string `s`, return _the longest palindromic substring_ in `s`.
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
-; #Data_Structure_II_Day_9_String #Algorithm_II_Day_14_Dynamic_Programming
-; #Dynamic_Programming_I_Day_17 #Udemy_Strings #Big_O_Time_O(n)_Space_O(n)
-; #2025_01_28_Time_10_(50.00%)_Space_102.35_(50.00%)
-
 (define (longest-palindrome s)
   (define (expand-around-center s left right)
     (let loop ([l left] [r right])

src/main/racket/g0001_0100/s0006_zigzag_conversion/readme.md

@@ -44,9 +44,6 @@ string convert(string s, int numRows);
 ## Solution
 
 ```racket
-; #Medium #String #Top_Interview_150_Array/String
-; #2025_02_03_Time_57_(100.00%)_Space_130.82_(60.00%)
-
 (define/contract (convert s numRows)
   (-> string? exact-integer? string?)
   (let* ((sLen (string-length s))

src/main/racket/g0001_0100/s0007_reverse_integer/readme.md

@@ -40,9 +40,6 @@ Given a signed 32-bit integer `x`, return `x` _with its digits reversed_. If rev
 ## Solution
 
 ```racket
-; #Medium #Top_Interview_Questions #Math #Udemy_Integers
-; #2025_02_03_Time_204_(100.00%)_Space_101.45_(100.00%)
-
 (define/contract (reverse x)
   (-> exact-integer? exact-integer?)
   (let loop ((x x) (rev 0))

src/main/racket/g0001_0100/s0008_string_to_integer_atoi/readme.md

@@ -118,8 +118,6 @@ Since -91283472332 is less than the lower bound of the range [-2<sup>31</sup>, 2
 ## Solution
 
 ```racket
-; #Medium #Top_Interview_Questions #String #2025_02_03_Time_3_(100.00%)_Space_101.64_(100.00%)
-
 (define/contract (my-atoi s)
   (-> string? exact-integer?)
   (let* ((trimmed (string-trim s))

src/main/racket/g0001_0100/s0009_palindrome_number/readme.md

@@ -46,9 +46,6 @@ An integer is a **palindrome** when it reads the same backward as forward. For e
 ## Solution
 
 ```racket
-; #Easy #Math #Udemy_Integers #Top_Interview_150_Math
-; #2025_02_03_Time_8_(100.00%)_Space_129.01_(88.24%)
-
 (define/contract (is-palindrome x)
   (-> exact-integer? boolean?)
   (if (< x 0)

src/main/racket/g0001_0100/s0010_regular_expression_matching/readme.md

@@ -61,9 +61,6 @@ The matching should cover the **entire** input string (not partial).
 ## Solution
 
 ```racket
-; #Hard #Top_Interview_Questions #String #Dynamic_Programming #Recursion #Udemy_Dynamic_Programming
-; #Big_O_Time_O(m*n)_Space_O(m*n) #2025_02_03_Time_11_(100.00%)_Space_101.36_(100.00%)
-
 (define (regex-state s is-star)
   (list s (if is-star '* '1)))
 

src/main/racket/g0001_0100/s0011_container_with_most_water/readme.md

@@ -46,10 +46,6 @@ Given `n` non-negative integers <code>a<sub>1</sub>, a<sub>2</sub>, ..., a<sub>n
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Greedy #Two_Pointers
-; #Algorithm_II_Day_4_Two_Pointers #Top_Interview_150_Two_Pointers #Big_O_Time_O(n)_Space_O(1)
-; #2025_02_03_Time_32_(100.00%)_Space_130.58_(100.00%)
-
 (define/contract (max-area height)
   (-> (listof exact-integer?) exact-integer?)
     

src/main/racket/g0001_0100/s0015_3sum/readme.md

@@ -35,11 +35,6 @@ Notice that the solution set must not contain duplicate triplets.
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Sorting #Two_Pointers
-; #Data_Structure_II_Day_1_Array #Algorithm_II_Day_3_Two_Pointers #Udemy_Two_Pointers
-; #Top_Interview_150_Two_Pointers #Big_O_Time_O(n*log(n))_Space_O(n^2)
-; #2025_02_03_Time_999_(100.00%)_Space_130.90_(100.00%)
-
 (define (bin-search val left right items)
   (cond [(> left right) #f]
         [(= left right) (eq? val (vector-ref items left))]

src/main/racket/g0001_0100/s0017_letter_combinations_of_a_phone_number/readme.md

@@ -37,11 +37,6 @@ A mapping of digit to letters (just like on the telephone buttons) is given belo
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Backtracking
-; #Algorithm_II_Day_11_Recursion_Backtracking #Udemy_Backtracking/Recursion
-; #Top_Interview_150_Backtracking #Big_O_Time_O(4^n)_Space_O(n)
-; #2025_02_03_Time_0_(100.00%)_Space_102.48_(_%)
-
 (define (letter-combinations digits)
   (let* ((letters (vector "" "" "abc" "def" "ghi" "jkl" "mno" "pqrs" "tuv" "wxyz"))
          (letters2 (map string->list

src/main/racket/g0001_0100/s0019_remove_nth_node_from_end_of_list/readme.md

@@ -39,10 +39,6 @@ Given the `head` of a linked list, remove the `nth` node from the end of the lis
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Two_Pointers #Linked_List
-; #Algorithm_I_Day_5_Two_Pointers #Level_2_Day_3_Linked_List #Top_Interview_150_Linked_List
-; #Big_O_Time_O(L)_Space_O(L) #2025_02_03_Time_0_(100.00%)_Space_101.91_(_%)
-
 ; Definition for singly-linked list:
 #|
 

src/main/racket/g0001_0100/s0020_valid_parentheses/readme.md

@@ -50,10 +50,6 @@ An input string is valid if:
 ## Solution
 
 ```racket
-; #Easy #Top_100_Liked_Questions #Top_Interview_Questions #String #Stack
-; #Data_Structure_I_Day_9_Stack_Queue #Udemy_Strings #Top_Interview_150_Stack
-; #Big_O_Time_O(n)_Space_O(n) #2025_02_03_Time_98_(100.00%)_Space_130.80_(100.00%)
-
 (define (is-left-paren c)
     (or (eq? c #\u28)
         (eq? c #\[)

src/main/racket/g0001_0100/s0021_merge_two_sorted_lists/readme.md

@@ -36,11 +36,6 @@ Merge two sorted linked lists and return it as a **sorted** list. The list shoul
 ## Solution
 
 ```racket
-; #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Linked_List #Recursion
-; #Data_Structure_I_Day_7_Linked_List #Algorithm_I_Day_10_Recursion_Backtracking
-; #Level_1_Day_3_Linked_List #Udemy_Linked_List #Top_Interview_150_Linked_List
-; #Big_O_Time_O(m+n)_Space_O(m+n) #2025_02_03_Time_0_(100.00%)_Space_102.38_(66.67%)
-
 ; Definition for singly-linked list:
 #|
 

src/main/racket/g0001_0100/s0022_generate_parentheses/readme.md

@@ -26,11 +26,6 @@ Given `n` pairs of parentheses, write a function to _generate all combinations o
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
-; #Backtracking #Algorithm_II_Day_11_Recursion_Backtracking #Udemy_Backtracking/Recursion
-; #Top_Interview_150_Backtracking #Big_O_Time_O(2^n)_Space_O(n)
-; #2025_02_03_Time_3_(100.00%)_Space_101.96_(100.00%)
-
 (define (generate-parenthesis n)
   (let ([res '()])
     (let loop ([opening 0] [closing 0] [path ""])

src/main/racket/g0001_0100/s0023_merge_k_sorted_lists/readme.md

@@ -41,10 +41,6 @@ _Merge all the linked-lists into one sorted linked-list and return it._
 ## Solution
 
 ```racket
-; #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Heap_Priority_Queue #Linked_List
-; #Divide_and_Conquer #Merge_Sort #Top_Interview_150_Divide_and_Conquer
-; #Big_O_Time_O(k*n*log(k))_Space_O(log(k)) #2025_02_03_Time_306_(100.00%)_Space_130.68_(100.00%)
-
 ; Definition for singly-linked list:
 #|
 

src/main/racket/g0001_0100/s0024_swap_nodes_in_pairs/readme.md

@@ -35,10 +35,6 @@ Given a linked list, swap every two adjacent nodes and return its head. You must
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Linked_List #Recursion #Data_Structure_II_Day_12_Linked_List
-; #Udemy_Linked_List #Big_O_Time_O(n)_Space_O(1)
-; #2025_02_03_Time_0_(100.00%)_Space_101.59_(100.00%)
-
 ; Definition for singly-linked list:
 #|
 

src/main/racket/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md

@@ -51,10 +51,6 @@ You may not alter the values in the list's nodes, only nodes themselves may be c
 ## Solution
 
 ```racket
-; #Hard #Top_100_Liked_Questions #Linked_List #Recursion #Data_Structure_II_Day_13_Linked_List
-; #Udemy_Linked_List #Top_Interview_150_Linked_List #Big_O_Time_O(n)_Space_O(k)
-; #2025_02_03_Time_0_(100.00%)_Space_101.65_(100.00%)
-
 ; Definition for singly-linked list:
 #|
 

src/main/racket/g0001_0100/s0032_longest_valid_parentheses/readme.md

@@ -37,9 +37,6 @@ Given a string containing just the characters `'('` and `')'`, find the length o
 ## Solution
 
 ```racket
-; #Hard #Top_100_Liked_Questions #String #Dynamic_Programming #Stack #Big_O_Time_O(n)_Space_O(1)
-; #2025_02_03_Time_3_(100.00%)_Space_101.36_(100.00%)
-
 (define/contract (longest-valid-parentheses s)
   (-> string? exact-integer?)
   (let* ((n (string-length s)))

src/main/racket/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md

@@ -42,11 +42,6 @@ You must write an algorithm with `O(log n)` runtime complexity.
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search
-; #Algorithm_II_Day_1_Binary_Search #Binary_Search_I_Day_11 #Level_2_Day_8_Binary_Search
-; #Udemy_Binary_Search #Top_Interview_150_Binary_Search #Big_O_Time_O(log_n)_Space_O(1)
-; #2025_02_03_Time_0_(100.00%)_Space_101.54_(100.00%)
-
 (define/contract (search nums target [index 0])
   (-> (listof exact-integer?) exact-integer? exact-integer?)
   (cond [(null? nums) -1]

src/main/racket/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md

@@ -39,10 +39,6 @@ You must write an algorithm with `O(log n)` runtime complexity.
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search
-; #Algorithm_II_Day_1_Binary_Search #Binary_Search_I_Day_5 #Top_Interview_150_Binary_Search
-; #Big_O_Time_O(log_n)_Space_O(1) #2025_02_03_Time_0_(100.00%)_Space_101.71_(66.67%)
-
 (define (find-bound vec target first-val)
   (define (ptr-narrow left right)
     (let* ([mid (quotient (+ left right) 2)]

src/main/racket/g0001_0100/s0035_search_insert_position/readme.md

@@ -49,10 +49,6 @@ You must write an algorithm with `O(log n)` runtime complexity.
 ## Solution
 
 ```racket
-; #Easy #Top_100_Liked_Questions #Array #Binary_Search #Algorithm_I_Day_1_Binary_Search
-; #Binary_Search_I_Day_2 #Top_Interview_150_Binary_Search #Big_O_Time_O(log_n)_Space_O(1)
-; #2025_02_03_Time_0_(100.00%)_Space_102.38_(_%)
-
 (define (search-insert nums target [low 0] [high (sub1 (length nums))])
 (if (< high low)
     low

src/main/racket/g0001_0100/s0039_combination_sum/readme.md

@@ -46,11 +46,6 @@ These are the only two combinations.
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Array #Backtracking #Algorithm_II_Day_10_Recursion_Backtracking
-; #Level_2_Day_20_Brute_Force/Backtracking #Udemy_Backtracking/Recursion
-; #Top_Interview_150_Backtracking #Big_O_Time_O(2^n)_Space_O(n+2^n)
-; #2025_02_03_Time_7_(100.00%)_Space_101.91_(50.00%)
-
 (define (create-task-rec elems target next-list result)
   (if (= 0 (length next-list)) result
       (if (< target (+ (foldl + 0 elems) (car next-list)))

src/main/racket/g0001_0100/s0041_first_missing_positive/readme.md

@@ -41,9 +41,6 @@ You must implement an algorithm that runs in `O(n)` time and uses constant extra
 ## Solution
 
 ```racket
-; #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table #Udemy_Arrays
-; #Big_O_Time_O(n)_Space_O(n) #2025_02_03_Time_11_(100.00%)_Space_132.67_(100.00%)
-
 (define/contract (first-missing-positive nums)
   (-> (listof exact-integer?) exact-integer?)
   (let* ((len (length nums))

src/main/racket/g0001_0100/s0042_trapping_rain_water/readme.md

@@ -32,11 +32,6 @@ Given `n` non-negative integers representing an elevation map where the width of
 ## Solution
 
 ```racket
-; #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming #Two_Pointers
-; #Stack #Monotonic_Stack #Dynamic_Programming_I_Day_9 #Udemy_Two_Pointers
-; #Top_Interview_150_Array/String #Big_O_Time_O(n)_Space_O(1)
-; #2025_02_03_Time_0_(100.00%)_Space_129.13_(100.00%)
-
 (define (trap height)
     (define H (list->vector height))
     

src/main/racket/g0001_0100/s0045_jump_game_ii/readme.md

@@ -35,11 +35,6 @@ You can assume that you can always reach the last index.
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Array #Dynamic_Programming #Greedy
-; #Algorithm_II_Day_13_Dynamic_Programming #Dynamic_Programming_I_Day_4
-; #Top_Interview_150_Array/String #Big_O_Time_O(n)_Space_O(1)
-; #2025_02_03_Time_631_(100.00%)_Space_132.16_(100.00%)
-
 (define (init-vec len)
   (let ([prepare-vec (make-vector len 99999)])
     (begin (vector-set! prepare-vec 0 0) prepare-vec)))

src/main/racket/g0001_0100/s0046_permutations/readme.md

@@ -34,11 +34,6 @@ Given an array `nums` of distinct integers, return _all the possible permutation
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Backtracking
-; #Algorithm_I_Day_11_Recursion_Backtracking #Level_2_Day_20_Brute_Force/Backtracking
-; #Udemy_Backtracking/Recursion #Top_Interview_150_Backtracking #Big_O_Time_O(n*n!)_Space_O(n+n!)
-; #2025_02_03_Time_0_(100.00%)_Space_101.43_(66.67%)
-
 (define/contract (permute nums)
   (-> (listof exact-integer?) (listof (listof exact-integer?)))
   (cond [(empty? nums) (list empty)]

src/main/racket/g0001_0100/s0049_group_anagrams/readme.md

@@ -36,11 +36,6 @@ An **Anagram** is a word or phrase formed by rearranging the letters of a differ
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #String #Hash_Table #Sorting
-; #Data_Structure_II_Day_8_String #Programming_Skills_II_Day_11 #Udemy_Strings
-; #Top_Interview_150_Hashmap #Big_O_Time_O(n*k_log_k)_Space_O(n)
-; #2025_02_03_Time_72_(100.00%)_Space_131.77_(100.00%)
-
 (define (group-anagrams strs)
   (group-by (compose1 (curryr sort char<?) string->list) strs))
 ```

src/main/racket/g0001_0100/s0051_n_queens/readme.md

@@ -34,9 +34,6 @@ Each solution contains a distinct board configuration of the n-queens' placement
 ## Solution
 
 ```racket
-; #Hard #Top_100_Liked_Questions #Array #Backtracking #Big_O_Time_O(N!)_Space_O(N)
-; #2025_02_03_Time_123_(100.00%)_Space_129.70_(100.00%)
-
 (define (reverse sequence)
     (foldr (lambda (x y) (append y (list x))) `() sequence))
 

src/main/racket/g0001_0100/s0053_maximum_subarray/readme.md

@@ -39,11 +39,6 @@ A **subarray** is a **contiguous** part of an array.
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming
-; #Divide_and_Conquer #Data_Structure_I_Day_1_Array #Dynamic_Programming_I_Day_5
-; #Udemy_Famous_Algorithm #Top_Interview_150_Kadane's_Algorithm #Big_O_Time_O(n)_Space_O(1)
-; #2025_02_03_Time_51_(100.00%)_Space_140.95_(100.00%)
-
 (define/contract (recur nums)
     (-> (listof exact-integer?) pair?)
     (if (empty? nums) (cons 0 -1000000)

src/main/racket/g0001_0100/s0055_jump_game/readme.md

@@ -33,11 +33,6 @@ Return `true` _if you can reach the last index, or_ `false` _otherwise_.
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming #Greedy
-; #Algorithm_II_Day_12_Dynamic_Programming #Dynamic_Programming_I_Day_4 #Udemy_Arrays
-; #Top_Interview_150_Array/String #Big_O_Time_O(n)_Space_O(1)
-; #2025_02_03_Time_0_(100.00%)_Space_132.04_(_%)
-
 (define (can-jump L)
   (let loop ([i 0] [arr L] [best 0] [N (length L)])
     (cond ((< best i) #f)

src/main/racket/g0001_0100/s0056_merge_intervals/readme.md

@@ -32,11 +32,6 @@ Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Sorting
-; #Data_Structure_II_Day_2_Array #Level_2_Day_17_Interval #Udemy_2D_Arrays/Matrix
-; #Top_Interview_150_Intervals #Big_O_Time_O(n_log_n)_Space_O(n)
-; #2025_02_03_Time_474_(100.00%)_Space_131.06_(_%)
-
 (define/contract (merge intervals)
   (-> (listof (listof exact-integer?)) (listof (listof exact-integer?)))
   (if (empty? intervals)

src/main/racket/g0001_0100/s0062_unique_paths/readme.md

@@ -40,11 +40,6 @@ The test cases are generated so that the answer will be less than or equal to <c
 ## Solution
 
 ```racket
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Dynamic_Programming #Math
-; #Combinatorics #Algorithm_II_Day_13_Dynamic_Programming #Dynamic_Programming_I_Day_15
-; #Level_1_Day_11_Dynamic_Programming #Big_O_Time_O(m*n)_Space_O(m*n)
-; #2025_02_03_Time_6_(100.00%)_Space_102.66_(100.00%)
-
 (define (calc-path! start end direction cache other-p)
   (begin (if (string=? direction "v")
       (for ([i (in-range start end)])