add 77, 191, 704, 1351, 2724; update 1, 146, 191, 2469

rustykitty · rustykitty · commit fc93ffc1f3fd · 2025-02-06T19:45:56.000-08:00
diff --git a/0001-two-sum.py b/0001-two-sum.py
@@ -11,7 +11,9 @@ class Solution:
     def twoSum(self, nums: List[int], target: int) -> List[int]:
         d = {}
         return next(x for x in (
-            (i, d[target - nums[i]]) if ((target - nums[i]) in d) else d.update({ nums[i]: i })
+            (i, d[target - nums[i]]) 
+            if ((target - nums[i]) in d) 
+            else d.__setitem__(nums[i], i) 
             for i in range(len(nums))
             ) if x is not None
         )
diff --git a/0077-combinations.py b/0077-combinations.py
@@ -0,0 +1,14 @@
+"""
+77. Combinations
+
+Submitted: January 29, 2025
+
+Runtime: 23 ms (beats 97.78%)
+Memory: 56.92 MB (beats 98.34%)
+"""
+
+from itertools import combinations
+
+class Solution:
+    def combine(self, n: int, k: int) -> List[List[int]]:
+        return list(combinations(range(1, n + 1), k))
diff --git a/0146-lru-cache.py b/0146-lru-cache.py
@@ -0,0 +1,33 @@
+"""
+146. LRU Cache
+
+Submitted: January 24, 2025
+
+Runtime: 116 ms (beats 82.52%)
+Memory: 78.04 MB (beats 88.47%)
+"""
+
+from collections import OrderedDict
+
+class LRUCache(OrderedDict):
+
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+
+    def get(self, key: int) -> int:
+        if key in self:
+            self.move_to_end(key, last=True)
+            return self[key]
+        else:
+            return -1
+
+    def put(self, key: int, value: int) -> None:
+        if key in self: self.move_to_end(key, last=True)
+        self[key] = value
+        while len(self) > self.capacity:
+            self.popitem(last=False)
+
+# Your LRUCache object will be instantiated and called as such:
+# obj = LRUCache(capacity)
+# param_1 = obj.get(key)
+# obj.put(key,value)
diff --git a/0191-number-of-1-bits.cpp b/0191-number-of-1-bits.cpp
@@ -1,21 +1,15 @@
 /*
 191. Number of 1 Bits
 
-First submitted: October 13, 2024
-This solution: October 14, 2024
+Submitted: January 25, 2025
 
 Runtime: 0 ms (beats 100.00%)
-Memory: 7.90 MB (beats 76.22%)
+Memory: 8.26 MB (beats 47.54%)
 */
 
 class Solution {
 public:
-    int hammingWeight(int n) {
-        int res = 0;
-        while (n != 0) {
-            res += n & 1;
-            n >>= 1;
-        }
-        return res;
+    inline int hammingWeight(int n) {
+        return __builtin_popcount(n);
     }
 };
diff --git a/0704-binary-search.c b/0704-binary-search.c
@@ -0,0 +1,20 @@
+/*
+704. Binary Search
+
+Submitted: January 31, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 9.40 MB (beats 30.03%)
+*/
+
+int search(int* nums, int numsSize, int target) {
+    int min = 0, max = numsSize - 1;
+    int mid;
+    while (min <= max) {
+        mid = (max + min) / 2;
+        if (nums[mid] == target) return mid;
+        else if (nums[mid] < target) min = mid + 1;
+        else if (nums[mid] > target) max = mid - 1;
+    }
+    return -1;
+}
diff --git a/0704-binary-search.cpp b/0704-binary-search.cpp
@@ -0,0 +1,24 @@
+/*
+704. Binary Search
+
+Submitted: January 31, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 31.24 MB (beats 79.81%)
+*/
+
+class Solution {
+public:
+    int search(vector<int>& nums, int target) {
+        int min = 0, max = nums.size() - 1;
+        int mid;
+        auto arr = nums.data();
+        while (min <= max) {
+            mid = (max + min) / 2;
+            if (arr[mid] == target) return mid;
+            else if (arr[mid] < target) min = mid + 1;
+            else if (arr[mid] > target) max = mid - 1;
+        }
+        return -1;
+    }
+};
diff --git a/0704-binary-search.py b/0704-binary-search.py
@@ -0,0 +1,19 @@
+"""
+704. Binary Search
+
+Submitted: January 31, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 18.59 MB (beats 82.38%)
+"""
+
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        min = 0
+        max = len(nums) - 1
+        while min <= max:
+            mid = (max + min) // 2
+            if nums[mid] == target: return mid
+            elif nums[mid] < target: min = mid + 1
+            elif nums[mid] > target: max = mid - 1
+        return -1
diff --git a/1351-count-negative-numbers-in-a-sorted-matrix.py b/1351-count-negative-numbers-in-a-sorted-matrix.py
@@ -0,0 +1,12 @@
+"""
+1351. Count Negative Numbers in a Sorted Matrix
+
+Submitted: February 6, 2025
+
+Runtime: 4 ms (beats 12.26%)
+Memory: 19.05 MB (beats 13.05%)
+"""
+
+class Solution:
+    def countNegatives(self, grid: List[List[int]]) -> int:
+        return sum(sum(cell < 0 for cell in row) for row in grid)
diff --git a/2469-convert-the-temperature.py b/2469-convert-the-temperature.py
@@ -3,10 +3,10 @@
 
 Submitted: October 3, 2024
 
-Runtime: 38 ms (beats 100.00%)
-Memory: 16.68 MB (beats 37.35%)
+Runtime: 0 ms (beats 100.00%)
+Memory: 17.94 MB (beats 16.66%)
 """
 
 class Solution:
     def convertTemperature(self, celsius: float) -> List[float]:
-        return [celsius + 273.15, celsius * 1.80 + 32.00]
+        return celsius + 273.15, celsius * 1.80 + 32.00
diff --git a/2724-sort-by.js b/2724-sort-by.js
@@ -0,0 +1,36 @@
+/*
+2724. Sort By
+
+Submitted: February 6, 2025
+
+Runtime: 506 MB (beats 5.62%)
+Memory: 70.77 MB (beats 5.12%)
+*/
+
+/**
+ * @param {Array} arr
+ * @param {Function} fn
+ * @return {Array}
+ */
+function sortBy(arr, fn) {
+    if (arr.length <= 1) return arr;
+    var left = arr.slice(0, arr.length / 2);
+    var right = arr.slice(arr.length / 2);
+    return merge(sortBy(left, fn), sortBy(right, fn), fn);
+};
+
+function merge(left, right, fn) {
+    let res = [];
+    while (left.length && right.length) {
+        if (fn(left[0]) > fn(right[0])) {
+            res.push(right[0]);
+            right = right.slice(1);
+        } else {
+            res.push(left[0]);
+            left = left.slice(1);
+        }
+    }
+    if (left.length) res = res.concat(left);
+    else res = res.concat(right);
+    return res;
+}
