add 8, 148, 290, 374, 3714; update 217

Author: rustykitty

0008-string-to-integer-atoi.cpp

@@ -0,0 +1,35 @@
+/*
+8. String to Integer (atoi)
+
+Submitted: February 10, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 9.09 MB (beats 82.35%)
+*/
+
+class Solution {
+public:
+    int myAtoi(string s) {
+        if (s.size() == 0) return 0;
+        long long res = 0;
+        auto it = s.cbegin();
+        while (*it == ' ') ++it;
+        bool negative = false;
+        if (*it == '-') {
+            negative = true;
+            ++it;
+        } else if (*it == '+') {
+            ++it;
+        }
+        while (it != s.cend() && 48 <= (int) *it && (int) *it <= 57) {
+            res *= 10;
+            if (res > 2147483648 && negative) return -2147483648;
+            if (res > 2147483647 && !negative) return 2147483647;
+            res += ((int) *it) - 48;
+            ++it;
+        }
+        if (res > 2147483647) return negative ? -2147483648 : 2147483647;
+        if (negative) return -res;
+        return res;
+    }
+};

0148-sort-list.cpp

@@ -0,0 +1,30 @@
+/*
+148. Sort List
+
+Submitted: February 10, 2025
+
+Runtime: 7 ms (beats 96.37%)
+Memory: 58.09 MB (beats 75.27%)
+*/
+
+/**
+ * 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:
+    ListNode* sortList(ListNode* head) {
+        vector<int> v;
+        for (ListNode* p = head; p != nullptr; p = p->next) v.push_back(p->val); 
+        sort(v.begin(), v.end());
+        auto it = v.cbegin();
+        for (ListNode* p = head; p != nullptr && it != v.cend(); p = p->next, ++it) p->val = *it;
+        return head;
+    }
+};

0217-contains-duplicate.py

@@ -1,16 +1,11 @@
 """
 217. Contains Duplicate
 
-Submitted: October 4, 2024
-Runtime: 414 ms (beats 5.53%)
-Memory: 35.63 MB (beats 8.45)
+Submitted: February 7, 2025
+Runtime: 18 ms (beats 20.84%)
+Memory: 31.66 MB (beats 30.18%)
 """
 
 class Solution:
     def containsDuplicate(self, nums: List[int]) -> bool:
-        map = {}
-        for i in range(len(nums)):
-            if nums[i] in map:
-                return True
-            map[nums[i]] = i
-        return False
+        return len(set(nums)) != len(nums)

0290-word-pattern.py

@@ -0,0 +1,24 @@
+"""
+290. Word Pattern
+
+Submitted: February 7, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 17.72 MB (beats 54.52%)
+"""
+
+class Solution:
+    def wordPattern(self, pattern: str, s: str) -> bool:
+        words: list[str] = s.split(' ')
+        if len(pattern) != len(words): return False
+        # bidirectional hash map
+        d1 = {}
+        d2 = {}
+        for (letter, word) in zip(pattern, words):
+            if letter in d1:
+                if d1[letter] != word: return False
+            elif word in d2:
+                if d2[word] != letter: return False
+            d1[letter] = word
+            d2[word] = letter
+        return True

0374-guess-number-higher-or-lower.cpp

@@ -0,0 +1,31 @@
+/*
+374. Guess Number Higher or Lower
+
+Submitted: February 7, 2025
+*/
+
+/** 
+ * Forward declaration of guess API.
+ * @param  num   your guess
+ * @return 	     -1 if num is higher than the picked number
+ *			      1 if num is lower than the picked number
+ *               otherwise return 0
+ * int guess(int num);
+ */
+
+class Solution {
+public:
+    int guessNumber(int n) {
+        unsigned min = 1, max = n;
+        unsigned mid;
+        unsigned char guess_res;
+        while (min <= max) {
+            mid = (max + min) / 2;
+            guess_res = guess(mid);
+            if (guess_res == 0) return mid;
+            else if (guess_res == 1) min = mid + 1;
+            else max = mid - 1;
+        }
+        return -1;
+    }
+};

3174-clear-digits.py

@@ -0,0 +1,14 @@
+"""
+3174. Clear Digits
+
+Submitted: February 10, 2025
+
+Runtime: 3 ms (beats 29.98%)
+Memory: 17.56 MB (beats 88.57%)
+"""
+
+class Solution:
+    def clearDigits(self, s: str) -> str:
+        while (pos := next((i for i in range(len(s)) if s[i].isdigit()), None)) is not None:
+            s = s[:pos-1] + s[pos+1:]
+        return s