Added racket

Author: javadev

src/main/racket/g0001_0100/s0079_word_search/Solution.rkt

@@ -1,6 +1,6 @@
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Bit_Manipulation #Backtracking
-; #Algorithm_II_Day_9_Recursion_Backtracking #Udemy_Backtracking/Recursion
-; #Big_O_Time_O(2^n)_Space_O(n*2^n) #2025_02_04_Time_0_(100.00%)_Space_101.30_(100.00%)
+; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Matrix #Backtracking
+; #Algorithm_II_Day_11_Recursion_Backtracking #Top_Interview_150_Backtracking
+; #Big_O_Time_O(4^(m*n))_Space_O(m*n) #2025_02_07_Time_2517_(100.00%)_Space_130.64_(_%)
 
 (define/contract (exist board word)
   (-> (listof (listof char?)) string? boolean?)

src/main/racket/g0101_0200/s0114_flatten_binary_tree_to_linked_list/Solution.rkt

@@ -1,6 +1,6 @@
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table #Tree #Binary_Tree
-; #Divide_and_Conquer #Data_Structure_II_Day_15_Tree #Top_Interview_150_Binary_Tree_General
-; #Big_O_Time_O(N)_Space_O(N) #2025_02_05_Time_23_(100.00%)_Space_101.43_(100.00%)
+; #Medium #Top_100_Liked_Questions #Depth_First_Search #Tree #Binary_Tree #Stack #Linked_List
+; #Udemy_Linked_List #Top_Interview_150_Binary_Tree_General #Big_O_Time_O(N)_Space_O(N)
+; #2025_02_07_Time_0_(100.00%)_Space_101.49_(100.00%)
 
 ; Definition for a binary tree node.
 #|

src/main/racket/g0101_0200/s0124_binary_tree_maximum_path_sum/Solution.rkt

@@ -1,7 +1,6 @@
-; #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming
-; #Data_Structure_I_Day_3_Array #Dynamic_Programming_I_Day_7 #Level_1_Day_5_Greedy #Udemy_Arrays
-; #Top_Interview_150_Array/String #Big_O_Time_O(N)_Space_O(1)
-; #2025_02_05_Time_7_(100.00%)_Space_131.60_(50.00%)
+; #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Dynamic_Programming #Depth_First_Search
+; #Tree #Binary_Tree #Udemy_Tree_Stack_Queue #Top_Interview_150_Binary_Tree_General
+; #Big_O_Time_O(N)_Space_O(N) #2025_02_07_Time_0_(100.00%)_Space_131.06_(100.00%)
 
 ; Definition for a binary tree node.
 #|

src/main/racket/g0101_0200/s0136_single_number/Solution.rkt

@@ -1,6 +1,7 @@
-; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
-; #Backtracking #Big_O_Time_O(N*2^N)_Space_O(2^N*N)
-; #2025_02_05_Time_43_(100.00%)_Space_142.17_(100.00%)
+; #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Bit_Manipulation
+; #Data_Structure_II_Day_1_Array #Algorithm_I_Day_14_Bit_Manipulation #Udemy_Integers
+; #Top_Interview_150_Bit_Manipulation #Big_O_Time_O(N)_Space_O(1)
+; #2025_02_07_Time_0_(100.00%)_Space_129.05_(100.00%)
 
 (define (single-number nums)
   (apply bitwise-xor nums)

src/main/racket/g0101_0200/s0139_word_break/Solution.rkt

@@ -0,0 +1,24 @@
+; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table
+; #Dynamic_Programming #Trie #Memoization #Algorithm_II_Day_15_Dynamic_Programming
+; #Dynamic_Programming_I_Day_9 #Udemy_Dynamic_Programming #Top_Interview_150_1D_DP
+; #Big_O_Time_O(M+max*N)_Space_O(M+N+max) #2025_02_06_Time_4_(100.00%)_Space_102.55_(100.00%)
+
+(define/contract (word-break s wordDict)
+  (-> string? (listof string?) boolean?)
+  (let ((memo (make-hash)))
+    (define (dp i)
+      (cond
+        [(= i (string-length s)) #t]
+        [(hash-has-key? memo i) (hash-ref memo i)]
+        [else
+         (let loop ((words wordDict))
+           (if (null? words)
+               (begin (hash-set! memo i #f) #f)
+               (let* ((word (car words))
+                      (len (string-length word)))
+                 (if (and (<= (+ i len) (string-length s))
+                          (string=? (substring s i (+ i len)) word)
+                          (dp (+ i len)))
+                     (begin (hash-set! memo i #t) #t)
+                     (loop (cdr words))))))]))
+    (dp 0)))

src/main/racket/g0101_0200/s0139_word_break/readme.md

@@ -0,0 +1,39 @@
+139\. Word Break
+
+Medium
+
+Given a string `s` and a dictionary of strings `wordDict`, return `true` if `s` can be segmented into a space-separated sequence of one or more dictionary words.
+
+**Note** that the same word in the dictionary may be reused multiple times in the segmentation.
+
+**Example 1:**
+
+**Input:** s = "leetcode", wordDict = ["leet","code"]
+
+**Output:** true
+
+**Explanation:** Return true because "leetcode" can be segmented as "leet code".
+
+**Example 2:**
+
+**Input:** s = "applepenapple", wordDict = ["apple","pen"]
+
+**Output:** true
+
+**Explanation:** Return true because "applepenapple" can be segmented as "apple pen apple". 
+
+Note that you are allowed to reuse a dictionary word.
+
+**Example 3:**
+
+**Input:** s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
+
+**Output:** false
+
+**Constraints:**
+
+*   `1 <= s.length <= 300`
+*   `1 <= wordDict.length <= 1000`
+*   `1 <= wordDict[i].length <= 20`
+*   `s` and `wordDict[i]` consist of only lowercase English letters.
+*   All the strings of `wordDict` are **unique**.

src/main/racket/g0101_0200/s0146_lru_cache/LRUCache.rkt

@@ -0,0 +1,56 @@
+; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Hash_Table #Design #Linked_List
+; #Doubly_Linked_List #Udemy_Linked_List #Top_Interview_150_Linked_List
+; #Big_O_Time_O(1)_Space_O(capacity) #2025_02_06_Time_471_(100.00%)_Space_163.64_(100.00%)
+
+(define lru-cache%
+  (class object%
+    (super-new)
+    
+    (init-field capacity)
+    
+    (define head #f)
+    (define tail #f)
+    (define cache (make-hash))
+    
+    (define/private (move-to-head node)
+      (when (not (eq? node head))
+        (when (eq? node tail)
+          (set! tail (hash-ref node 'prev))
+          (when tail (hash-set! tail 'next #f)))
+        (let ((prev (hash-ref node 'prev #f))
+              (next (hash-ref node 'next #f)))
+          (when prev (hash-set! prev 'next next))
+          (when next (hash-set! next 'prev prev))
+          (hash-set! node 'prev #f)
+          (hash-set! node 'next head)
+          (when head (hash-set! head 'prev node))
+          (set! head node))))
+    
+    (define/public (get key)
+      (let ((node (hash-ref cache key #f)))
+        (if node
+            (begin (move-to-head node)
+                   (hash-ref node 'value))
+            -1)))
+    
+    (define/public (put key value)
+      (let ((node (hash-ref cache key #f)))
+        (if node
+            (begin
+              (hash-set! node 'value value)
+              (move-to-head node))
+            (begin
+              (when (>= (hash-count cache) capacity)
+                (when tail
+                  (hash-remove! cache (hash-ref tail 'key))
+                  (set! tail (hash-ref tail 'prev #f))
+                  (when tail (hash-set! tail 'next #f))))
+              (let ((new-node (make-hash)))
+                (hash-set! new-node 'key key)
+                (hash-set! new-node 'value value)
+                (hash-set! new-node 'prev #f)
+                (hash-set! new-node 'next head)
+                (when head (hash-set! head 'prev new-node))
+                (set! head new-node)
+                (unless tail (set! tail new-node))
+                (hash-set! cache key new-node))))))))

src/main/racket/g0101_0200/s0146_lru_cache/readme.md

@@ -0,0 +1,48 @@
+146\. LRU Cache
+
+Medium
+
+Design a data structure that follows the constraints of a **[Least Recently Used (LRU) cache](https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU)**.
+
+Implement the `LRUCache` class:
+
+*   `LRUCache(int capacity)` Initialize the LRU cache with **positive** size `capacity`.
+*   `int get(int key)` Return the value of the `key` if the key exists, otherwise return `-1`.
+*   `void put(int key, int value)` Update the value of the `key` if the `key` exists. Otherwise, add the `key-value` pair to the cache. If the number of keys exceeds the `capacity` from this operation, **evict** the least recently used key.
+
+The functions `get` and `put` must each run in `O(1)` average time complexity.
+
+**Example 1:**
+
+**Input** ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"] [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+
+**Output:** [null, null, null, 1, null, -1, null, -1, 3, 4]
+
+**Explanation:** 
+
+LRUCache lRUCache = new LRUCache(2); 
+
+lRUCache.put(1, 1); // cache is {1=1} 
+
+lRUCache.put(2, 2); // cache is {1=1, 2=2} 
+
+lRUCache.get(1); // return 1 
+
+lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3} 
+
+lRUCache.get(2); // returns -1 (not found) 
+
+lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
+
+lRUCache.get(1); // return -1 (not found) 
+
+lRUCache.get(3); // return 3 
+
+lRUCache.get(4); // return 4
+
+**Constraints:**
+
+*   `1 <= capacity <= 3000`
+*   <code>0 <= key <= 10<sup>4</sup></code>
+*   <code>0 <= value <= 10<sup>5</sup></code>
+*   At most <code>2 * 10<sup>5</sup></code> calls will be made to `get` and `put`.

src/main/racket/g0101_0200/s0148_sort_list/Solution.rkt

@@ -0,0 +1,65 @@
+; #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Sorting #Two_Pointers #Linked_List
+; #Divide_and_Conquer #Merge_Sort #Level_2_Day_4_Linked_List #Top_Interview_150_Divide_and_Conquer
+; #Big_O_Time_O(log(N))_Space_O(log(N)) #2025_02_08_Time_31_(100.00%)_Space_132.15_(100.00%)
+
+; Definition for singly-linked list:
+#|
+
+; val : integer?
+; next : (or/c list-node? #f)
+(struct list-node
+  (val next) #:mutable #:transparent)
+
+; constructor
+(define (make-list-node [val 0])
+  (list-node val #f))
+
+|#
+
+; Helper function to split the list into two halves
+(define (split-list head)
+  (let loop ([slow head]
+             [fast head]
+             [pre #f])
+    (cond
+      [(or (not fast) (not (list-node-next fast)))
+       (when pre
+         (set-list-node-next! pre #f))
+       slow]
+      [else
+       (loop (list-node-next slow)
+             (list-node-next (list-node-next fast))
+             slow)])))
+
+; Helper function to merge two sorted lists
+(define (merge-lists l1 l2)
+  (let ([dummy (list-node 1 #f)])
+    (let loop ([curr dummy]
+               [first l1]
+               [second l2])
+      (cond
+        [(not first)
+         (set-list-node-next! curr second)]
+        [(not second)
+         (set-list-node-next! curr first)]
+        [else
+         (if (<= (list-node-val first) (list-node-val second))
+             (begin
+               (set-list-node-next! curr first)
+               (loop first (list-node-next first) second))
+             (begin
+               (set-list-node-next! curr second)
+               (loop second first (list-node-next second))))])
+      (list-node-next dummy))))
+
+; Main sort-list function with contract
+(define/contract (sort-list head)
+  (-> (or/c list-node? #f) (or/c list-node? #f))
+  (cond
+    [(or (not head) (not (list-node-next head)))
+     head]
+    [else
+     (let* ([middle (split-list head)]
+            [first (sort-list head)]
+            [second (sort-list middle)])
+       (merge-lists first second))]))

src/main/racket/g0101_0200/s0148_sort_list/readme.md

@@ -0,0 +1,34 @@
+148\. Sort List
+
+Medium
+
+Given the `head` of a linked list, return _the list after sorting it in **ascending order**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg)
+
+**Input:** head = [4,2,1,3]
+
+**Output:** [1,2,3,4]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg)
+
+**Input:** head = [-1,5,3,4,0]
+
+**Output:** [-1,0,3,4,5]
+
+**Example 3:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+
+**Follow up:** Can you sort the linked list in `O(n logn)` time and `O(1)` memory (i.e. constant space)?