add 5, 47, 187; update 46, 65, 67, 289

Author: rustykitty

0005-longest-palindromic-substring.py

@@ -0,0 +1,13 @@
+"""
+5. Longest Palindromic Substring
+
+Submitted: March 29, 2025
+
+Runtime: 9869 ms (beats 5.01%)
+17.43 MB (beats 99.57%)
+"""
+
+class Solution:
+    def longestPalindrome(self, s: str) -> str: 
+        # https://stackoverflow.com/a/53798151
+        return max((s[i:j+1] for i in range (len(s)) for j in range(i,len(s)) if s[i:j+1] == s[i:j+1][::-1]), key=str.__len__)

0046-permutations.py

@@ -1,12 +1,21 @@
 """
 46. Permutations
 
-Submitted: January 23, 2025
+Submitted: March 28, 2025
 
 Runtime: 0 ms (beats 100.00%)
-Memory: 17.71 MB (beats 60.66%)
+Memory: 18.02 MB (beats 32.93%)
 """
 
 class Solution:
     def permute(self, nums: List[int]) -> List[List[int]]:
-        return list(permutations(nums))
+        if len(nums) < 2: 
+            return [nums]
+        elif len(nums) == 2:
+            return [nums, list(reversed(nums))]
+        return list(
+            itertools.chain.from_iterable(
+                [[nums[i]] + v for v in self.permute(nums[:i] + nums[i+1:])] 
+                for i in range(len(nums))
+            )
+        )

0047-permutations-ii.py

@@ -0,0 +1,23 @@
+"""
+47. Permutations II
+
+Submitted: March 28, 2025
+
+Runtime: 239 ms (beats 12.60%)
+Memory: 23.88 MB (beats 5.08%)
+"""
+
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        if len(nums) < 2: 
+            return [nums]
+        elif len(nums) == 2:
+            return [nums, list(reversed(nums))]
+        return list(
+            itertools.chain.from_iterable(
+                [[nums[i]] + v for v in self.permute(nums[:i] + nums[i+1:])] 
+                for i in range(len(nums))
+            )
+        )
+    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
+        return list(set(tuple(x) for x in self.permute(nums)))

0065-valid-number.md

@@ -5,25 +5,17 @@
 I used the regular expression shown below:
 
 ```regex
-(\+|-)?(\d+\.?|(\d+)?\.\d+)((e|E)(\+|-)?\d+)?
+[\+-]?(?:\d+\.?|(\d+)?\.\d+)(?:[Ee][\+-]?\d+)?
 ```
 
 ### Breakdown of Regex
 
-`(\+|-)?` - an optional plus (`+`) or minus (`-`) sign
-`(\d+\.?|(\d+)?\.\d+)` - the digits, matches one of either:
+`[\+-]?` - an optional plus (`+`) or minus (`-`) sign
+`(?:\d+\.?|(\d+)?\.\d+)` - the digits, matches one of either:
 - `\d+\.?` - at least one numeric digit and optionally a following decimal dot (e.g. `123`, `123.`)
 - `(\d+)?\.\d+` - a decimal dot and at least one numeric digit, optionally preceded by digits (e.g. `0.33`, `.33`)
-`((e|E)(\+|-)?\d+)?` - the exponent:
-- `(e|E)` matches either uppercase or lowercase `e`
-- `(\+|-)` - see above
+`(?:[eE][\+-]?\d+)?` - the exponent:
+- `[eE]` matches either uppercase or lowercase `e`
+- `[\+-]?` - see above
 - `\d+` - at least one numeric digit
 - the `?` at the end makes it optional
-
-## Code
-
-```python3
-class Solution:
-    def isNumber(self, s: str) -> bool:
-        return bool(re.fullmatch(r'(\+|-)?(\d+\.?|(\d+)?\.\d+)((e|E)(\+|-)?\d+)?', s))
-```

0065-valid-number.py

@@ -1,12 +1,12 @@
 """
 65. Valid Number
 
-Submitted: January 23, 2025
+Submitted: April 15, 2025
 
 Runtime: 0 ms (beats 100.00%)
-Memory: 17.60 MB (beats 49.99%)
+Memory: 17.66 MB (beats 88.76%)
 """
 
 class Solution:
     def isNumber(self, s: str) -> bool:
-        return bool(re.fullmatch(r'(\+|-)?(\d+\.?|(\d+)?\.\d+)((e|E)(\+|-)?\d+)?', s))
+        return bool(re.fullmatch(r'[\+-]?(?:\d+\.?|(\d+)?\.\d+)(?:[Ee][\+-]?\d+)?', s))

0067-add-binary.py

@@ -0,0 +1,10 @@
+"""
+67. Add Binary
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 17.76 MB (beats 73.35%)
+"""
+
+class Solution:
+    def addBinary(self, a: str, b: str) -> str:
+        return bin(int(a, 2) + int(b, 2))[2:]

0187-repeated-dna-sequences.py

@@ -0,0 +1,24 @@
+"""
+187. Repeated DNA Sequences
+
+Submitted: April 16, 2025
+
+Runtime: 39 ms (beats 15.79%)
+Memory: 29.16 MB (beats 48.93%)
+"""
+
+class Solution:
+    def findRepeatedDnaSequences(self, s: str) -> List[str]:
+        if len(s) <= 10:
+            return []
+        def _():
+            dq = deque(s[:10])
+            for i in s[10:]:
+                yield ''.join(dq)
+                dq.popleft()
+                dq.append(i)
+            yield ''.join(dq)
+        return [
+            k for k,v in Counter(_()).items()
+            if v >= 2
+        ]

0289-game-of-life.c

@@ -0,0 +1,74 @@
+/*
+289. Game of Life
+
+Submitted: April 3, 2025
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 9.25 MB (beats 6.02%)
+*/
+
+typedef struct pair {
+    int x;
+    int y;
+} pair;
+
+inline unsigned char** init2D(pair size) {
+    int n = size.x, m = size.y;
+    unsigned char** mat = malloc((sizeof(unsigned char*) * n) + (sizeof(unsigned char) * n * m));
+    unsigned char* data = (unsigned char*)(mat + n);
+    for (size_t i = 0; i < n; ++i) {
+        mat[i] = data + (m * i);
+    }
+    return mat;
+}
+
+inline unsigned char** copy2D(int** matrix, pair size) {
+    unsigned char** copy = init2D(size);
+    int n = size.x, m = size.y;
+    for (size_t i = 0; i < n; ++i) {
+        for (size_t j = 0; j < m; ++j) {
+            copy[i][j] = matrix[i][j];
+        }
+    }
+    return copy;
+}
+
+#define isValidIndex(n, m, i, j) ((0 <= i && i < n) && (0 <= j && j < m))
+#define validOrZero(a, n, m, i, j) (isValidIndex(n, m, i, j) ? a[i][j] : 0)
+unsigned char sumOfNeighbors(unsigned char** matrix, pair size, pair index) {
+    const int n = size.x, m = size.y;
+    const int i = index.x, j = index.y;
+    return validOrZero(matrix, n, m, i - 1, j - 1) + 
+           validOrZero(matrix, n, m, i - 1, j) +
+           validOrZero(matrix, n, m, i - 1, j + 1) +
+           validOrZero(matrix, n, m, i, j - 1) +
+           validOrZero(matrix, n, m, i, j + 1) +
+           validOrZero(matrix, n, m, i + 1, j - 1) +
+           validOrZero(matrix, n, m, i + 1, j) +
+           validOrZero(matrix, n, m, i + 1, j + 1);
+}
+
+void gameOfLife(int** board, int boardSize, int* boardColSize) {
+    pair size = { boardSize, boardColSize[0] };
+    int n = size.x, m = size.y;
+    unsigned char** copy = copy2D(board, size);
+    for (size_t i = 0; i < n; ++i) {
+        for (size_t j = 0; j < m; ++j) {
+            int cell = board[i][j];
+            pair index = { i, j };
+            unsigned char neighbors = sumOfNeighbors(copy, size, index);
+            if (cell) {
+                if (neighbors < 2) {
+                    board[i][j] = 0;
+                } else if (neighbors > 3) {
+                    board[i][j] = 0;
+                }
+            } else {
+                if (neighbors == 3) {
+                    board[i][j] = 1;
+                }
+            }
+        }
+    }
+    free(copy);
+}