formatted code: remove extra spaces/newlines

rustykitty · rustykitty · commit 64324e312439 · 2024-12-02T19:13:06.000-08:00
diff --git a/0001-two-sum.py b/0001-two-sum.py
@@ -16,4 +16,3 @@ def twoSum(self, nums: List[int], target: int) -> List[int]:
                 return [i, d[want]]
             else:
                 d[nums[i]] = i
-        
diff --git a/0009-palindrome-number.cpp b/0009-palindrome-number.cpp
@@ -13,7 +13,7 @@ class Solution {
         if (x < 0) return false;
         // Reverse digits
         long y = 0;
-        int x2 = x; 
+        int x2 = x;
         while (x2 != 0) {
             y *= 10;
             y += x2 % 10;
diff --git a/0014-longest-common-prefix.c b/0014-longest-common-prefix.c
@@ -21,7 +21,7 @@ char* longestCommonPrefix(char** strs, int strsSize) {
     char* prefix = calloc(len_shortest + 1, sizeof(char));
     for (unsigned char i = 0; i < len_shortest; i++) {
         for (char** p = strs; p != strsEnd; ++p ) {
-            char* str = *p; 
+            char* str = *p;
             // this means that the prefix ends here
             if (str[i] != strs[0][i]) return prefix;
         }
diff --git a/0020-valid-parentheses.cpp b/0020-valid-parentheses.cpp
@@ -15,7 +15,7 @@ class Solution {
         for (const char& c : s) {
             if (c == '(' || c == '[' || c == '{') { // opening parentheses
                 stack.push_back(c);
-            } else if (stack.empty() || 
+            } else if (stack.empty() ||
                        stack.back() != (c == ')' ? '(' : // matching closing
                                         c == ']' ? '[' : // parentheses with
                                         c == '}' ? '{' : // open parentheses
diff --git a/0035-search-insert-position.py b/0035-search-insert-position.py
@@ -21,7 +21,7 @@ def bs(a, h, l, x): # begin binary search function
             else:
                 return -1
         # end binary search function
-        if target in nums: 
+        if target in nums:
             r = bs(nums, len(nums), 0, target)
             if r >= 0:
                 return r
@@ -39,4 +39,4 @@ def bs(a, h, l, x): # begin binary search function
                 for i in range(len(nums)):
                     if nums[i] > target:
                         return i
-        return -1 # not found
+        return -1 # not found
diff --git a/0141-linked-list-cycle.py b/0141-linked-list-cycle.py
@@ -5,11 +5,10 @@
 Last submitted: September 30, 2024
 Submitted: September 26, 2024
 
-Runtime: 40 ms (beats 83.76%) 
+Runtime: 40 ms (beats 83.76%)
 Memory: 19.15 MB (beats 33.41%)
 """
 
-
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, x):
@@ -25,4 +24,4 @@ def hasCycle(self, head: Optional[ListNode]) -> bool:
             fast = fast.next.next
             if slow is fast:
                 return True
-        return False
+        return False
diff --git a/0146-lru-cache.cpp b/0146-lru-cache.cpp
@@ -21,7 +21,7 @@ class LinkedList {
 private:
     Node* const head = new Node(-1, -1);
     Node* const tail = new Node(-2, -2);
-    size_type currentSize = 0; 
+    size_type currentSize = 0;
 
     inline void validateNode(Node* node) const {
         if (node == nullptr) throw invalid_argument("Node cannot be null");
@@ -93,15 +93,15 @@ class LRUCache {
     LinkedList list;
 public:
     LRUCache(int capacity) : capacity((LinkedList::size_type) capacity) {}
-    
+
     int get(int key) {
         if (map.count(key)) {
             list.moveToHead(map[key]);
             return map[key]->val;
         }
         return -1;
     }
-    
+
     void put(int key, int value) {
         if (map.count(key)) {
             list.moveToHead(map[key]);
diff --git a/0150-evaluate-reverse-polish-notation.cpp b/0150-evaluate-reverse-polish-notation.cpp
@@ -3,7 +3,7 @@
 
 Submitted: November 16, 2024
 
-Runtime: 0 ms (beats 100.00%) 
+Runtime: 0 ms (beats 100.00%)
 Memory: 15.74 MB (beats 61.18%)
 */
 
@@ -42,4 +42,4 @@ class Solution {
         }
         return stack.top();
     }
-};
+};
diff --git a/0150-evaluate-reverse-polish-notation.py b/0150-evaluate-reverse-polish-notation.py
@@ -15,18 +15,18 @@ def evalRPN(self, tokens: List[str]) -> int:
                 x = stack.pop()
                 y = stack.pop()
                 stack.append(x + y)
-            elif token == "-": 
+            elif token == "-":
                 y = stack.pop()
                 x = stack.pop()
                 stack.append(x - y)
-            elif token == "*": 
+            elif token == "*":
                 x = stack.pop()
                 y = stack.pop()
                 stack.append(x * y)
-            elif token == "/": 
+            elif token == "/":
                 y = stack.pop()
                 x = stack.pop()
                 stack.append(int(x / y))
             else:
                 stack.append(int(token))
-        return stack[-1]
+        return stack[-1]
diff --git a/0175-combine-two-tables.sql b/0175-combine-two-tables.sql
@@ -7,7 +7,7 @@ Runtime: 399 ms (beats 83.54%)
 */
 
 # Write your MySQL query statement below
-SELECT firstName, lastName, city, state 
-FROM Person 
+SELECT firstName, lastName, city, state
+FROM Person
 LEFT JOIN Address -- we need to use LEFT JOIN so that `null` is produced if the
-USING (personId); -- address of a Person is not found in Address
+USING (personId); -- address of a Person is not found in Address
diff --git a/0193-valid-phone-numbers.sh b/0193-valid-phone-numbers.sh
@@ -9,7 +9,7 @@
 while read REPLY; do # read line into $REPLY until EOF
     [[ $REPLY =~ ^[0-9]{3}-[0-9]{3}-[0-9]{4}$ ]] || # if $REPLY matches regex for nnn-nnn-nnnn
     [[ $REPLY =~ ^\([0-9]{3}\)\ [0-9]{3}\-[0-9]{4}$ ]] && # if $REPLY matches regex for (nnn) nnn-nnnn
-    echo $REPLY 
+    echo $REPLY
 done < file.txt # redirect stdin to read from file.txt
 # all in one line:
 # while read REPLY; do [[ $REPLY =~ ^[0-9]{3}-[0-9]{3}-[0-9]{4}$ ]] || [[ $REPLY =~ ^\([0-9]{3}\)\ [0-9]{3}\-[0-9]{4}$ ]] && echo $REPLY; done < file.txt
diff --git a/0202-happy-number.cpp b/0202-happy-number.cpp
@@ -16,7 +16,7 @@ class Solution {
             fast = sumDigits(sumDigits(fast));
             slow = sumDigits(slow);
         }
-        if (fast == 1) return true; 
+        if (fast == 1) return true;
         return false;
     }
     int sumDigits(int n) { // sum squares of digits
@@ -28,4 +28,4 @@ class Solution {
         }
         return res;
     }
-};
+};
diff --git a/0203-remove-linked-list-elements.py b/0203-remove-linked-list-elements.py
@@ -20,5 +20,5 @@ def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNod
         while p:
             while p.next and p.next.val == val:
                 p.next = p.next.next
-            p = p.next 
+            p = p.next
         return dummy.next
diff --git a/0217-contains-duplicate.py b/0217-contains-duplicate.py
@@ -3,7 +3,7 @@
 
 Submitted: October 4, 2024
 Runtime: 414 ms (beats 5.53%)
-Memory: 35.63 MB (beats 8.45) 
+Memory: 35.63 MB (beats 8.45)
 """
 
 class Solution:
@@ -13,4 +13,4 @@ def containsDuplicate(self, nums: List[int]) -> bool:
             if nums[i] in map:
                 return True
             map[nums[i]] = i
-        return False
+        return False
diff --git a/0242-valid-anagram.cpp b/0242-valid-anagram.cpp
@@ -9,8 +9,8 @@ Memory: 10.10 MB (beats 17.76%)
 */
 
 /*
-Approach: 
-We count the number of times each character appears in the two strings. If they 
+Approach:
+We count the number of times each character appears in the two strings. If they
 are equal, they must be anagrams.
 */
 
@@ -27,4 +27,4 @@ class Solution {
         }
         return s_count == t_count;
     }
-};
+};
diff --git a/0387-first-unique-character-in-a-string.cpp b/0387-first-unique-character-in-a-string.cpp
@@ -10,7 +10,7 @@ Memory: 12.95 MB (beats 94.71%)
 class Solution {
 public:
     int firstUniqChar(string s) {
-        int occurrences[26] = { 0 }; // using an array as a map w/ fixed values 
+        int occurrences[26] = { 0 }; // using an array as a map w/ fixed values
         for (const char& c : s) {
             occurrences[c - 'a']++;
         }
@@ -19,4 +19,4 @@ class Solution {
         }
         return -1;
     }
-};
+};
diff --git a/0476-number-compliment.cpp b/0476-number-compliment.cpp
@@ -18,7 +18,7 @@ class Solution {
             n >>= 1;       // digits has the same number of `1` bits as
             digits <<= 1;  // the number of digits total in `n` when you
             digits++;      // remove leading zeroes
-        } 
+        }
         return d ^ digits; // 1 ^ 1 = 0, 0 ^ 1 = 1
     }
-};
+};
diff --git a/0482-license-key-formatting.cpp b/0482-license-key-formatting.cpp
@@ -12,21 +12,21 @@ class Solution {
     string licenseKeyFormatting(string s, int k) {
         unsigned short i = 0;
         string result;
-        // we go through the string backwards so that the first group can 
+        // we go through the string backwards so that the first group can
         // contain less than `k` digits. it's easier to make the last group
         // different than the first group different.
-        for (auto it = s.crbegin(); it != s.crend(); ++it) { 
+        for (auto it = s.crbegin(); it != s.crend(); ++it) {
             const char& c = *it;
             if (c == '-') { // ignore hyphens
                 continue;
             } else if (i == k) { // after k non-hyphen characters, append a hyphen
                 result.push_back('-');
                 i = 0;
-            } 
+            }
             result.push_back(c >= 'a' ? c - 32 : c); // convert to uppercase
             ++i;
         }
         reverse(result.begin(), result.end());
         return result;
     }
-};
+};
diff --git a/0504-base-7.cpp b/0504-base-7.cpp
@@ -13,7 +13,7 @@ class Solution {
         if (num == 0) return "0";
         string res = "";
         bool negative = false;
-        if (num < 0) { 
+        if (num < 0) {
             negative = true;
             num = -num;
         }
@@ -24,4 +24,4 @@ class Solution {
         if (negative) res.insert(0, 1, '-');
         return res;
     }
-};
+};
diff --git a/0804-unique-morse-code-words.cpp b/0804-unique-morse-code-words.cpp
@@ -16,34 +16,34 @@ class Solution {
             for (const char& c : word) {
                 s.append(c == 'a' ? ".-" :   // nested ternary operators
                          c == 'b' ? "-..." : // in place of map
-                         c == 'c' ? "-.-." : 
-                         c == 'd' ? "-.." : 
-                         c == 'e' ? "." : 
-                         c == 'f' ? "..-." : 
-                         c == 'g' ? "--." : 
-                         c == 'h' ? "...." : 
-                         c == 'i' ? ".." : 
-                         c == 'j' ? ".---" : 
-                         c == 'k' ? "-.-" : 
-                         c == 'l' ? ".-.." : 
-                         c == 'm' ? "--" : 
-                         c == 'n' ? "-." : 
-                         c == 'o' ? "---" : 
-                         c == 'p' ? ".--." : 
-                         c == 'q' ? "--.-" : 
-                         c == 'r' ? ".-." : 
-                         c == 's' ? "..." : 
-                         c == 't' ? "-" : 
-                         c == 'u' ? "..-" : 
-                         c == 'v' ? "...-" : 
-                         c == 'w' ? ".--" : 
-                         c == 'x' ? "-..-" : 
-                         c == 'y' ? "-.--" : 
-                         c == 'z' ? "--.." : 
+                         c == 'c' ? "-.-." :
+                         c == 'd' ? "-.." :
+                         c == 'e' ? "." :
+                         c == 'f' ? "..-." :
+                         c == 'g' ? "--." :
+                         c == 'h' ? "...." :
+                         c == 'i' ? ".." :
+                         c == 'j' ? ".---" :
+                         c == 'k' ? "-.-" :
+                         c == 'l' ? ".-.." :
+                         c == 'm' ? "--" :
+                         c == 'n' ? "-." :
+                         c == 'o' ? "---" :
+                         c == 'p' ? ".--." :
+                         c == 'q' ? "--.-" :
+                         c == 'r' ? ".-." :
+                         c == 's' ? "..." :
+                         c == 't' ? "-" :
+                         c == 'u' ? "..-" :
+                         c == 'v' ? "...-" :
+                         c == 'w' ? ".--" :
+                         c == 'x' ? "-..-" :
+                         c == 'y' ? "-.--" :
+                         c == 'z' ? "--.." :
                                     ""); // fail condition
             }
             set.emplace(s);
         }
         return set.size();
     }
-};
+};
diff --git a/1281-subtract-the-product-and-sum-of-digits-of-an-integer.cpp b/1281-subtract-the-product-and-sum-of-digits-of-an-integer.cpp
@@ -10,7 +10,7 @@ Memory: 7.55 MB (beats 13.43%)
 class Solution {
 public:
     int subtractProductAndSum(int n) {
-        int digitProduct = 1; 
+        int digitProduct = 1;
         int p = n;
         while (p != 0) {
             digitProduct *= p % 10;
@@ -25,4 +25,4 @@ class Solution {
         cout << digitProduct << " " << digitSum;
         return digitProduct - digitSum;
     }
-};
+};
diff --git a/1313-decompress-run-length-encoded-list.c b/1313-decompress-run-length-encoded-list.c
@@ -25,10 +25,10 @@ int* decompressRLElist(int* nums, int numsSize, int* returnSize) {
         int freq = *p;
         int val = *(++p);
         for (unsigned char i = 0; i < freq; ++i) {
-            *r = val; 
+            *r = val;
             ++r;
         }
         p++;
     }
     return returnArray;
-}
+}
diff --git a/1455-check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.cpp b/1455-check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.cpp
@@ -17,7 +17,7 @@ class Solution {
         words.push_back(sentence.substr(0, sentence.find(' '))); // first split
         while ((pos = sentence.find(' ', pos)) != string::npos) { // other splits
             // pos + 1 since sentence[pos] == ' '
-            words.push_back(sentence.substr(pos + 1, pos + sws + 1)); 
+            words.push_back(sentence.substr(pos + 1, pos + sws + 1));
             pos++;
         }
         for (unsigned char i = 0, n = words.size(); i < n; ++i) {
diff --git a/1486-xor-operation-in-an-array.cpp b/1486-xor-operation-in-an-array.cpp
@@ -4,7 +4,7 @@
 Submitted: October 28, 2024
 
 Runtime: 0 ms (beats 100.00%)
-Memory: 7.31 MB (beats 84.96%) 
+Memory: 7.31 MB (beats 84.96%)
 */
 
 class Solution {
@@ -16,4 +16,4 @@ class Solution {
         }
         return res;
     }
-};
+};
diff --git a/1603-design-parking-system.cpp b/1603-design-parking-system.cpp
diff --git a/2114-maximum-number-of-words-found-in-sentences.py b/2114-maximum-number-of-words-found-in-sentences.py
diff --git a/2194-cells-in-a-range-on-an-excel-sheet.cpp b/2194-cells-in-a-range-on-an-excel-sheet.cpp
diff --git a/2331-evaluate-boolean-binary-tree.cpp b/2331-evaluate-boolean-binary-tree.cpp
diff --git a/2535-difference-between-element-sum-and-digit-sum-of-an-array.cpp b/2535-difference-between-element-sum-and-digit-sum-of-an-array.cpp
diff --git a/2648-generate-fibonacci-sequence.js b/2648-generate-fibonacci-sequence.js
diff --git a/2942-find-words-containing-character.py b/2942-find-words-containing-character.py
diff --git a/3019-number-of-changing-keys.cpp b/3019-number-of-changing-keys.cpp
diff --git a/3024-type-of-triangle.cpp b/3024-type-of-triangle.cpp

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ char* longestCommonPrefix(char** strs, int strsSize) {`
`21`	`21`	`char* prefix = calloc(len_shortest + 1, sizeof(char));`
`22`	`22`	`for (unsigned char i = 0; i < len_shortest; i++) {`
`23`	`23`	`for (char** p = strs; p != strsEnd; ++p ) {`
`24`		`- char* str = *p;`
	`24`	`+ char* str = *p;`
`25`	`25`	`// this means that the prefix ends here`
`26`	`26`	`if (str[i] != strs[0][i]) return prefix;`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`Submitted: November 16, 2024`
`5`	`5`
`6`		`-Runtime: 0 ms (beats 100.00%)`
	`6`	`+Runtime: 0 ms (beats 100.00%)`
`7`	`7`	`Memory: 15.74 MB (beats 61.18%)`
`8`	`8`	`*/`
`9`	`9`
`@@ -42,4 +42,4 @@ class Solution {`
`42`	`42`	`}`
`43`	`43`	`return stack.top();`
`44`	`44`	`}`
`45`		`-};`
	`45`	`+};`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ class Solution {`
`16`	`16`	`fast = sumDigits(sumDigits(fast));`
`17`	`17`	`slow = sumDigits(slow);`
`18`	`18`	`}`
`19`		`- if (fast == 1) return true;`
	`19`	`+ if (fast == 1) return true;`
`20`	`20`	`return false;`
`21`	`21`	`}`
`22`	`22`	`int sumDigits(int n) { // sum squares of digits`
`@@ -28,4 +28,4 @@ class Solution {`
`28`	`28`	`}`
`29`	`29`	`return res;`
`30`	`30`	`}`
`31`		`-};`
	`31`	`+};`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@ Memory: 10.10 MB (beats 17.76%)`
`9`	`9`	`*/`
`10`	`10`
`11`	`11`	`/*`
`12`		`-Approach:`
`13`		`-We count the number of times each character appears in the two strings. If they`
	`12`	`+Approach:`
	`13`	`+We count the number of times each character appears in the two strings. If they`
`14`	`14`	`are equal, they must be anagrams.`
`15`	`15`	`*/`
`16`	`16`
`@@ -27,4 +27,4 @@ class Solution {`
`27`	`27`	`}`
`28`	`28`	`return s_count == t_count;`
`29`	`29`	`}`
`30`		`-};`
	`30`	`+};`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ Memory: 12.95 MB (beats 94.71%)`
`10`	`10`	`class Solution {`
`11`	`11`	`public:`
`12`	`12`	`int firstUniqChar(string s) {`
`13`		`- int occurrences[26] = { 0 }; // using an array as a map w/ fixed values`
	`13`	`+ int occurrences[26] = { 0 }; // using an array as a map w/ fixed values`
`14`	`14`	`for (const char& c : s) {`
`15`	`15`	`occurrences[c - 'a']++;`
`16`	`16`	`}`
`@@ -19,4 +19,4 @@ class Solution {`
`19`	`19`	`}`
`20`	`20`	`return -1;`
`21`	`21`	`}`
`22`		`-};`
	`22`	`+};`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ class Solution {`
`13`	`13`	`if (num == 0) return "0";`
`14`	`14`	`string res = "";`
`15`	`15`	`bool negative = false;`
`16`		`- if (num < 0) {`
	`16`	`+ if (num < 0) {`
`17`	`17`	`negative = true;`
`18`	`18`	`num = -num;`
`19`	`19`	`}`
`@@ -24,4 +24,4 @@ class Solution {`
`24`	`24`	`if (negative) res.insert(0, 1, '-');`
`25`	`25`	`return res;`
`26`	`26`	`}`
`27`		`-};`
	`27`	`+};`
Original file line number	Diff line number	Diff line change
`@@ -25,10 +25,10 @@ int* decompressRLElist(int* nums, int numsSize, int* returnSize) {`
`25`	`25`	`int freq = *p;`
`26`	`26`	`int val = *(++p);`
`27`	`27`	`for (unsigned char i = 0; i < freq; ++i) {`
`28`		`- *r = val;`
	`28`	`+ *r = val;`
`29`	`29`	`++r;`
`30`	`30`	`}`
`31`	`31`	`p++;`
`32`	`32`	`}`
`33`	`33`	`return returnArray;`
`34`		`-}`
	`34`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ class Solution {`
`17`	`17`	`words.push_back(sentence.substr(0, sentence.find(' '))); // first split`
`18`	`18`	`while ((pos = sentence.find(' ', pos)) != string::npos) { // other splits`
`19`	`19`	`// pos + 1 since sentence[pos] == ' '`
`20`		`- words.push_back(sentence.substr(pos + 1, pos + sws + 1));`
	`20`	`+ words.push_back(sentence.substr(pos + 1, pos + sws + 1));`
`21`	`21`	`pos++;`
`22`	`22`	`}`
`23`	`23`	`for (unsigned char i = 0, n = words.size(); i < n; ++i) {`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`Submitted: October 28, 2024`
`5`	`5`
`6`	`6`	`Runtime: 0 ms (beats 100.00%)`
`7`		`-Memory: 7.31 MB (beats 84.96%)`
	`7`	`+Memory: 7.31 MB (beats 84.96%)`
`8`	`8`	`*/`
`9`	`9`
`10`	`10`	`class Solution {`
`@@ -16,4 +16,4 @@ class Solution {`
`16`	`16`	`}`
`17`	`17`	`return res;`
`18`	`18`	`}`
`19`		`-};`
	`19`	`+};`