Added js

src/main/js/com_github_leetcode/listnode.js

@@ -0,0 +1,18 @@
+class ListNode {
+    constructor(val, next) {
+        this.val = val === undefined ? 0 : val
+        this.next = next === undefined ? null : next
+    }
+
+    toString() {
+        let result = `${this.val}`
+        let current = this.next
+        while (current !== null) {
+            result += `, ${current.val}`
+            current = current.next
+        }
+        return result
+    }
+}
+
+export { ListNode }

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

@@ -0,0 +1,38 @@
+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]
+
+**Explanation:** 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?

src/main/js/g0001_0100/s0001_two_sum/solution.js

@@ -0,0 +1,22 @@
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table
+// #Data_Structure_I_Day_2_Array #Level_1_Day_13_Hashmap #Udemy_Arrays #Big_O_Time_O(n)_Space_O(n)
+// #AI_can_be_used_to_solve_the_task #2024_11_17_Time_1_ms_(89.15%)_Space_51.9_MB_(13.71%)
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+function twoSum(nums, target) {
+    const indexMap = new Map()
+    for (let i = 0; i < nums.length; i++) {
+        const requiredNum = target - nums[i]
+        if (indexMap.has(requiredNum)) {
+            return [indexMap.get(requiredNum), i]
+        }
+        indexMap.set(nums[i], i)
+    }
+    return [-1, -1]
+}
+
+export { twoSum }

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

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

src/main/js/g0001_0100/s0002_add_two_numbers/solution.js

@@ -0,0 +1,46 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Math #Linked_List #Recursion
+// #Data_Structure_II_Day_10_Linked_List #Programming_Skills_II_Day_15
+// #Big_O_Time_O(max(N,M))_Space_O(max(N,M)) #AI_can_be_used_to_solve_the_task
+// #2024_11_29_Time_3_ms_(81.61%)_Space_55.3_MB_(96.39%)
+
+import { ListNode } from 'src/main/js/com_github_leetcode/listnode'
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function (l1, l2) {
+    const dummyHead = new ListNode(0)
+    let p = l1,
+        q = l2,
+        curr = dummyHead
+    let carry = 0
+
+    while (p !== null || q !== null) {
+        const x = p !== null ? p.val : 0
+        const y = q !== null ? q.val : 0
+        const sum = carry + x + y
+        carry = Math.floor(sum / 10)
+        curr.next = new ListNode(sum % 10)
+        curr = curr.next
+
+        if (p !== null) p = p.next
+        if (q !== null) q = q.next
+    }
+
+    if (carry > 0) {
+        curr.next = new ListNode(carry)
+    }
+
+    return dummyHead.next
+}
+
+export { addTwoNumbers }

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

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

src/main/js/g0001_0100/s0003_longest_substring_without_repeating_characters/solution.js

@@ -0,0 +1,37 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Sliding_Window
+// #Algorithm_I_Day_6_Sliding_Window #Level_2_Day_14_Sliding_Window/Two_Pointer #Udemy_Strings
+// #Big_O_Time_O(n)_Space_O(1) #AI_can_be_used_to_solve_the_task
+// #2024_11_29_Time_3_ms_(98.96%)_Space_53.9_MB_(69.91%)
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function (s) {
+    const lastIndices = new Array(256).fill(-1) // Array to store last indices of characters
+    let maxLen = 0 // Tracks maximum length of substring
+    let curLen = 0 // Current substring length
+    let start = 0 // Start index of the current substring
+
+    for (let i = 0; i < s.length; i++) {
+        const cur = s.charCodeAt(i) // Get ASCII code of the current character
+
+        if (lastIndices[cur] < start) {
+            // If the character hasn't been seen in the current substring
+            lastIndices[cur] = i
+            curLen++
+        } else {
+            // If the character was seen, update the start position
+            const lastIndex = lastIndices[cur]
+            start = lastIndex + 1
+            curLen = i - start + 1
+            lastIndices[cur] = i
+        }
+
+        maxLen = Math.max(maxLen, curLen)
+    }
+
+    return maxLen
+}
+
+export { lengthOfLongestSubstring }

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

@@ -0,0 +1,50 @@
+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>

src/main/js/g0001_0100/s0004_median_of_two_sorted_arrays/solution.js

@@ -0,0 +1,44 @@
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search #Divide_and_Conquer
+// #Big_O_Time_O(log(min(N,M)))_Space_O(1) #AI_can_be_used_to_solve_the_task
+// #2024_11_29_Time_3_ms_(91.90%)_Space_54.1_MB_(88.03%)
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var findMedianSortedArrays = function (nums1, nums2) {
+    if (nums2.length < nums1.length) {
+        return findMedianSortedArrays(nums2, nums1)
+    }
+
+    let n1 = nums1.length,
+        n2 = nums2.length
+    let low = 0,
+        high = n1
+
+    while (low <= high) {
+        let cut1 = Math.floor((low + high) / 2)
+        let cut2 = Math.floor((n1 + n2 + 1) / 2) - cut1
+
+        let l1 = cut1 === 0 ? -Infinity : nums1[cut1 - 1]
+        let l2 = cut2 === 0 ? -Infinity : nums2[cut2 - 1]
+        let r1 = cut1 === n1 ? Infinity : nums1[cut1]
+        let r2 = cut2 === n2 ? Infinity : nums2[cut2]
+
+        if (l1 <= r2 && l2 <= r1) {
+            if ((n1 + n2) % 2 === 0) {
+                return (Math.max(l1, l2) + Math.min(r1, r2)) / 2.0
+            }
+            return Math.max(l1, l2)
+        } else if (l1 > r2) {
+            high = cut1 - 1
+        } else {
+            low = cut1 + 1
+        }
+    }
+
+    return 0.0
+}
+
+export { findMedianSortedArrays }

src/main/js/g0001_0100/s0005_longest_palindromic_substring/readme.md

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