feat: updates jan 11 2025

Author: Shamik07

1009-complement-base-10.dart

@@ -0,0 +1,26 @@
+class Solution {
+  int findComplement(int num) {
+    if (num == 0) return 1;
+
+    int mask = num;
+    mask |= mask >> 1;
+    mask |= mask >> 2;
+    mask |= mask >> 4;
+    mask |= mask >> 8;
+    mask |= mask >> 16;
+
+    return num ^ mask;
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  // Test Case 1
+  final num1 = 5;
+  print('Example 1: ${solution.findComplement(num1)}'); // Output: 2
+
+  // Test Case 2
+  final num2 = 1;
+  print('Example 2: ${solution.findComplement(num2)}'); // Output: 0
+}

1400-k-palindrome-strings.dart

@@ -0,0 +1,28 @@
+class Solution {
+  bool canConstruct(String s, int k) {
+    if (k > s.length) return false;
+    if (k == s.length) return true;
+    
+    List<int> freq = List.filled(26, 0);
+    for (int i = 0; i < s.length; i++) {
+      freq[s.codeUnitAt(i) - 'a'.codeUnitAt(0)]++;
+    }
+    
+    int oddCount = 0;
+    for (int count in freq) {
+      if (count % 2 == 1) {
+        oddCount++;
+      }
+    }
+    return oddCount <= k;
+  }
+}
+
+void main() {
+  final solution = Solution();
+  
+  print('Test 1: ${solution.canConstruct("annabelle", 2)}'); // true
+  print('Test 2: ${solution.canConstruct("leetcode", 3)}'); // false
+  print('Test 3: ${solution.canConstruct("true", 4)}'); // true
+
+}

145-binary-tree-postorder.dart

@@ -0,0 +1,75 @@
+/**
+ * Definition for a binary tree node.
+ */
+class TreeNode {
+  int val;
+  TreeNode? left;
+  TreeNode? right;
+  TreeNode([this.val = 0, this.left, this.right]);
+}
+
+class Solution {
+  List<int> postorderTraversal(TreeNode? root) {
+    List<int> result = [];
+    if (root == null) return result;
+
+    List<TreeNode> stack1 = [];
+    List<TreeNode> stack2 = [];
+
+    stack1.add(root);
+
+    while (stack1.isNotEmpty) {
+      TreeNode node = stack1.removeLast();
+      stack2.add(node);
+
+      if (node.left != null) {
+        stack1.add(node.left!);
+      }
+      if (node.right != null) {
+        stack1.add(node.right!);
+      }
+    }
+
+    while (stack2.isNotEmpty) {
+      result.add(stack2.removeLast().val);
+    }
+
+    return result;
+  }
+}
+
+void main() {
+  Solution solution = Solution();
+
+  TreeNode? createTree(List<int?> values) {
+    if (values.isEmpty || values[0] == null) return null;
+
+    TreeNode root = TreeNode(values[0]!);
+    List<TreeNode> queue = [root];
+    int i = 1;
+
+    while (queue.isNotEmpty && i < values.length) {
+      TreeNode current = queue.removeAt(0);
+
+      if (i < values.length && values[i] != null) {
+        current.left = TreeNode(values[i]!);
+        queue.add(current.left!);
+      }
+      i++;
+
+      if (i < values.length && values[i] != null) {
+        current.right = TreeNode(values[i]!);
+        queue.add(current.right!);
+      }
+      i++;
+    }
+
+    return root;
+  }
+
+  var tree1 = createTree([1, null, 2, 3]);
+  print('Test 1: ${solution.postorderTraversal(tree1)}'); // [3,2,1]
+
+  var tree2 = createTree([1]);
+  print('Test 2: ${solution.postorderTraversal(tree2)}'); // [1]
+}

2116-validate-locked-parentheses.dart

@@ -0,0 +1,41 @@
+class Solution {
+  bool canBeValid(String s, String locked) {
+    if (s.length % 2 != 0) return false;
+    
+    int balance = 0;
+    int wild = 0;
+    
+    for (int i = 0; i < s.length; i++) {
+      if (locked[i] == '1') {
+        balance += s[i] == '(' ? 1 : -1;
+      } else {
+        wild++;
+      }
+      
+      if (balance + wild < 0) return false;
+    }
+    
+    balance = 0;
+    wild = 0;
+    
+    for (int i = s.length - 1; i >= 0; i--) {
+      if (locked[i] == '1') {
+        balance += s[i] == ')' ? 1 : -1;
+      } else {
+        wild++;
+      }
+      
+      if (balance + wild < 0) return false;
+    }
+    
+    return true;
+  }
+}
+
+void main() {
+  final solution = Solution();
+  
+  print(solution.canBeValid("))()))", "010100")); // true
+  print(solution.canBeValid("()()", "0000")); // true
+  print(solution.canBeValid(")", "0")); // false
+}

2185-counting-words-prefix.dart

@@ -0,0 +1,29 @@
+class Solution {
+  int prefixCount(List<String> words, String pref) {
+    int count = 0;
+
+    for (String word in words) {
+      if (word.startsWith(pref)) {
+        count++;
+      }
+    }
+
+    return count;
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  final words1 = ["pay", "attention", "practice", "attend"];
+  final pref1 = "at";
+  print('1: ${solution.prefixCount(words1, pref1)}'); // Output: 2
+
+  final words2 = ["leetcode", "win", "loops", "success"];
+  final pref2 = "code";
+  print('2: ${solution.prefixCount(words2, pref2)}'); // Output: 0
+
+  final words3 = ["abc", "acd", "abd", "abx", "bcd"];
+  final pref3 = "ab";
+  print('3: ${solution.prefixCount(words3, pref3)}'); // Output: 3
+}

476-number-complement.dart

@@ -0,0 +1,26 @@
+class Solution {
+  int findComplement(int num) {
+    if (num == 0) return 1;
+
+    int mask = num;
+    mask |= mask >> 1;
+    mask |= mask >> 2;
+    mask |= mask >> 4;
+    mask |= mask >> 8;
+    mask |= mask >> 16;
+
+    return num ^ mask;
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  // Test Case 1
+  final num1 = 5;
+  print('Example 1: ${solution.findComplement(num1)}'); // Output: 2
+
+  // Test Case 2
+  final num2 = 1;
+  print('Example 2: ${solution.findComplement(num2)}'); // Output: 0
+}

590-nary-tree-postorder.dart

@@ -0,0 +1,38 @@
+class Solution {
+  bool lemonadeChange(List<int> bills) {
+    int five = 0;
+    int ten = 0;
+
+    for (int bill in bills) {
+      if (bill == 5) {
+        five++;
+      } else if (bill == 10) {
+        if (five == 0) return false;
+        five--;
+        ten++;
+      } else {
+        // bill == 20
+        if (ten > 0 && five > 0) {
+          ten--;
+          five--;
+        } else if (five >= 3) {
+          five -= 3;
+        } else {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  final bills1 = [5, 5, 5, 10, 20];
+  print('Example 1: ${solution.lemonadeChange(bills1)}'); // Output: true
+
+  final bills2 = [5, 5, 10, 10, 20];
+  print('Example 2: ${solution.lemonadeChange(bills2)}'); // Output: false
+}

860-lemonade-change.dart

@@ -0,0 +1,58 @@
+class Solution {
+  List<String> wordSubsets(List<String> words1, List<String> words2) {
+    List<String> result = [];
+    List<int> maxFreq = List.filled(26, 0);
+
+    for (String word in words2) {
+      List<int> freq = getFrequency(word);
+      for (int i = 0; i < 26; i++) {
+        maxFreq[i] = maxFreq[i] > freq[i] ? maxFreq[i] : freq[i];
+      }
+    }
+
+    for (String word in words1) {
+      List<int> freq = getFrequency(word);
+      bool isUniversal = true;
+
+      for (int i = 0; i < 26; i++) {
+        if (freq[i] < maxFreq[i]) {
+          isUniversal = false;
+          break;
+        }
+      }
+
+      if (isUniversal) {
+        result.add(word);
+      }
+    }
+
+    return result;
+  }
+
+  List<int> getFrequency(String word) {
+    List<int> freq = List.filled(26, 0);
+    for (int i = 0; i < word.length; i++) {
+      freq[word.codeUnitAt(i) - 'a'.codeUnitAt(0)]++;
+    }
+    return freq;
+  }
+}
+
+void main() {
+  final solution = Solution();
+
+  List<String> words1 = ["amazon", "apple", "facebook", "google", "leetcode"];
+  List<String> words2 = ["e", "o"];
+  print('Test 1: ${solution.wordSubsets(words1, words2)}');
+  // Output: ["facebook","google","leetcode"]
+
+  List<String> words3 = ["amazon", "apple", "facebook", "google", "leetcode"];
+  List<String> words4 = ["l", "e"];
+  print('Test 2: ${solution.wordSubsets(words3, words4)}');
+  // Output: ["apple","google","leetcode"]
+
+  List<String> words5 = ["warrior", "world", "win"];
+  List<String> words6 = ["wr"];
+  print('Test 3: ${solution.wordSubsets(words5, words6)}');
+  // Output: ["warrior","world"]
+}