Added dart

pom.xml

@@ -5,7 +5,7 @@
     <groupId>com.github.javadev</groupId>
     <artifactId>leetcode-in-all</artifactId>
     <packaging>jar</packaging>
-    <version>1.3</version>
+    <version>1.4</version>
     <name>leetcode-in-all</name>
     <description>104 LeetCode algorithm problem solutions</description>
     <url>https://github.com/javadev/LeetCode-in-All</url>
@@ -92,6 +92,7 @@
                                 <source>src/main/swift</source>
                                 <source>src/main/elixir</source>
                                 <source>src/main/rust</source>
+                                <source>src/main/dart</source>
                             </sources>
                         </configuration>
                     </execution>

src/main/dart/g0001_0100/s0001_two_sum/Solution.dart

@@ -0,0 +1,17 @@
+// #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_09_28_Time_305_ms_(99.57%)_Space_146.2_MB_(99.70%)
+
+class Solution {
+  List<int> twoSum(List<int> numbers, int target) {
+    Map<int, int> indexMap = {};
+    for (int i = 0; i < numbers.length; i++) {
+      int requiredNum = target - numbers[i];
+      if (indexMap.containsKey(requiredNum)) {
+        return [indexMap[requiredNum]!, i];
+      }
+      indexMap[numbers[i]] = i;
+    }
+    return [-1, -1];
+  }
+}

src/main/dart/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]
+
+**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?

src/main/dart/g0001_0100/s0002_add_two_numbers/Solution.dart

@@ -0,0 +1,40 @@
+// #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_09_28_Time_386_ms_(97.18%)_Space_151.9_MB_(38.24%)
+
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *   int val;
+ *   ListNode? next;
+ *   ListNode([this.val = 0, this.next]);
+ * }
+ */
+class Solution {
+  ListNode addTwoNumbers(ListNode? l1, ListNode? l2) {
+    ListNode dummyHead = ListNode(0);
+    ListNode? p = l1;
+    ListNode? q = l2;
+    ListNode curr = dummyHead;
+    int carry = 0;
+
+    while (p != null || q != null) {
+      int x = (p != null) ? p.val : 0;
+      int y = (q != null) ? q.val : 0;
+      int sum = carry + x + y;
+      carry = sum ~/ 10;
+      curr.next = ListNode(sum % 10);
+      curr = curr.next!;
+
+      if (p != null) p = p.next;
+      if (q != null) q = q.next;
+    }
+
+    if (carry > 0) {
+      curr.next = ListNode(carry);
+    }
+
+    return dummyHead.next!;
+  }
+}

src/main/dart/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/dart/g0001_0100/s0003_longest_substring_without_repeating_characters/Solution.dart

@@ -0,0 +1,29 @@
+// #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) #2024_09_28_Time_336_ms_(99.68%)_Space_149.1_MB_(64.29%)
+
+class Solution {
+  int lengthOfLongestSubstring(String s) {
+    List<int> lastIndices = List.filled(256, -1);
+    int maxLen = 0;
+    int curLen = 0;
+    int start = 0;
+
+    for (int i = 0; i < s.length; i++) {
+      int cur = s.codeUnitAt(i); // Getting ASCII value of the character
+      if (lastIndices[cur] < start) {
+        lastIndices[cur] = i;
+        curLen++;
+      } else {
+        int lastIndex = lastIndices[cur];
+        start = lastIndex + 1;
+        curLen = i - start + 1;
+        lastIndices[cur] = i;
+      }
+      if (curLen > maxLen) {
+        maxLen = curLen;
+      }
+    }
+    return maxLen;
+  }
+}

src/main/dart/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/dart/g0001_0100/s0004_median_of_two_sorted_arrays/Solution.dart

@@ -0,0 +1,43 @@
+// #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)
+// #2024_09_28_Time_393_ms_(100.00%)_Space_151.2_MB_(78.38%)
+
+import 'dart:math';
+
+class Solution {
+  double findMedianSortedArrays(List<int> nums1, List<int> nums2) {
+    if (nums2.length < nums1.length) {
+      return findMedianSortedArrays(nums2, nums1);
+    }
+
+    int n1 = nums1.length;
+    int n2 = nums2.length;
+    int low = 0;
+    int high = n1;
+
+    int minValue = -pow(2, 31).toInt(); // substitute for Integer.MIN_VALUE
+    int maxValue = pow(2, 31).toInt() - 1; // substitute for Integer.MAX_VALUE
+
+    while (low <= high) {
+      int cut1 = (low + high) ~/ 2;
+      int cut2 = ((n1 + n2 + 1) ~/ 2) - cut1;
+
+      int l1 = cut1 == 0 ? minValue : nums1[cut1 - 1];
+      int l2 = cut2 == 0 ? minValue : nums2[cut2 - 1];
+      int r1 = cut1 == n1 ? maxValue : nums1[cut1];
+      int r2 = cut2 == n2 ? maxValue : nums2[cut2];
+
+      if (l1 <= r2 && l2 <= r1) {
+        if ((n1 + n2) % 2 == 0) {
+          return (max(l1, l2) + min(r1, r2)) / 2.0;
+        }
+        return max(l1, l2).toDouble();
+      } else if (l1 > r2) {
+        high = cut1 - 1;
+      } else {
+        low = cut1 + 1;
+      }
+    }
+    return 0.0;
+  }
+}

src/main/dart/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/dart/g0001_0100/s0005_longest_palindromic_substring/Solution.dart

@@ -0,0 +1,48 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
+// #Data_Structure_II_Day_9_String #Algorithm_II_Day_14_Dynamic_Programming
+// #Dynamic_Programming_I_Day_17 #Udemy_Strings #Big_O_Time_O(n)_Space_O(n)
+// #2024_09_28_Time_297_ms_(97.22%)_Space_146.7_MB_(92.59%)
+
+class Solution {
+  String longestPalindrome(String s) {
+    List<String> newStr = List.filled(s.length * 2 + 1, '#');
+
+    for (int i = 0; i < s.length; i++) {
+      newStr[2 * i + 1] = s[i];
+      newStr[2 * i + 2] = '#';
+    }
+
+    List<int> dp = List.filled(newStr.length, 0);
+    int friendCenter = 0;
+    int friendRadius = 0;
+    int lpsCenter = 0;
+    int lpsRadius = 0;
+
+    for (int i = 0; i < newStr.length; i++) {
+      dp[i] = (friendCenter + friendRadius > i)
+          ? (dp[friendCenter * 2 - i] < (friendCenter + friendRadius) - i
+          ? dp[friendCenter * 2 - i]
+          : (friendCenter + friendRadius) - i)
+          : 1;
+
+      while (i + dp[i] < newStr.length &&
+          i - dp[i] >= 0 &&
+          newStr[i + dp[i]] == newStr[i - dp[i]]) {
+        dp[i]++;
+      }
+
+      if (friendCenter + friendRadius < i + dp[i]) {
+        friendCenter = i;
+        friendRadius = dp[i];
+      }
+
+      if (lpsRadius < dp[i]) {
+        lpsCenter = i;
+        lpsRadius = dp[i];
+      }
+    }
+
+    return s.substring(
+        (lpsCenter - lpsRadius + 1) ~/ 2, (lpsCenter + lpsRadius - 1) ~/ 2);
+  }
+}