Added racket

Author: javadev

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

@@ -0,0 +1,25 @@
+; #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Stack #Monotonic_Stack
+; #Big_O_Time_O(n_log_n)_Space_O(log_n) #2025_02_12_Time_18_ms_(100.00%)_Space_132.44_MB_(100.00%)
+
+(define/contract (largest-rectangle-area heights)
+  (-> (listof exact-integer?) exact-integer?)
+  (let* ((n (length heights))
+         (heights-vec (list->vector (append heights '(0))))
+         (stack '())
+         (max-area 0))
+    
+    (for ([i (in-range (add1 n))])
+      (let loop ()
+        (when (and (not (null? stack))
+                   (<= (vector-ref heights-vec i) (vector-ref heights-vec (car stack))))
+          (let* ((top (car stack))
+                 (new-stack (cdr stack))
+                 (height (vector-ref heights-vec top))
+                 (width (if (null? new-stack) i (- i (car new-stack) 1)))
+                 (area (* height width)))
+            (set! max-area (max max-area area))
+            (set! stack new-stack)
+            (loop))))
+      (set! stack (cons i stack)))
+
+    max-area))

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

@@ -0,0 +1,30 @@
+84\. Largest Rectangle in Histogram
+
+Hard
+
+Given an array of integers `heights` representing the histogram's bar height where the width of each bar is `1`, return _the area of the largest rectangle in the histogram_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/histogram.jpg)
+
+**Input:** heights = [2,1,5,6,2,3]
+
+**Output:** 10
+
+**Explanation:** The above is a histogram where width of each bar is 1. 
+
+The largest rectangle is shown in the red area, which has an area = 10 units.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/histogram-1.jpg)
+
+**Input:** heights = [2,4]
+
+**Output:** 4
+
+**Constraints:**
+
+*   <code>1 <= heights.length <= 10<sup>5</sup></code>
+*   <code>0 <= heights[i] <= 10<sup>4</sup></code>

src/main/racket/g0301_0400/s0322_coin_change/Solution.rkt

@@ -0,0 +1,18 @@
+; #Medium #Top_100_Liked_Questions #Array #Dynamic_Programming #Breadth_First_Search
+; #Algorithm_II_Day_18_Dynamic_Programming #Dynamic_Programming_I_Day_20
+; #Level_2_Day_12_Dynamic_Programming #Top_Interview_150_1D_DP #Big_O_Time_O(m*n)_Space_O(amount)
+; #2025_02_11_Time_29_ms_(100.00%)_Space_101.98_MB_(100.00%)
+
+(define/contract (coin-change coins amount)
+  (-> (listof exact-integer?) exact-integer? exact-integer?)
+  (let ([dp (make-vector (+ amount 1) 0)])
+    (vector-set! dp 0 1)
+    (for ([coin coins])
+      (for ([i (in-range coin (+ amount 1))])
+        (let ([prev (vector-ref dp (- i coin))])
+          (when (> prev 0)
+            (vector-set! dp i
+                         (if (= (vector-ref dp i) 0)
+                             (+ prev 1)
+                             (min (vector-ref dp i) (+ prev 1))))))))
+    (- (vector-ref dp amount) 1)))

src/main/racket/g0301_0400/s0322_coin_change/readme.md

@@ -0,0 +1,35 @@
+322\. Coin Change
+
+Medium
+
+You are given an integer array `coins` representing coins of different denominations and an integer `amount` representing a total amount of money.
+
+Return _the fewest number of coins that you need to make up that amount_. If that amount of money cannot be made up by any combination of the coins, return `-1`.
+
+You may assume that you have an infinite number of each kind of coin.
+
+**Example 1:**
+
+**Input:** coins = [1,2,5], amount = 11
+
+**Output:** 3
+
+**Explanation:** 11 = 5 + 5 + 1
+
+**Example 2:**
+
+**Input:** coins = [2], amount = 3
+
+**Output:** -1
+
+**Example 3:**
+
+**Input:** coins = [1], amount = 0
+
+**Output:** 0
+
+**Constraints:**
+
+*   `1 <= coins.length <= 12`
+*   <code>1 <= coins[i] <= 2<sup>31</sup> - 1</code>
+*   <code>0 <= amount <= 10<sup>4</sup></code>

src/main/racket/g0301_0400/s0338_counting_bits/Solution.rkt

@@ -0,0 +1,19 @@
+; #Easy #Dynamic_Programming #Bit_Manipulation #Udemy_Bit_Manipulation
+; #Big_O_Time_O(num)_Space_O(num) #2025_02_11_Time_3_ms_(100.00%)_Space_135.21_MB_(100.00%)
+
+(define (near-bit n i)
+    (if (and (<= i n) (< n (* i 2)))
+        i
+        (near-bit n (* i 2))))
+
+(define/contract (count-bits n)
+  (-> exact-integer? (listof exact-integer?))
+  (match n
+      [0 '(0)]
+      [1 '(0 1)]
+      [else 
+        (let* ([b (near-bit n 1)]
+               [prev (count-bits (- b 1))]
+               [next (map (lambda (n) (+ n 1)) prev)]) 
+               (take (append prev next) (+ n 1)))]
+      ))

src/main/racket/g0301_0400/s0338_counting_bits/readme.md

@@ -0,0 +1,41 @@
+338\. Counting Bits
+
+Easy
+
+Given an integer `n`, return _an array_ `ans` _of length_ `n + 1` _such that for each_ `i` (`0 <= i <= n`)_,_ `ans[i]` _is the **number of**_ `1`_**'s** in the binary representation of_ `i`.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** [0,1,1]
+
+**Explanation:**
+
+    0 --> 0
+    1 --> 1
+    2 --> 10 
+
+**Example 2:**
+
+**Input:** n = 5
+
+**Output:** [0,1,1,2,1,2]
+
+**Explanation:**
+
+    0 --> 0
+    1 --> 1
+    2 --> 10
+    3 --> 11
+    4 --> 100
+    5 --> 101 
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>5</sup></code>
+
+**Follow up:**
+
+*   It is very easy to come up with a solution with a runtime of `O(n log n)`. Can you do it in linear time `O(n)` and possibly in a single pass?
+*   Can you do it without using any built-in function (i.e., like `__builtin_popcount` in C++)?

src/main/racket/g0301_0400/s0347_top_k_frequent_elements/Solution.rkt

@@ -0,0 +1,12 @@
+; #Medium #Top_100_Liked_Questions #Array #Hash_Table #Sorting #Heap_Priority_Queue #Counting
+; #Divide_and_Conquer #Quickselect #Bucket_Sort #Data_Structure_II_Day_20_Heap_Priority_Queue
+; #Big_O_Time_O(n*log(n))_Space_O(k) #2025_02_11_Time_3_ms_(100.00%)_Space_103.26_MB_(100.00%)
+
+(define (hash-table-counter ls)
+  (let ([counts (make-hash)])
+    (for-each (λ (v) (hash-update! counts v add1 0)) ls)
+    counts))
+
+(define (top-k-frequent nums k)
+  (let ([counter (hash-table-counter nums)])
+    (map car (take (sort (hash->list counter) #:key cdr >) k))))

src/main/racket/g0301_0400/s0347_top_k_frequent_elements/readme.md

@@ -0,0 +1,26 @@
+347\. Top K Frequent Elements
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the_ `k` _most frequent elements_. You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** nums = [1,1,1,2,2,3], k = 2
+
+**Output:** [1,2]
+
+**Example 2:**
+
+**Input:** nums = [1], k = 1
+
+**Output:** [1]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `k` is in the range `[1, the number of unique elements in the array]`.
+*   It is **guaranteed** that the answer is **unique**.
+
+**Follow up:** Your algorithm's time complexity must be better than `O(n log n)`, where n is the array's size.

src/main/racket/g0301_0400/s0394_decode_string/Solution.rkt

@@ -0,0 +1,44 @@
+; #Medium #Top_100_Liked_Questions #String #Stack #Recursion #Level_1_Day_14_Stack #Udemy_Strings
+; #Big_O_Time_O(n)_Space_O(n) #2025_02_11_Time_0_ms_(100.00%)_Space_101.43_MB_(100.00%)
+
+(define/contract (decode-string s)
+  (-> string? string?)
+  (let-values ([(result _) (decode-helper (string->list s) 0)])
+    result))
+
+(define (decode-helper chars pos)
+  (let loop ([current-pos pos]
+             [count 0]
+             [result ""])
+    (if (>= current-pos (length chars))
+        (values result current-pos)
+        (let ([char (list-ref chars current-pos)])
+          (cond
+            ; If it's a letter, append it to result
+            [(char-alphabetic? char)
+             (loop (add1 current-pos)
+                   count
+                   (string-append result (string char)))]
+            
+            ; If it's a digit, update count
+            [(char-numeric? char)
+             (loop (add1 current-pos)
+                   (+ (* count 10) (- (char->integer char) (char->integer #\0)))
+                   result)]
+            
+            ; If it's '[', handle nested string
+            [(char=? char #\[)
+             (let-values ([(nested-str new-pos) (decode-helper chars (add1 current-pos))])
+               (loop new-pos
+                     0
+                     (string-append result 
+                                  (string-join 
+                                   (make-list count nested-str)
+                                   ""))))]
+            
+            ; If it's ']', return current result and position
+            [(char=? char #\])
+             (values result (add1 current-pos))]
+            
+            ; Skip other characters
+            [else (loop (add1 current-pos) count result)])))))

src/main/racket/g0301_0400/s0394_decode_string/readme.md

@@ -0,0 +1,36 @@
+394\. Decode String
+
+Medium
+
+Given an encoded string, return its decoded string.
+
+The encoding rule is: `k[encoded_string]`, where the `encoded_string` inside the square brackets is being repeated exactly `k` times. Note that `k` is guaranteed to be a positive integer.
+
+You may assume that the input string is always valid; there are no extra white spaces, square brackets are well-formed, etc. Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, `k`. For example, there will not be input like `3a` or `2[4]`.
+
+The test cases are generated so that the length of the output will never exceed <code>10<sup>5</sup></code>.
+
+**Example 1:**
+
+**Input:** s = "3[a]2[bc]"
+
+**Output:** "aaabcbc"
+
+**Example 2:**
+
+**Input:** s = "3[a2[c]]"
+
+**Output:** "accaccacc"
+
+**Example 3:**
+
+**Input:** s = "2[abc]3[cd]ef"
+
+**Output:** "abcabccdcdcdef"
+
+**Constraints:**
+
+*   `1 <= s.length <= 30`
+*   `s` consists of lowercase English letters, digits, and square brackets `'[]'`.
+*   `s` is guaranteed to be **a valid** input.
+*   All the integers in `s` are in the range `[1, 300]`.

src/main/racket/g0401_0500/s0416_partition_equal_subset_sum/Solution.rkt

@@ -0,0 +1,18 @@
+; #Medium #Top_100_Liked_Questions #Array #Dynamic_Programming #Level_2_Day_13_Dynamic_Programming
+; #Big_O_Time_O(n*sums)_Space_O(n*sums)
+; #2025_02_11_Time_1098_ms_(100.00%)_Space_132.26_MB_(100.00%)
+
+(define/contract (can-partition nums)
+  (-> (listof exact-integer?) boolean?)
+  (let* ([sum (apply + nums)])
+    (if (odd? sum)
+        #f
+        (let* ([target (/ sum 2)]
+               [dp (make-hash)])
+          (hash-set! dp 0 #t)
+          (for ([num nums])
+            (for ([key (reverse (hash-keys dp))])
+              (let ([new-sum (+ key num)])
+                (when (<= new-sum target)
+                  (hash-set! dp new-sum #t)))))
+          (hash-ref dp target #f)))))

src/main/racket/g0401_0500/s0416_partition_equal_subset_sum/readme.md

@@ -0,0 +1,26 @@
+416\. Partition Equal Subset Sum
+
+Medium
+
+Given a **non-empty** array `nums` containing **only positive integers**, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.
+
+**Example 1:**
+
+**Input:** nums = [1,5,11,5]
+
+**Output:** true
+
+**Explanation:** The array can be partitioned as [1, 5, 5] and [11].
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,5]
+
+**Output:** false
+
+**Explanation:** The array cannot be partitioned into equal sum subsets.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 200`
+*   `1 <= nums[i] <= 100`

src/main/racket/g0401_0500/s0437_path_sum_iii/Solution.rkt

@@ -0,0 +1,27 @@
+; #Medium #Depth_First_Search #Tree #Binary_Tree #Level_2_Day_7_Tree #Big_O_Time_O(n)_Space_O(n)
+; #2025_02_11_Time_107_ms_(100.00%)_Space_136.84_MB_(100.00%)
+
+; Definition for a binary tree node.
+#|
+
+; val : integer?
+; left : (or/c tree-node? #f)
+; right : (or/c tree-node? #f)
+(struct tree-node
+  (val left right) #:mutable #:transparent)
+
+; constructor
+(define (make-tree-node [val 0])
+  (tree-node val #f #f))
+
+|#
+
+(define/contract (path-sum root targetSum)
+  (-> (or/c tree-node? #f) exact-integer? exact-integer?)
+    (let recur ([root root][candidates empty])
+        (if (boolean? root) 0
+            (let ([new-candidates 
+                  (cons (tree-node-val root)
+                        (map (lambda (i) (+ i (tree-node-val root))) candidates))])
+        (+ (recur (tree-node-left root) new-candidates) (recur (tree-node-right root) new-candidates)
+        (foldl (lambda (i res) (+ res (if (= i targetSum) 1 0))) 0 new-candidates))))))