Added racket

Author: javadev

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

@@ -43,8 +43,6 @@ You can return the answer in any order.
 ## Solution
 
 ```erlang
-% #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table
-
 -spec two_sum(Nums :: [integer()], Target :: integer()) -> [integer()].
 two_sum(Nums, Target) ->
     two_sum(Nums, Target, #{}, 0).

src/main/racket/g0201_0300/s0207_course_schedule/readme.md

@@ -0,0 +1,60 @@
+[![](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)
+
+## 207\. Course Schedule
+
+Medium
+
+There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where <code>prerequisites[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that you **must** take course <code>b<sub>i</sub></code> first if you want to take course <code>a<sub>i</sub></code>.
+
+*   For example, the pair `[0, 1]`, indicates that to take course `0` you have to first take course `1`.
+
+Return `true` if you can finish all courses. Otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** numCourses = 2, prerequisites = \[\[1,0]]
+
+**Output:** true
+
+**Explanation:** There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.
+
+**Example 2:**
+
+**Input:** numCourses = 2, prerequisites = \[\[1,0],[0,1]]
+
+**Output:** false
+
+**Explanation:** There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.
+
+**Constraints:**
+
+*   `1 <= numCourses <= 2000`
+*   `0 <= prerequisites.length <= 5000`
+*   `prerequisites[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < numCourses</code>
+*   All the pairs prerequisites[i] are **unique**.
+
+## Solution
+
+```racket
+(define (can-finish num-courses prereqs)
+  (let ([adj (make-hash)]
+        [seen (make-vector num-courses 0)])
+    (for ([x prereqs])
+      (hash-set! adj (first x)
+                 (cons (second x) (hash-ref adj (first x) '()))))
+   
+    (define (dfs node)
+      (cond ((= 1 (vector-ref seen node)) #f)
+            ((= 2 (vector-ref seen node)) #t)
+            (else
+             (vector-set! seen node 1)
+             (if (andmap dfs (hash-ref adj node '()))         
+                 (begin
+                   (vector-set! seen node 2)
+                   #t)
+                 #f))))
+
+    (andmap dfs (hash-keys adj))))
+```

src/main/racket/g0201_0300/s0208_implement_trie_prefix_tree/readme.md

@@ -0,0 +1,99 @@
+[![](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)
+
+## 208\. Implement Trie (Prefix Tree)
+
+Medium
+
+A [**trie**](https://en.wikipedia.org/wiki/Trie) (pronounced as "try") or **prefix tree** is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. There are various applications of this data structure, such as autocomplete and spellchecker.
+
+Implement the Trie class:
+
+*   `Trie()` Initializes the trie object.
+*   `void insert(String word)` Inserts the string `word` into the trie.
+*   `boolean search(String word)` Returns `true` if the string `word` is in the trie (i.e., was inserted before), and `false` otherwise.
+*   `boolean startsWith(String prefix)` Returns `true` if there is a previously inserted string `word` that has the prefix `prefix`, and `false` otherwise.
+
+**Example 1:**
+
+**Input** ["Trie", "insert", "search", "search", "startsWith", "insert", "search"] [[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
+
+**Output:** [null, null, true, false, true, null, true]
+
+**Explanation:** 
+
+Trie trie = new Trie(); 
+
+trie.insert("apple"); 
+
+trie.search("apple"); // return True 
+
+trie.search("app"); // return False 
+
+trie.startsWith("app"); // return True 
+
+trie.insert("app"); 
+
+trie.search("app"); // return True
+
+**Constraints:**
+
+*   `1 <= word.length, prefix.length <= 2000`
+*   `word` and `prefix` consist only of lowercase English letters.
+*   At most <code>3 * 10<sup>4</sup></code> calls **in total** will be made to `insert`, `search`, and `startsWith`.
+
+## Solution
+
+```racket
+(define trie%
+  (class object%
+    (super-new)
+
+    ;; Define TrieNode struct
+    (struct trie-node (children is-word?) #:mutable)
+
+    ;; Root node of the Trie
+    (init-field)
+    (define root (trie-node (make-hash) #f))
+    (define start-with? #f)
+
+    ;; Inserts a word into the trie.
+    (define/public (insert word)
+      (define (insert-helper node word idx)
+        (if (= idx (string-length word))
+            (set-trie-node-is-word?! node #t)
+            (let* ([ch (string-ref word idx)]
+                   [children (trie-node-children node)]
+                   [next-node (hash-ref children ch (lambda () (trie-node (make-hash) #f)))])
+              (hash-set! children ch next-node)
+              (insert-helper next-node word (+ idx 1)))))
+      (insert-helper root word 0))
+
+    ;; Searches for a word in the trie.
+    (define/public (search word)
+      (define (search-helper node word idx)
+        (if (= idx (string-length word))
+            (begin
+              (set! start-with? #t)
+              (trie-node-is-word? node))
+            (let* ([ch (string-ref word idx)]
+                   [children (trie-node-children node)]
+                   [next-node (hash-ref children ch #f)])
+              (if next-node
+                  (search-helper next-node word (+ idx 1))
+                  (begin
+                    (set! start-with? #f)
+                    #f)))))
+      (search-helper root word 0))
+
+    ;; Checks if any word in the trie starts with the given prefix.
+    (define/public (starts-with prefix)
+      (send this search prefix)
+      start-with?)))
+
+;; Your trie% object will be instantiated and called as such:
+;; (define obj (new trie%))
+;; (send obj insert word)
+;; (define param_2 (send obj search word))
+;; (define param_3 (send obj starts-with prefix))
+```

src/main/racket/g0201_0300/s0215_kth_largest_element_in_an_array/readme.md

@@ -0,0 +1,39 @@
+[![](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)
+
+## 215\. Kth Largest Element in an Array
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the_ <code>k<sup>th</sup></code> _largest element in the array_.
+
+Note that it is the <code>k<sup>th</sup></code> largest element in the sorted order, not the <code>k<sup>th</sup></code> distinct element.
+
+You must solve it in `O(n)` time complexity.
+
+**Example 1:**
+
+**Input:** nums = [3,2,1,5,6,4], k = 2
+
+**Output:** 5
+
+**Example 2:**
+
+**Input:** nums = [3,2,3,1,2,4,5,5,6], k = 4
+
+**Output:** 4
+
+**Constraints:**
+
+*   <code>1 <= k <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+
+## Solution
+
+```racket
+(define/contract (find-kth-largest nums k)
+  (-> (listof exact-integer?) exact-integer? exact-integer?)
+  (let* ([sorted-nums (sort nums >)]  ; Sort in descending order
+         [index (- k 1)])             ; Convert 1-based to 0-based index
+    (list-ref sorted-nums index)))    ; Return the k-th largest element
+```

src/main/racket/g0201_0300/s0221_maximal_square/readme.md

@@ -0,0 +1,62 @@
+[![](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)
+
+## 221\. Maximal Square
+
+Medium
+
+Given an `m x n` binary `matrix` filled with `0`'s and `1`'s, _find the largest square containing only_ `1`'s _and return its area_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/max1grid.jpg)
+
+**Input:** matrix = \[\["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
+
+**Output:** 4
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/max2grid.jpg)
+
+**Input:** matrix = \[\["0","1"],["1","0"]]
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** matrix = \[\["0"]]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 300`
+*   `matrix[i][j]` is `'0'` or `'1'`.
+
+## Solution
+
+```racket
+(define/contract (maximal-square matrix)
+  (-> (listof (listof char?)) exact-integer?)
+  (let* ([m (length matrix)]
+         [n (if (zero? m) 0 (length (first matrix)))]
+         [dp (make-hash)]  ; Hash table to simulate a 2D array
+         [max-size 0])
+
+    (define (get-dp i j)
+      (hash-ref dp (cons i j) 0))  ; Default to 0 if not found
+
+    ;; Iterate over the matrix
+    (for ([i (in-range m)])
+      (for ([j (in-range n)])
+        (when (char=? (list-ref (list-ref matrix i) j) #\1)
+          (let* ([min-neighbor (min (get-dp i j) (get-dp (+ i 1) j) (get-dp i (+ j 1)))]
+                 [size (+ 1 min-neighbor)])
+            (hash-set! dp (cons (+ i 1) (+ j 1)) size)
+            (set! max-size (max max-size size))))))
+
+    (* max-size max-size)))  ; Return area of the largest square
+```

src/main/racket/g0201_0300/s0226_invert_binary_tree/readme.md

@@ -0,0 +1,63 @@
+[![](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)
+
+## 226\. Invert Binary Tree
+
+Easy
+
+Given the `root` of a binary tree, invert the tree, and return _its root_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg)
+
+**Input:** root = [4,2,7,1,3,6,9]
+
+**Output:** [4,7,2,9,6,3,1]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg)
+
+**Input:** root = [2,1,3]
+
+**Output:** [2,3,1]
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 100]`.
+*   `-100 <= Node.val <= 100`
+
+## Solution
+
+```racket
+; 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)
+
+; Helper function to create a tree node.
+|#
+(define (make-tree-node val [left #f] [right #f])
+  (tree-node val left right))
+
+; Function to invert a binary tree.
+(define/contract (invert-tree root)
+  (-> (or/c tree-node? #f) (or/c tree-node? #f))
+  (cond
+    [(not root) #f] ; Base case: empty tree.
+    [else
+     (make-tree-node
+      (tree-node-val root)
+      (invert-tree (tree-node-right root))
+      (invert-tree (tree-node-left root)))]))
+```