Added racket

Author: javadev

README.md

@@ -0,0 +1,58 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 1\. Two Sum
+
+Easy
+
+Given an array of integers `nums` and an integer `target`, return _indices of the two numbers such that they add up to `target`_.
+
+You may assume that each input would have **_exactly_ one solution**, and you may not use the _same_ element twice.
+
+You can return the answer in any order.
+
+**Example 1:**
+
+**Input:** nums = [2,7,11,15], target = 9
+
+**Output:** [0,1]
+
+**Output:** Because nums[0] + nums[1] == 9, we return [0, 1]. 
+
+**Example 2:**
+
+**Input:** nums = [3,2,4], target = 6
+
+**Output:** [1,2] 
+
+**Example 3:**
+
+**Input:** nums = [3,3], target = 6
+
+**Output:** [0,1] 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
+*   **Only one valid answer exists.**
+
+**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>) </code>time complexity?
+
+## Solution
+
+```racket
+(define (two-sum-iter nums target hash index)
+  (cond
+    ((null? nums) '())
+    ((hash-has-key? hash (car nums) ) (list (hash-ref hash (car nums) ) index ) )
+    (else (two-sum-iter (cdr nums) target (hash-set hash (- target (car nums ) ) index ) (+ index 1) ))
+  )
+)
+
+(define/contract (two-sum nums target)
+  (-> (listof exact-integer?) exact-integer? (listof exact-integer?))
+    (two-sum-iter nums target (make-immutable-hash) 0)
+)
+```

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

@@ -0,0 +1,70 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 2\. Add Two Numbers
+
+Medium
+
+You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in **reverse order**, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg)
+
+**Input:** l1 = [2,4,3], l2 = [5,6,4]
+
+**Output:** [7,0,8]
+
+**Explanation:** 342 + 465 = 807. 
+
+**Example 2:**
+
+**Input:** l1 = [0], l2 = [0]
+
+**Output:** [0] 
+
+**Example 3:**
+
+**Input:** l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+
+**Output:** [8,9,9,9,0,0,0,1] 
+
+**Constraints:**
+
+*   The number of nodes in each linked list is in the range `[1, 100]`.
+*   `0 <= Node.val <= 9`
+*   It is guaranteed that the list represents a number that does not have leading zeros.
+
+## Solution
+
+```racket
+; 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))
+
+|#
+
+(define/contract (add-two-numbers l1 l2)
+  (-> (or/c list-node? #f) (or/c list-node? #f) (or/c list-node? #f))
+  (add-two-numbers-help l1 l2 0)
+  )
+
+(define (add-two-numbers-help l1 l2 carry-sum)
+    (cond
+        [(and (false? l1) (false? l2)) (if (zero? carry-sum) #f (list-node carry-sum #f))]
+        [(false? l1) (list-node (modulo (+ (list-node-val l2) carry-sum) 10) (add-two-numbers-help l1 (list-node-next l2) (/ (- (+ (list-node-val l2) carry-sum) (modulo (+ (list-node-val l2) carry-sum) 10)) 10)))]
+        [(false? l2) (list-node (modulo (+ (list-node-val l1) carry-sum) 10) (add-two-numbers-help (list-node-next l1) l2 (/ (- (+ (list-node-val l1) carry-sum) (modulo (+ (list-node-val l1) carry-sum) 10)) 10)))]
+        [else (list-node (modulo (+ (list-node-val l1) (list-node-val l2) carry-sum) 10) (add-two-numbers-help (list-node-next l1) (list-node-next l2) (/ (- (+ (list-node-val l1) (list-node-val l2) carry-sum) (modulo (+ (list-node-val l1) (list-node-val l2) carry-sum) 10)) 10)))]
+    )
+)
+```

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

@@ -0,0 +1,75 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 3\. Longest Substring Without Repeating Characters
+
+Medium
+
+Given a string `s`, find the length of the **longest substring** without repeating characters.
+
+**Example 1:**
+
+**Input:** s = "abcabcbb"
+
+**Output:** 3
+
+**Explanation:** The answer is "abc", with the length of 3. 
+
+**Example 2:**
+
+**Input:** s = "bbbbb"
+
+**Output:** 1
+
+**Explanation:** The answer is "b", with the length of 1. 
+
+**Example 3:**
+
+**Input:** s = "pwwkew"
+
+**Output:** 3
+
+**Explanation:** The answer is "wke", with the length of 3. Notice that the answer must be a substring, "pwke" is a subsequence and not a substring. 
+
+**Example 4:**
+
+**Input:** s = ""
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= s.length <= 5 * 10<sup>4</sup></code>
+*   `s` consists of English letters, digits, symbols and spaces.
+
+## Solution
+
+```racket
+; Helper function to get the sublist up to 'v' excluded.
+(define (take-till q v)
+  (define (take-till/helper q v acc)
+    (if (or (null? q)
+            (eq? (car q) v))
+        acc
+        (take-till/helper (cdr q) v (cons (car q) acc))))
+  (foldl cons null (take-till/helper q v null)))
+
+; (take-till '(1 2 3 4 5) 4) returns '(1 2 3)
+
+(define (max-substr s queue len max-len)
+  (cond
+    [(null? s) max-len]
+    [(pair? s)
+     (let ((x (car s))
+           (xs (cdr s)))
+       (if (member x queue)
+           (let* ((tqueue (take-till queue x)) ; queue from last repeated char
+                 (tqueue-len (+ 1 (length tqueue))))
+             (max-substr xs (cons x tqueue) tqueue-len (max tqueue-len max-len)))
+           ; else
+           (max-substr xs (cons x queue) (+ 1 len) (max (+ 1 len) max-len))))]))
+
+(define/contract (length-of-longest-substring s)
+  (-> string? exact-integer?)
+  (max-substr (string->list s) null 0 0))
+```

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

@@ -0,0 +1,89 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 4\. Median of Two Sorted Arrays
+
+Hard
+
+Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return **the median** of the two sorted arrays.
+
+The overall run time complexity should be `O(log (m+n))`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,3], nums2 = [2]
+
+**Output:** 2.00000
+
+**Explanation:** merged array = [1,2,3] and median is 2. 
+
+**Example 2:**
+
+**Input:** nums1 = [1,2], nums2 = [3,4]
+
+**Output:** 2.50000
+
+**Explanation:** merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. 
+
+**Example 3:**
+
+**Input:** nums1 = [0,0], nums2 = [0,0]
+
+**Output:** 0.00000 
+
+**Example 4:**
+
+**Input:** nums1 = [], nums2 = [1]
+
+**Output:** 1.00000 
+
+**Example 5:**
+
+**Input:** nums1 = [2], nums2 = []
+
+**Output:** 2.00000 
+
+**Constraints:**
+
+*   `nums1.length == m`
+*   `nums2.length == n`
+*   `0 <= m <= 1000`
+*   `0 <= n <= 1000`
+*   `1 <= m + n <= 2000`
+*   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>
+
+## Solution
+
+```racket
+(define/contract (find-median-sorted-arrays nums1 nums2)
+  (-> (listof exact-integer?) (listof exact-integer?) flonum?)
+  
+  (define (find-kth-smallest k nums1 nums2)
+    (cond
+      [(empty? nums1) (list-ref nums2 k)]
+      [(empty? nums2) (list-ref nums1 k)]
+      [(= k 0) (min (car nums1) (car nums2))]
+      [else
+       (let* ([mid1 (min (length nums1) (quotient (+ k 1) 2))]
+              [mid2 (min (length nums2) (quotient (+ k 1) 2))]
+              [median1 (list-ref nums1 (sub1 mid1))]
+              [median2 (list-ref nums2 (sub1 mid2))])
+         (cond
+           [(< median1 median2)
+            (find-kth-smallest (- k mid1) (drop nums1 mid1) nums2)]
+           [else
+            (find-kth-smallest (- k mid2) nums1 (drop nums2 mid2))]))]))
+  
+  (define (find-median)
+    (let* ([m (length nums1)]
+           [n (length nums2)]
+           [total-length (+ m n)]
+           [half-length (quotient total-length 2)])
+      (if (even? total-length)
+          (/ (+ (exact->inexact (find-kth-smallest half-length nums1 nums2))
+                (exact->inexact (find-kth-smallest (sub1 half-length) nums1 nums2)))
+             2.0)
+          (exact->inexact (find-kth-smallest half-length nums1 nums2)))))
+  
+  (find-median))
+```

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

@@ -0,0 +1,71 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 5\. Longest Palindromic Substring
+
+Medium
+
+Given a string `s`, return _the longest palindromic substring_ in `s`.
+
+**Example 1:**
+
+**Input:** s = "babad"
+
+**Output:** "bab" **Note:** "aba" is also a valid answer. 
+
+**Example 2:**
+
+**Input:** s = "cbbd"
+
+**Output:** "bb" 
+
+**Example 3:**
+
+**Input:** s = "a"
+
+**Output:** "a" 
+
+**Example 4:**
+
+**Input:** s = "ac"
+
+**Output:** "a" 
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` consist of only digits and English letters.
+
+## Solution
+
+```racket
+(define (longest-palindrome s)
+  (define (expand-around-center s left right)
+    (let loop ([l left] [r right])
+      (if (and (>= l 0)
+               (< r (string-length s))
+               (char=? (string-ref s l) (string-ref s r)))
+          (loop (sub1 l) (add1 r))
+          (values (add1 l) (sub1 r))))) ;; Return correct boundaries
+
+  (define (find-longest-palindrome s)
+    (define len (string-length s))
+    (define start 0)
+    (define end 0)
+    (for ([i (in-range len)])
+      ;; Odd-length palindromes centered at i
+      (define-values (l1 r1) (expand-around-center s i i))
+      ;; Even-length palindromes centered between i and i + 1
+      (define-values (l2 r2) (expand-around-center s i (add1 i)))
+      
+      ;; Update the maximum length palindrome if necessary
+      (when (> (- r1 l1) (- end start))
+        (set! start l1)
+        (set! end r1))
+      (when (> (- r2 l2) (- end start))
+        (set! start l2)
+        (set! end r2)))
+    (substring s start (add1 end))) 
+
+  (find-longest-palindrome s))
+```