update 1, add 75, 136, 147, 2415

Author: rustykitty

0001-two-sum.cpp

@@ -0,0 +1,23 @@
+/*
+1. Two Sum
+
+Submitted: December 20, 2024
+
+Runtime: 3 ms (beats 77.60%)
+Memory: 14.80MB (beats 24.95%)
+*/
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> map;
+        for (int i = 0, n = nums.size(); i < n; ++i) {
+            if (map.count(target - nums[i])) {
+                return { i, map[target - nums[i]] };
+            } else {
+                map[nums[i]] = i;
+            }
+        }
+        return {}; // this is only here so that compliation doesn't fail
+    }
+};

0075-sort-colors.c

@@ -0,0 +1,25 @@
+/*
+75. Sort Colors
+
+Submitted: December 20, 2024
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 9.70 MB (beats 68.92%)
+*/
+
+void sortColors(int* nums, int numsSize) {
+    int count[3] = { 0, 0, 0 };
+    for (int* p = nums, *end = (nums + numsSize); p != end; ++p) {
+        count[*p]++;
+    }
+    int* p = nums;
+    for (int i = 0; i < count[0]; ++i) {
+        *p++ = 0;
+    }
+    for (int i = 0; i < count[1]; ++i) {
+        *p++ = 1;
+    }
+    for (int i = 0; i < count[2]; ++i) {
+        *p++ = 2;
+    }
+}

0075-sort-colors.cpp

@@ -0,0 +1,29 @@
+/*
+75. Sort Colors
+
+Submitted: December 20, 2024
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 11.46 MB (beats 35.93%)
+*/
+
+class Solution {
+public:
+    // counting sort
+    void sortColors(vector<int>& nums) {
+        int count[3] = { 0, 0, 0 };
+        for (const int i : nums) {
+            count[i]++;
+        }
+        auto it = nums.begin();
+        for (int i = 0; i < count[0]; ++i) {
+            *it++ = 0;
+        }
+        for (int i = 0; i < count[1]; ++i) {
+            *it++ = 1;
+        }
+        for (int i = 0; i < count[2]; ++i) {
+            *it++ = 2;
+        }
+    }
+};

0136-single-number.cpp

@@ -0,0 +1,19 @@
+/*
+136. Single Number
+
+Submitted: December 20, 2024
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 20.71 MB (beats 23.16%)
+*/
+
+class Solution {
+public:
+    int singleNumber(vector<int>& nums) {
+        int n = 0;
+        for (const int i : nums) {
+            n ^= i;
+        }
+        return n;
+    }
+};

0136-single-number.py

@@ -0,0 +1,10 @@
+"""
+136. Single Number
+
+Runtime: 4 ms (beats 48.81%)
+Memory: 19.51 MB (beats 6.17%)
+"""
+
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        return functools.reduce(lambda x, y: x ^ y, nums)

0147-insertion-sort-list.cpp

@@ -0,0 +1,43 @@
+/*
+147. Insertion Sort List
+
+Submitted: December 20, 2024
+
+Runtime: 43 ms (beats 5.75%)
+Memory: 14.59 MB (beats 65.76%)
+*/
+
+/**
+ * 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* insertionSortList(ListNode* head) {
+        ListNode* newHead = head;
+        head = head->next;
+        newHead->next = nullptr;
+        while (head != nullptr) {
+            cout << head->val;
+            ListNode* node = head;
+            head = head->next;
+            ListNode* p = newHead;
+            if (node->val < newHead->val) {
+                node->next = newHead;
+                newHead = node;
+            }
+            else {
+                for (; p->next != nullptr && p->next->val < node->val; p = p->next) ;
+                node->next = p->next;
+                p->next = node;
+            }
+        }
+        return newHead;
+    }
+};

2415-reverse-odd-levels-of-binary-tree.cpp

@@ -0,0 +1,45 @@
+/*
+2415. Reverse Odd Levels of Binary Tree
+
+LeetCode Daily Question for December 20, 2024
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 79.82 MB (beats 57.48%)
+*/
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* reverseOddLevels(TreeNode* root) {
+        if (root == nullptr) return root;
+        deque<TreeNode*> queue;
+        int level = 0;
+        queue.push_back(root);
+        while (!queue.empty()) {
+            // level order traversal stuff
+            for (int i = 0, n = queue.size(); i < n; ++i) {
+                TreeNode* p = queue.back();
+                queue.pop_back();
+                if (p->left != nullptr) queue.push_front(p->left);
+                if (p->right != nullptr) queue.push_front(p->right);
+            }
+            if (++level & 1) { // if level is odd
+                // reverse node values
+                for (int i = 0, n = queue.size(); i < n / 2; ++i) {
+                    swap(queue[i]->val, queue[n - i - 1]->val);
+                }
+            }
+        }
+        return root;
+    }
+};