Added tasks 206-221

Author: javadev

README.md

@@ -0,0 +1,34 @@
+206\. Reverse Linked List
+
+Easy
+
+Given the `head` of a singly linked list, reverse the list, and return _the reversed list_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg)
+
+**Input:** head = [1,2,3,4,5]
+
+**Output:** [5,4,3,2,1] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg)
+
+**Input:** head = [1,2]
+
+**Output:** [2,1] 
+
+**Example 3:**
+
+**Input:** head = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the list is the range `[0, 5000]`.
+*   `-5000 <= Node.val <= 5000`
+
+**Follow up:** A linked list can be reversed either iteratively or recursively. Could you implement both?

src/main/ts/g0201_0300/s0206_reverse_linked_list/readme.md

@@ -0,0 +1,31 @@
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Linked_List #Recursion
+// #Data_Structure_I_Day_8_Linked_List #Algorithm_I_Day_10_Recursion_Backtracking
+// #Level_1_Day_3_Linked_List #Udemy_Linked_List #Big_O_Time_O(N)_Space_O(1)
+// #2023_10_09_Time_51_ms_(92.87%)_Space_44.3_MB_(96.03%)
+
+import { ListNode } from '../../com_github_leetcode/listnode'
+
+/*
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+function reverseList(head: ListNode | null): ListNode | null {
+    let prev: ListNode | null = null
+    let curr: ListNode | null = head
+    while (curr !== null) {
+        const next: ListNode | null = curr.next
+        curr.next = prev
+        prev = curr
+        curr = next
+    }
+    return prev
+}
+
+export { reverseList }

src/main/ts/g0201_0300/s0206_reverse_linked_list/solution.ts

@@ -0,0 +1,33 @@
+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:**
+
+*   <code>1 <= numCourses <= 10<sup>5</sup></code>
+*   `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**.

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

@@ -0,0 +1,38 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Depth_First_Search
+// #Breadth_First_Search #Graph #Topological_Sort #Big_O_Time_O(N)_Space_O(N)
+// #2023_10_09_Time_68_ms_(70.14%)_Space_47.7_MB_(73.55%)
+
+const WHITE = 0
+const GRAY = 1
+const BLACK = 2
+
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+    const adj: number[][] = Array.from({ length: numCourses }, () => [])
+    for (const pre of prerequisites) {
+        adj[pre[1]].push(pre[0])
+    }
+    const colors: number[] = new Array(numCourses).fill(WHITE)
+    for (let i = 0; i < numCourses; i++) {
+        if (colors[i] === WHITE && adj[i].length > 0 && hasCycle(adj, i, colors)) {
+            return false
+        }
+    }
+    return true
+}
+
+function hasCycle(adj: number[][], node: number, colors: number[]): boolean {
+    colors[node] = GRAY
+    for (const nei of adj[node]) {
+        if (colors[nei] === GRAY) {
+            return true
+        }
+
+        if (colors[nei] === WHITE && hasCycle(adj, nei, colors)) {
+            return true
+        }
+    }
+    colors[node] = BLACK
+    return false
+}
+
+export { canFinish }

src/main/ts/g0201_0300/s0207_course_schedule/solution.ts

@@ -0,0 +1,36 @@
+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`.

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

@@ -0,0 +1,84 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Design #Trie
+// #Level_2_Day_16_Design #Udemy_Trie_and_Heap
+// #Big_O_Time_O(word.length())_or_O(prefix.length())_Space_O(N)
+// #2023_10_09_Time_168_ms_(80.99%)_Space_79.5_MB_(14.46%)
+
+class TrieNode {
+    children: TrieNode[]
+    isWord: boolean
+
+    constructor() {
+        this.children = new Array<TrieNode>(26)
+        this.isWord = false
+    }
+}
+
+class Trie {
+    private root: TrieNode
+    private startWith: boolean
+
+    private static readonly ALPHABET_SIZE = 26
+
+    constructor() {
+        this.root = new TrieNode()
+        this.startWith = false
+    }
+
+    // Inserts a word into the trie.
+    insert(word: string): void {
+        this.insertRecursive(word, this.root, 0)
+    }
+
+    private insertRecursive(word: string, node: TrieNode, idx: number): void {
+        if (idx === word.length) {
+            node.isWord = true
+            return
+        }
+        const charIndex = this.getCharIndex(word.charAt(idx))
+        if (!node.children[charIndex]) {
+            node.children[charIndex] = new TrieNode()
+        }
+        this.insertRecursive(word, node.children[charIndex], idx + 1)
+    }
+
+    // Returns if the word is in the trie.
+    search(word: string): boolean {
+        this.startWith = false
+        return this.searchRecursive(word, this.root, 0)
+    }
+
+    private searchRecursive(word: string, node: TrieNode, idx: number): boolean {
+        if (idx === word.length) {
+            this.startWith = true
+            return node.isWord
+        }
+
+        const charIndex = this.getCharIndex(word.charAt(idx))
+        if (!node.children[charIndex]) {
+            this.startWith = false
+            return false
+        }
+        return this.searchRecursive(word, node.children[charIndex], idx + 1)
+    }
+
+    // Returns if there is any word in the trie
+    // that starts with the given prefix.
+    startsWith(prefix: string): boolean {
+        this.search(prefix)
+        return this.startWith
+    }
+
+    private getCharIndex(char: string): number {
+        return char.charCodeAt(0) - 'a'.charCodeAt(0)
+    }
+}
+
+/*
+ * Your Trie object will be instantiated and called as such:
+ * var obj = new Trie()
+ * obj.insert(word)
+ * var param_2 = obj.search(word)
+ * var param_3 = obj.startsWith(prefix)
+ */
+
+export { Trie }

src/main/ts/g0201_0300/s0208_implement_trie_prefix_tree/solution.ts

@@ -0,0 +1,24 @@
+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.
+
+**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>4</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>

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

@@ -0,0 +1,10 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Sorting #Heap_Priority_Queue
+// #Divide_and_Conquer #Quickselect #Data_Structure_II_Day_20_Heap_Priority_Queue
+// #Big_O_Time_O(n*log(n))_Space_O(log(n)) #2023_10_09_Time_148_ms_(54.45%)_Space_51.5_MB_(73.60%)
+
+function findKthLargest(nums: number[], k: number): number {
+    nums.sort((prev, next) => next - prev)
+    return nums[k - 1]
+}
+
+export { findKthLargest }

src/main/ts/g0201_0300/s0215_kth_largest_element_in_an_array/solution.ts

@@ -0,0 +1,34 @@
+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'`.