add 234, 500, 832, 1323, 1678, 1684, 2315, 2725, 3248; update 1, 231, 709, 2011

rustykitty · rustykitty · commit 8b4d77630984 · 2025-01-17T21:14:29.000-08:00
diff --git a/0001-two-sum.py b/0001-two-sum.py
@@ -1,18 +1,17 @@
 """
 1. Two Sum
-First solved: February 27, 2024
-Last solved: November 22, 2024
+
+Submitted: January 16, 2025
 
 Runtime: 0 ms (beats 100.00%)
-Memory: 17.98 MB (beats 14.36%)
+Memory: 19.00 MB (beats 19.63%)
 """
 
 class Solution:
     def twoSum(self, nums: List[int], target: int) -> List[int]:
         d = {}
-        for i in range(len(nums)):
-            want = target - nums[i]
-            if want in d:
-                return [i, d[want]]
-            else:
-                d[nums[i]] = i
+        return next(x for x in (
+            (i, d[target - nums[i]]) if ((target - nums[i]) in d) else d.update({ nums[i]: i })
+            for i in range(len(nums))
+            ) if x is not None
+        )
diff --git a/0231-power-of-two.cpp b/0231-power-of-two.cpp
@@ -1,16 +1,15 @@
 /*
 231. Power of Two
 
-Solved: December 9, 2024
+Submitted: January 17, 2025
 
 Runtime: 0 ms (beats 100.00%)
-Memory: 7.84 MB (beats 10.33%)
+Memory: 7.83 MB (beats 49.22%)
 */
 
 class Solution {
 public:
     bool isPowerOfTwo(int n) {
-        if (n <= 0) return false;
-        return !(n & (n - 1));
+        return (n > 0) && !(n & (n - 1));
     }
 };
diff --git a/0234-palindrome-linked-list.cpp b/0234-palindrome-linked-list.cpp
@@ -0,0 +1,34 @@
+/*
+234. Palindrome Linked List
+
+Submitted: January 17, 2025
+
+Runtime: 6 ms (beats 35.32%)
+Memory: 132.08 MB (beats 14.40%)
+*/
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    bool isPalindrome(ListNode* head) {
+        vector<int> v;
+        for (; head != nullptr; head = head->next) {
+            v.push_back(head->val);
+        }
+        auto forward = v.cbegin();
+        auto backward = v.crbegin();
+        while (forward != v.cend()) {
+            if (*forward++ != *backward++) return false;
+        }
+        return true;
+    }
+};
diff --git a/0500-keyboard-row.py b/0500-keyboard-row.py
@@ -0,0 +1,18 @@
+"""
+500. Keyboard Row
+
+Submitted: January 16, 2025
+"""
+
+class Solution:
+    def findWords(self, words: List[str]) -> List[str]:
+        return [
+            word for word in words if any(
+                all(char in row for char in word.lower())
+                for row in (
+                    'qwertyuiop',
+                    'asdfghjkl',
+                    'zxcvbnm'
+                )
+            )
+        ]
diff --git a/0709-to-lower-case.py b/0709-to-lower-case.py
@@ -1,13 +1,12 @@
 """
 709. To Lower Case
 
-Submitted: November 22, 2024
+Submitted: January 17, 2025
 
 Runtime: 0 ms (100.00%)
-Memory: 16.40 MB (beats 80.46%)
+Memory: 17.36 MB (beats 33.60%)
 """
 
 class Solution:
-    def __init__(self):
-        # this is a literal joke
-        self.toLowerCase = str.lower
+    def toLowerCase(self, s: str) -> str:
+        return s.lower()
diff --git a/0832-flipping-an-image.py b/0832-flipping-an-image.py
@@ -0,0 +1,12 @@
+"""
+832. Flipping an Image
+
+Submitted: January 17, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 17.73 MB (beats 32.61%)
+"""
+
+class Solution:
+    def flipAndInvertImage(self, image: List[List[int]]) -> List[List[int]]:
+        return [[int(not k) for k in i] for i in (j[::-1] for j in image)]
diff --git a/1323-maximum-69-number.py b/1323-maximum-69-number.py
@@ -0,0 +1,19 @@
+"""
+1323. Maximum 69 Number
+
+Submitted: January 17, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 17.97 MB (beats 15.18%)
+"""
+
+class Solution:
+    def maximum69Number(self, num: int) -> int:
+        return max(
+            max(
+                int(''.join(
+                    ('6' if str(num)[i] == '9' else '9') if i == j else str(num)[j] for j in range(len(str(num)))
+                )) for i in range(len(str(num)))
+            ),
+            num
+        )
diff --git a/1678-goal-parser-interpretation.py b/1678-goal-parser-interpretation.py
@@ -0,0 +1,12 @@
+"""
+1678. Goal Parser Interpretation
+
+Submitted: January 17, 2025
+
+Runtime: 50 ms (beats 33.76%)
+Memory: 17.61 MB (beats 35.26%)
+"""
+
+class Solution:
+    def interpret(self, command: str) -> str:
+        return command.replace('()', 'o').replace('(al)', 'al')
diff --git a/1684-count-the-number-of-consistent-strings.py b/1684-count-the-number-of-consistent-strings.py
@@ -0,0 +1,12 @@
+"""
+1684. Count the Number of Consistent Strings
+
+Submitted: January 17, 2025
+
+Runtime: 258 ms (beats 7.24%)
+Memory: 19.71 MB (beats 10.46%)
+"""
+
+class Solution:
+    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
+        return sum(all(c in allowed for c in s) for s in words)
diff --git a/2011-final-value-of-variable-after-performing-operations.py b/2011-final-value-of-variable-after-performing-operations.py
@@ -0,0 +1,12 @@
+"""
+2011. Final Value of Variable After Performing Operations
+
+Submitted: January 17, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 17.88 MB (beats 21.09)
+"""
+
+class Solution:
+    def finalValueAfterOperations(self, operations: List[str]) -> int:
+        return sum((-1 if op[1] == '-' else 1) for op in operations)
diff --git a/2315-count-asterisks.cpp b/2315-count-asterisks.cpp
@@ -0,0 +1,21 @@
+/*
+2315. Count Asterisks
+
+Submitted: January 17, 2025
+
+RUntime: 0 ms (Beats 100.00%)
+Memory: 8.36 MB (beats 68.54%)
+*/
+
+class Solution {
+public:
+    int countAsterisks(string s) {
+        bool count = true;
+        int res = 0;
+        for (const char c : s) {
+            if (c == '|') count = !count;
+            if (count && c == '*') ++res;
+        }
+        return res;
+    }
+};
diff --git a/2725-interval-cancellation.js b/2725-interval-cancellation.js
@@ -0,0 +1,53 @@
+/*
+2725. Interval Cancellation
+
+Submitted: January 17, 2025
+
+Runtime: 43 ms (beats 99.89%)
+Memory: 49.62 MB (beats 51.41%)
+*/
+
+/**
+ * @param {Function} fn
+ * @param {Array} args
+ * @param {number} t
+ * @return {Function}
+ */
+var cancellable = function(fn, args, t) {
+    fn(...args);
+    let id = setInterval(function() {
+        fn(...args);
+    }, t);
+    return function() {
+        clearInterval(id);
+    }
+};
+
+/**
+ *  const result = [];
+ *
+ *  const fn = (x) => x * 2;
+ *  const args = [4], t = 35, cancelTimeMs = 190;
+ *
+ *  const start = performance.now();
+ *
+ *  const log = (...argsArr) => {
+ *      const diff = Math.floor(performance.now() - start);
+ *      result.push({"time": diff, "returned": fn(...argsArr)});
+ *  }
+ *       
+ *  const cancel = cancellable(log, args, t);
+ *
+ *  setTimeout(cancel, cancelTimeMs);
+ *   
+ *  setTimeout(() => {
+ *      console.log(result); // [
+ *                           //     {"time":0,"returned":8},
+ *                           //     {"time":35,"returned":8},
+ *                           //     {"time":70,"returned":8},
+ *                           //     {"time":105,"returned":8},
+ *                           //     {"time":140,"returned":8},
+ *                           //     {"time":175,"returned":8}
+ *                           // ]
+ *  }, cancelTimeMs + t + 15)    
+ */
diff --git a/3248-snake-in-matrix.cpp b/3248-snake-in-matrix.cpp
@@ -0,0 +1,22 @@
+/*
+3248. Snake in Matrix
+
+Submitted: January 17, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 34.90 MB (beats 43.05%)
+*/
+
+class Solution {
+public:
+    int finalPositionOfSnake(int n, vector<string>& commands) {
+        int pos = 0;
+        for (const string& cmd : commands) {
+            pos += cmd == "UP"    ? -n : 
+                   cmd == "RIGHT" ? 1 :
+                   cmd == "DOWN"  ? n :
+                   cmd == "LEFT"  ? -1 : 0;
+        }
+        return pos;
+    }
+};
diff --git a/3248-snake-in-matrix.py b/3248-snake-in-matrix.py
@@ -0,0 +1,17 @@
+"""
+Snake in Matrix
+
+Submitted: January 17, 2025
+
+Runtime: 3 ms (beats 48.96%)
+Memory: 18.03 MB (beats 14.17%)
+"""
+
+class Solution:
+    def finalPositionOfSnake(self, n: int, commands: List[str]) -> int:
+        return sum(
+            -n if cmd == "UP" else
+            1  if cmd == "RIGHT" else
+            n  if cmd == "DOWN" else -1
+            for cmd in commands
+        )
