leet-tui 0.1.0 → 0.1.1

package/scripts/test_solutions/001_two_sum.c

@@ -0,0 +1,15 @@
+int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
+    *returnSize = 2;
+    int* result = (int*)malloc(2 * sizeof(int));
+    for (int i = 0; i < numsSize; i++) {
+        for (int j = i + 1; j < numsSize; j++) {
+            if (nums[i] + nums[j] == target) {
+                result[0] = i;
+                result[1] = j;
+                return result;
+            }
+        }
+    }
+    *returnSize = 0;
+    return result;
+}

package/scripts/test_solutions/001_two_sum.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> seen;
+        for (int i = 0; i < nums.size(); i++) {
+            int complement = target - nums[i];
+            if (seen.count(complement)) {
+                return {seen[complement], i};
+            }
+            seen[nums[i]] = i;
+        }
+        return {};
+    }
+};

package/scripts/test_solutions/001_two_sum.js

@@ -0,0 +1,11 @@
+var twoSum = function(nums, target) {
+    const map = new Map();
+    for (let i = 0; i < nums.length; i++) {
+        const complement = target - nums[i];
+        if (map.has(complement)) {
+            return [map.get(complement), i];
+        }
+        map.set(nums[i], i);
+    }
+    return [];
+};

package/scripts/test_solutions/001_two_sum.py

@@ -0,0 +1,8 @@
+def twoSum(nums, target):
+    seen = {}
+    for i, num in enumerate(nums):
+        complement = target - num
+        if complement in seen:
+            return [seen[complement], i]
+        seen[num] = i
+    return []

package/scripts/test_solutions/007_reverse_integer.c

@@ -0,0 +1,9 @@
+int reverse(int x) {
+    long result = 0;
+    while (x != 0) {
+        result = result * 10 + x % 10;
+        x /= 10;
+    }
+    if (result < INT_MIN || result > INT_MAX) return 0;
+    return (int)result;
+}

package/scripts/test_solutions/007_reverse_integer.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int reverse(int x) {
+        long result = 0;
+        while (x != 0) {
+            result = result * 10 + x % 10;
+            x /= 10;
+        }
+        if (result < INT_MIN || result > INT_MAX) return 0;
+        return (int)result;
+    }
+};

package/scripts/test_solutions/007_reverse_integer.js

@@ -0,0 +1,12 @@
+var reverse = function(x) {
+    const sign = x < 0 ? -1 : 1;
+    let result = 0;
+    x = Math.abs(x);
+    while (x > 0) {
+        result = result * 10 + (x % 10);
+        x = Math.floor(x / 10);
+    }
+    result *= sign;
+    if (result < -(2**31) || result > 2**31 - 1) return 0;
+    return result;
+};

package/scripts/test_solutions/007_reverse_integer.py

@@ -0,0 +1,11 @@
+def reverse(x):
+    sign = -1 if x < 0 else 1
+    x = abs(x)
+    result = 0
+    while x > 0:
+        result = result * 10 + x % 10
+        x //= 10
+    result *= sign
+    if result < -(2**31) or result > 2**31 - 1:
+        return 0
+    return result

package/scripts/test_solutions/049_group_anagrams.c

@@ -0,0 +1,14 @@
+// Note: C implementation requires complex memory management
+// This is a simplified version for reference
+char*** groupAnagrams(char** strs, int strsSize, int* returnSize, int** returnColumnSizes) {
+    // Simplified: return input as single group for testing scaffold
+    *returnSize = strsSize;
+    *returnColumnSizes = (int*)malloc(strsSize * sizeof(int));
+    char*** result = (char***)malloc(strsSize * sizeof(char**));
+    for (int i = 0; i < strsSize; i++) {
+        result[i] = (char**)malloc(sizeof(char*));
+        result[i][0] = strs[i];
+        (*returnColumnSizes)[i] = 1;
+    }
+    return result;
+}

package/scripts/test_solutions/049_group_anagrams.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    vector<vector<string>> groupAnagrams(vector<string>& strs) {
+        unordered_map<string, vector<string>> groups;
+        for (const string& s : strs) {
+            string key = s;
+            sort(key.begin(), key.end());
+            groups[key].push_back(s);
+        }
+        vector<vector<string>> result;
+        for (auto& [key, group] : groups) {
+            result.push_back(group);
+        }
+        return result;
+    }
+};

package/scripts/test_solutions/049_group_anagrams.js

@@ -0,0 +1,9 @@
+var groupAnagrams = function(strs) {
+    const map = new Map();
+    for (const s of strs) {
+        const key = s.split('').sort().join('');
+        if (!map.has(key)) map.set(key, []);
+        map.get(key).push(s);
+    }
+    return Array.from(map.values());
+};

package/scripts/test_solutions/049_group_anagrams.py

@@ -0,0 +1,8 @@
+def groupAnagrams(strs):
+    groups = {}
+    for s in strs:
+        key = ''.join(sorted(s))
+        if key not in groups:
+            groups[key] = []
+        groups[key].append(s)
+    return list(groups.values())

package/scripts/test_solutions/190_reverse_bits.c

@@ -0,0 +1,8 @@
+uint32_t reverseBits(uint32_t n) {
+    uint32_t result = 0;
+    for (int i = 0; i < 32; i++) {
+        result = (result << 1) | (n & 1);
+        n >>= 1;
+    }
+    return result;
+}

package/scripts/test_solutions/190_reverse_bits.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    uint32_t reverseBits(uint32_t n) {
+        uint32_t result = 0;
+        for (int i = 0; i < 32; i++) {
+            result = (result << 1) | (n & 1);
+            n >>= 1;
+        }
+        return result;
+    }
+};

package/scripts/test_solutions/190_reverse_bits.js

@@ -0,0 +1,8 @@
+var reverseBits = function(n) {
+    let result = 0;
+    for (let i = 0; i < 32; i++) {
+        result = (result << 1) | (n & 1);
+        n >>>= 1;
+    }
+    return result >>> 0;
+};

package/scripts/test_solutions/190_reverse_bits.py

@@ -0,0 +1,6 @@
+def reverseBits(n):
+    result = 0
+    for _ in range(32):
+        result = (result << 1) | (n & 1)
+        n >>= 1
+    return result

package/scripts/test_solutions/217_contains_duplicate.c

@@ -0,0 +1,17 @@
+int compare(const void* a, const void* b) {
+    return (*(int*)a - *(int*)b);
+}
+
+bool containsDuplicate(int* nums, int numsSize) {
+    int* sorted = (int*)malloc(numsSize * sizeof(int));
+    memcpy(sorted, nums, numsSize * sizeof(int));
+    qsort(sorted, numsSize, sizeof(int), compare);
+    for (int i = 1; i < numsSize; i++) {
+        if (sorted[i] == sorted[i-1]) {
+            free(sorted);
+            return true;
+        }
+    }
+    free(sorted);
+    return false;
+}

package/scripts/test_solutions/217_contains_duplicate.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        unordered_set<int> seen;
+        for (int num : nums) {
+            if (seen.count(num)) return true;
+            seen.insert(num);
+        }
+        return false;
+    }
+};

package/scripts/test_solutions/217_contains_duplicate.js

@@ -0,0 +1,8 @@
+var containsDuplicate = function(nums) {
+    const seen = new Set();
+    for (const num of nums) {
+        if (seen.has(num)) return true;
+        seen.add(num);
+    }
+    return false;
+};

package/scripts/test_solutions/217_contains_duplicate.py

@@ -0,0 +1,2 @@
+def containsDuplicate(nums):
+    return len(nums) != len(set(nums))

package/scripts/test_solutions/242_valid_anagram.c

@@ -0,0 +1,14 @@
+bool isAnagram(char* s, char* t) {
+    int count[26] = {0};
+    int sLen = strlen(s);
+    int tLen = strlen(t);
+    if (sLen != tLen) return false;
+    for (int i = 0; i < sLen; i++) {
+        count[s[i] - 'a']++;
+        count[t[i] - 'a']--;
+    }
+    for (int i = 0; i < 26; i++) {
+        if (count[i] != 0) return false;
+    }
+    return true;
+}

package/scripts/test_solutions/242_valid_anagram.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    bool isAnagram(string s, string t) {
+        if (s.length() != t.length()) return false;
+        int count[26] = {0};
+        for (int i = 0; i < s.length(); i++) {
+            count[s[i] - 'a']++;
+            count[t[i] - 'a']--;
+        }
+        for (int i = 0; i < 26; i++) {
+            if (count[i] != 0) return false;
+        }
+        return true;
+    }
+};

package/scripts/test_solutions/242_valid_anagram.js

@@ -0,0 +1,10 @@
+var isAnagram = function(s, t) {
+    if (s.length !== t.length) return false;
+    const count = {};
+    for (const c of s) count[c] = (count[c] || 0) + 1;
+    for (const c of t) {
+        if (!count[c]) return false;
+        count[c]--;
+    }
+    return true;
+};

package/scripts/test_solutions/242_valid_anagram.py

@@ -0,0 +1,11 @@
+def isAnagram(s, t):
+    if len(s) != len(t):
+        return False
+    count = {}
+    for c in s:
+        count[c] = count.get(c, 0) + 1
+    for c in t:
+        if c not in count or count[c] == 0:
+            return False
+        count[c] -= 1
+    return True

package/scripts/test_solutions/268_missing_number.c

@@ -0,0 +1,7 @@
+int missingNumber(int* nums, int numsSize) {
+    int xorVal = numsSize;
+    for (int i = 0; i < numsSize; i++) {
+        xorVal ^= i ^ nums[i];
+    }
+    return xorVal;
+}

package/scripts/test_solutions/268_missing_number.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    int missingNumber(vector<int>& nums) {
+        int xorVal = nums.size();
+        for (int i = 0; i < nums.size(); i++) {
+            xorVal ^= i ^ nums[i];
+        }
+        return xorVal;
+    }
+};

package/scripts/test_solutions/268_missing_number.js

@@ -0,0 +1,8 @@
+var missingNumber = function(nums) {
+    const n = nums.length;
+    let xor = n;
+    for (let i = 0; i < n; i++) {
+        xor ^= i ^ nums[i];
+    }
+    return xor;
+};

package/scripts/test_solutions/268_missing_number.py

@@ -0,0 +1,6 @@
+def missingNumber(nums):
+    n = len(nums)
+    xor = n
+    for i in range(n):
+        xor ^= i ^ nums[i]
+    return xor

package/scripts/test_solutions/338_counting_bits.c

@@ -0,0 +1,8 @@
+int* countBits(int n, int* returnSize) {
+    *returnSize = n + 1;
+    int* ans = (int*)calloc(n + 1, sizeof(int));
+    for (int i = 1; i <= n; i++) {
+        ans[i] = ans[i >> 1] + (i & 1);
+    }
+    return ans;
+}

package/scripts/test_solutions/338_counting_bits.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    vector<int> countBits(int n) {
+        vector<int> ans(n + 1, 0);
+        for (int i = 1; i <= n; i++) {
+            ans[i] = ans[i >> 1] + (i & 1);
+        }
+        return ans;
+    }
+};

package/scripts/test_solutions/338_counting_bits.js

@@ -0,0 +1,7 @@
+var countBits = function(n) {
+    const ans = new Array(n + 1).fill(0);
+    for (let i = 1; i <= n; i++) {
+        ans[i] = ans[i >> 1] + (i & 1);
+    }
+    return ans;
+};

package/scripts/test_solutions/338_counting_bits.py

@@ -0,0 +1,5 @@
+def countBits(n):
+    ans = [0] * (n + 1)
+    for i in range(1, n + 1):
+        ans[i] = ans[i >> 1] + (i & 1)
+    return ans

package/scripts/test_solutions/347_top_k_frequent.c

@@ -0,0 +1,29 @@
+typedef struct { int num; int count; } Pair;
+
+int cmpPair(const void* a, const void* b) {
+    return ((Pair*)b)->count - ((Pair*)a)->count;
+}
+
+int* topKFrequent(int* nums, int numsSize, int k, int* returnSize) {
+    Pair* pairs = (Pair*)calloc(20001, sizeof(Pair));
+    int uniqueCount = 0;
+    for (int i = 0; i < numsSize; i++) {
+        int idx = nums[i] + 10000;
+        if (pairs[idx].count == 0) {
+            pairs[idx].num = nums[i];
+            uniqueCount++;
+        }
+        pairs[idx].count++;
+    }
+    Pair* sorted = (Pair*)malloc(uniqueCount * sizeof(Pair));
+    int j = 0;
+    for (int i = 0; i < 20001; i++) {
+        if (pairs[i].count > 0) sorted[j++] = pairs[i];
+    }
+    qsort(sorted, uniqueCount, sizeof(Pair), cmpPair);
+    *returnSize = k;
+    int* result = (int*)malloc(k * sizeof(int));
+    for (int i = 0; i < k; i++) result[i] = sorted[i].num;
+    free(pairs); free(sorted);
+    return result;
+}

package/scripts/test_solutions/347_top_k_frequent.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    vector<int> topKFrequent(vector<int>& nums, int k) {
+        unordered_map<int, int> freq;
+        for (int n : nums) freq[n]++;
+        vector<vector<int>> bucket(nums.size() + 1);
+        for (auto& [num, count] : freq) {
+            bucket[count].push_back(num);
+        }
+        vector<int> result;
+        for (int i = bucket.size() - 1; i >= 0 && result.size() < k; i--) {
+            for (int num : bucket[i]) {
+                result.push_back(num);
+                if (result.size() == k) break;
+            }
+        }
+        return result;
+    }
+};

package/scripts/test_solutions/347_top_k_frequent.js

@@ -0,0 +1,11 @@
+var topKFrequent = function(nums, k) {
+    const freq = new Map();
+    for (const n of nums) freq.set(n, (freq.get(n) || 0) + 1);
+    const bucket = Array.from({length: nums.length + 1}, () => []);
+    for (const [num, count] of freq) bucket[count].push(num);
+    const result = [];
+    for (let i = bucket.length - 1; i >= 0 && result.length < k; i--) {
+        result.push(...bucket[i]);
+    }
+    return result.slice(0, k);
+};

package/scripts/test_solutions/347_top_k_frequent.py

@@ -0,0 +1,13 @@
+def topKFrequent(nums, k):
+    freq = {}
+    for n in nums:
+        freq[n] = freq.get(n, 0) + 1
+    bucket = [[] for _ in range(len(nums) + 1)]
+    for num, count in freq.items():
+        bucket[count].append(num)
+    result = []
+    for i in range(len(bucket) - 1, -1, -1):
+        result.extend(bucket[i])
+        if len(result) >= k:
+            break
+    return result[:k]

package/scripts/test_solutions/371_sum_of_two_integers.c

@@ -0,0 +1,8 @@
+int getSum(int a, int b) {
+    while (b != 0) {
+        unsigned carry = (unsigned)(a & b) << 1;
+        a = a ^ b;
+        b = carry;
+    }
+    return a;
+}

package/scripts/test_solutions/371_sum_of_two_integers.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    int getSum(int a, int b) {
+        while (b != 0) {
+            unsigned carry = (unsigned)(a & b) << 1;
+            a = a ^ b;
+            b = carry;
+        }
+        return a;
+    }
+};

package/scripts/test_solutions/371_sum_of_two_integers.js

@@ -0,0 +1,8 @@
+var getSum = function(a, b) {
+    while (b !== 0) {
+        const carry = (a & b) << 1;
+        a = a ^ b;
+        b = carry;
+    }
+    return a;
+};

package/scripts/test_solutions/371_sum_of_two_integers.py

@@ -0,0 +1,8 @@
+def getSum(a, b):
+    MASK = 0xFFFFFFFF
+    MAX_INT = 0x7FFFFFFF
+    while b != 0:
+        carry = ((a & b) << 1) & MASK
+        a = (a ^ b) & MASK
+        b = carry
+    return a if a <= MAX_INT else ~(a ^ MASK)