feat: updates mar 3 2025

Author: Shamik07

.DS_Store

@@ -0,0 +1,78 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *   int val;
+ *   TreeNode? left;
+ *   TreeNode? right;
+ *   TreeNode([this.val = 0, this.left, this.right]);
+ * }
+ */
+
+class TreeNode {
+  int val;
+  TreeNode? left;
+  TreeNode? right;
+  TreeNode([this.val = 0, this.left, this.right]);
+}
+
+class Solution {
+  TreeNode? recoverFromPreorder(String traversal) {
+    if (traversal.isEmpty) return null;
+
+    List<TreeNode> stack = [];
+    int index = 0;
+
+    while (index < traversal.length) {
+      int depth = 0;
+      while (index < traversal.length && traversal[index] == '-') {
+        depth++;
+        index++;
+      }
+
+      int value = 0;
+      while (index < traversal.length && traversal[index] != '-') {
+        value =
+            value * 10 + (traversal[index].codeUnitAt(0) - '0'.codeUnitAt(0));
+        index++;
+      }
+
+      TreeNode currentNode = TreeNode(value);
+
+      if (depth == 0) {
+        stack.add(currentNode);
+        continue;
+      }
+
+      while (stack.length > depth) {
+        stack.removeLast();
+      }
+
+      TreeNode parent = stack.last;
+      if (parent.left == null) {
+        parent.left = currentNode;
+      } else {
+        parent.right = currentNode;
+      }
+
+      stack.add(currentNode);
+    }
+
+    return stack.first;
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  // Test Case 1
+  TreeNode? result1 = solution.recoverFromPreorder("1-2--3--4-5--6--7");
+  print(result1?.val); // 1
+
+  // Test Case 2
+  TreeNode? result2 = solution.recoverFromPreorder("1-2--3---4-5--6---7");
+  print(result2?.val); // 1
+
+  // Test Case 3
+  TreeNode? result3 = solution.recoverFromPreorder("1-401--349---90--88");
+  print(result3?.val); // 1
+}

1028-recover-tree-preorder.dart

@@ -0,0 +1,43 @@
+class Solution {
+  int numTilePossibilities(String tiles) {
+    Map<String, int> frequency = {};
+    for (int i = 0; i < tiles.length; i++) {
+      String char = tiles[i];
+      frequency[char] = (frequency[char] ?? 0) + 1;
+    }
+
+    int result = 0;
+
+    void backtrack() {
+      for (var entry in frequency.entries) {
+        String char = entry.key;
+        int count = entry.value;
+
+        if (count > 0) {
+          result++;
+          frequency[char] = count - 1;
+
+          backtrack();
+
+          frequency[char] = count;
+        }
+      }
+    }
+
+    backtrack();
+    return result;
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  // Test Case 1
+  print(solution.numTilePossibilities("AAB")); // 8
+
+  // Test Case 2
+  print(solution.numTilePossibilities("AAABBC")); // 188
+
+  // Test Case 3
+  print(solution.numTilePossibilities("V")); // 1
+}

1079-letter-tile-possibilities.dart

@@ -0,0 +1,60 @@
+class Solution {
+  String shortestCommonSupersequence(String str1, String str2) {
+    int m = str1.length;
+    int n = str2.length;
+
+    List<List<int>> dp = List.generate(m + 1, (_) => List.filled(n + 1, 0));
+
+    for (int i = 1; i <= m; i++) {
+      for (int j = 1; j <= n; j++) {
+        if (str1[i - 1] == str2[j - 1]) {
+          dp[i][j] = dp[i - 1][j - 1] + 1;
+        } else {
+          dp[i][j] = dp[i - 1][j] > dp[i][j - 1] ? dp[i - 1][j] : dp[i][j - 1];
+        }
+      }
+    }
+
+    int i = m, j = n;
+    StringBuffer scs = StringBuffer();
+
+    while (i > 0 && j > 0) {
+      if (str1[i - 1] == str2[j - 1]) {
+        scs.write(str1[i - 1]);
+        i--;
+        j--;
+      } else if (dp[i - 1][j] > dp[i][j - 1]) {
+        scs.write(str1[i - 1]);
+        i--;
+      } else {
+        scs.write(str2[j - 1]);
+        j--;
+      }
+    }
+
+    while (i > 0) {
+      scs.write(str1[i - 1]);
+      i--;
+    }
+    while (j > 0) {
+      scs.write(str2[j - 1]);
+      j--;
+    }
+
+    return scs.toString().split('').reversed.join();
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  // Test Case 1
+  print(solution.shortestCommonSupersequence("abac", "cab")); // "cabac"
+
+  // Test Case 2
+  print(solution.shortestCommonSupersequence(
+      "aaaaaaaa", "aaaaaaaa")); // "aaaaaaaa"
+
+  // Test Case 3
+  print(solution.shortestCommonSupersequence("abc", "def")); // "abcdef"
+}

1092-shortest-common-supersequence.dart

@@ -0,0 +1,66 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *   int val;
+ *   TreeNode? left;
+ *   TreeNode? right;
+ *   TreeNode([this.val = 0, this.left, this.right]);
+ * }
+ */
+
+class TreeNode {
+  int val;
+  TreeNode? left;
+  TreeNode? right;
+  TreeNode([this.val = 0, this.left, this.right]);
+}
+
+class FindElements {
+  Set<int> _values = {};
+
+  FindElements(TreeNode? root) {
+    _recoverTree(root, 0);
+  }
+
+  void _recoverTree(TreeNode? node, int val) {
+    if (node == null) return;
+
+    node.val = val;
+    _values.add(val);
+
+    _recoverTree(node.left, 2 * val + 1);
+    _recoverTree(node.right, 2 * val + 2);
+  }
+
+  bool find(int target) {
+    return _values.contains(target);
+  }
+}
+
+/**
+ * Your FindElements object will be instantiated and called as such:
+ * FindElements obj = FindElements(root);
+ * bool param1 = obj.find(target);
+ */
+
+void main() {
+  // Test Case 1
+  TreeNode root1 = TreeNode(-1, TreeNode(-1), TreeNode(-1));
+  FindElements findElements1 = FindElements(root1);
+  print(findElements1.find(1)); // true
+  print(findElements1.find(2)); // true
+  print(findElements1.find(3)); // false
+
+  // Test Case 2
+  TreeNode root2 = TreeNode(-1, null, TreeNode(-1));
+  FindElements findElements2 = FindElements(root2);
+  print(findElements2.find(1)); // false
+  print(findElements2.find(2)); // true
+
+  // Test Case 3
+  TreeNode root3 = TreeNode(-1, TreeNode(-1, TreeNode(-1), null), TreeNode(-1));
+  FindElements findElements3 = FindElements(root3);
+  print(findElements3.find(1)); // true
+  print(findElements3.find(3)); // true
+  print(findElements3.find(5)); // false
+}

1261-elements-contaminated-tree.dart

@@ -0,0 +1,60 @@
+class ProductOfNumbers {
+  List<int> prefixProducts;
+
+  ProductOfNumbers() : prefixProducts = [1];
+
+  void add(int num) {
+    if (num == 0) {
+      prefixProducts = [1];
+    } else {
+      prefixProducts.add(prefixProducts.last * num);
+    }
+  }
+
+  int getProduct(int k) {
+    if (k >= prefixProducts.length) {
+      return 0;
+    }
+    return prefixProducts[prefixProducts.length - 1] ~/
+        prefixProducts[prefixProducts.length - 1 - k];
+  }
+}
+
+/**
+ * Your ProductOfNumbers object will be instantiated and called as such:
+ * ProductOfNumbers obj = ProductOfNumbers();
+ * obj.add(num);
+ * int param2 = obj.getProduct(k);
+ */
+
+void main() {
+  // Test Case 1
+  final product1 = ProductOfNumbers();
+  product1.add(3);
+  product1.add(0);
+  product1.add(2);
+  product1.add(5);
+  product1.add(4);
+  print(product1.getProduct(2)); // 20
+  print(product1.getProduct(3)); // 40
+  print(product1.getProduct(4)); // 0
+
+  // Test Case 2
+  final product2 = ProductOfNumbers();
+  product2.add(1);
+  product2.add(2);
+  product2.add(3);
+  print(product2.getProduct(1)); // 3
+  print(product2.getProduct(2)); // 6
+  print(product2.getProduct(3)); // 6
+
+  // Test Case 3
+  final product3 = ProductOfNumbers();
+  product3.add(5);
+  product3.add(2);
+  product3.add(0);
+  product3.add(4);
+  print(product3.getProduct(1)); // 4
+  print(product3.getProduct(2)); // 0
+  print(product3.getProduct(3)); // 0
+}

1352-product-last-k.dart

@@ -0,0 +1,41 @@
+class Solution {
+  String getHappyString(int n, int k) {
+    String result = "";
+    int count = 0;
+
+    void backtrack(String current) {
+      if (current.length == n) {
+        count++;
+        if (count == k) {
+          result = current;
+        }
+        return;
+      }
+
+      for (String char in ['a', 'b', 'c']) {
+        if (current.isEmpty || current[current.length - 1] != char) {
+          backtrack(current + char);
+          if (result.isNotEmpty) {
+            return;
+          }
+        }
+      }
+    }
+
+    backtrack("");
+    return result;
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  // Test Case 1
+  print(solution.getHappyString(1, 3)); // "c"
+
+  // Test Case 2
+  print(solution.getHappyString(3, 9)); // "cab"
+
+  // Test Case 3
+  print(solution.getHappyString(2, 7)); // ""
+}

1415-kth-lexicographical-happy.dart

@@ -0,0 +1,35 @@
+class Solution {
+  int numOfSubarrays(List<int> arr) {
+    const int MOD = 1000000007;
+    int prefixSum = 0;
+    int oddCount = 0;
+    int evenCount = 1;
+    int result = 0;
+
+    for (int num in arr) {
+      prefixSum += num;
+      if (prefixSum % 2 == 1) {
+        result = (result + evenCount) % MOD;
+        oddCount++;
+      } else {
+        result = (result + oddCount) % MOD;
+        evenCount++;
+      }
+    }
+
+    return result;
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  // Test Case 1
+  print(solution.numOfSubarrays([1, 3, 5])); // 4
+
+  // Test Case 2
+  print(solution.numOfSubarrays([2, 4, 6])); // 0
+
+  // Test Case 3
+  print(solution.numOfSubarrays([1, 2, 3, 4, 5])); // 9
+}