easy problems

Author: zhuli19901106

assign-cookies_1_AC.cpp

@@ -0,0 +1,21 @@
+#include <algorithm>
+using std::sort;
+
+class Solution {
+public:
+    int findContentChildren(vector<int>& g, vector<int>& s) {
+        int ng = g.size();
+        int ns = s.size();
+        sort(g.begin(), g.end());
+        sort(s.begin(), s.end());
+        int i = 0;
+        int j = 0;
+        while (i < ns && j < ng) {
+            if (s[i] >= g[j]) {
+                ++j;
+            }
+            ++i;
+        }
+        return j;
+    }
+};

delete-node-in-a-linked-list_1_AC.cpp

@@ -0,0 +1,19 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void deleteNode(ListNode* node) {
+        // Except the tail node.
+        // The value shall be deep-copied, or there will be problems.
+        ListNode* ptr = node->next;
+        node->val = ptr->val;
+        node->next = ptr->next;
+        delete ptr;
+    }
+};

excel-sheet-column-number_1_AC.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int titleToNumber(string s) {
+        const int R = 26;
+        int res = 1;
+        int i;
+        int n = s.size();
+        int b = 1;
+        
+        for (i = 1; i < n; ++i) {
+            b *= R;
+            res += b;
+        }
+        b = 0;
+        for (i = 0; i < n; ++i) {
+            b = b * R + (s[i] - 'A');
+        }
+        res += b;
+        return res;
+    }
+};

first-unique-character-in-a-string_1_AC.cpp

@@ -0,0 +1,33 @@
+#include <cstring>
+using std::memset;
+
+class Solution {
+public:
+    int firstUniqChar(string s) {
+        // Only lowercase letters.
+        const int DICT_SIZE = 26;
+        int idx[DICT_SIZE];
+        memset(idx, -1, DICT_SIZE * sizeof(int));
+        
+        int i;
+        int n = s.size();
+        const int DUP = -2; // For "duplicated".
+        for (i = 0; i < n; ++i) {
+            if (idx[s[i] - 'a'] == -1) {
+                idx[s[i] - 'a'] = i;
+            } else {
+                idx[s[i] - 'a'] = DUP;
+            }
+        }
+        int res = -1;
+        for (i = 0; i < DICT_SIZE; ++i) {
+            if (idx[i] < 0) {
+                continue;
+            }
+            if (res == -1 || res > idx[i]) {
+                res = idx[i];
+            }
+        }
+        return res;
+    }
+};

intersection-of-two-arrays_1_AC.cpp

@@ -0,0 +1,32 @@
+#include <unordered_set>
+using std::unordered_set;
+
+class Solution {
+public:
+    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
+        int n1 = nums1.size();
+        int n2 = nums2.size();
+        if (n1 > n2) {
+            return intersection(nums2, nums1);
+        }
+        
+        vector<int> res;
+        unordered_set<int> s1, s2;
+        int i;
+        for (i = 0; i < n1; ++i) {
+            s1.insert(nums1[i]);
+        }
+        for (i = 0; i < n2; ++i) {
+            s2.insert(nums2[i]);
+        }
+        unordered_set<int>::const_iterator it;
+        for (it = s1.begin(); it != s1.end(); ++it) {
+            if (s2.find(*it) != s2.end()) {
+                res.push_back(*it);
+            }
+        }
+        s1.clear();
+        s2.clear();
+        return res;
+    }
+};

invert-binary-tree_1_AC.cpp

@@ -0,0 +1,23 @@
+#include <algorithm>
+using std::swap;
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* invertTree(TreeNode* root) {
+        if (root == NULL) {
+            return root;
+        }
+        swap(root->left, root->right);
+        invertTree(root->left);
+        invertTree(root->right);
+        return root;
+    }
+};

majority-element_1_AC.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int majorityElement(vector<int> &nums) {
+        vector<int> &a = nums;
+        int n = a.size();
+        
+        int i, res = a[0], cnt = 1;
+        for (i = 1; i < n; ++i) {
+            res == a[i] ? ++cnt : (cnt == 1 ? res = a[i] : --cnt);
+        }
+        
+        // Majority element is guaranteed to exist, so skip the checking.
+        return res;
+    }
+};

minimum-moves-to-equal-array-elements_1_AC.cpp

@@ -0,0 +1,22 @@
+#include <algorithm>
+using std::min;
+
+class Solution {
+public:
+    int minMoves(vector<int>& nums) {
+        int n = nums.size();
+        if (n == 0) {
+            return 0;
+        }
+        int min_val = nums[0];
+        int i;
+        for (i = 1; i < n; ++i) {
+            min_val = min(min_val, nums[i]);
+        }
+        int res = 0;
+        for (i = 0; i < n; ++i) {
+            res += nums[i] - min_val;
+        }
+        return res;
+    }
+};

move-zeroes_1_AC.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+        int n = nums.size();
+        int i, j;
+        i = j = 0;
+        while (i < n) {
+            if (nums[i] != 0) {
+                nums[j++] = nums[i];
+            }
+            ++i;
+        }
+        while (j < n) {
+            nums[j++] = 0;
+        }
+    }
+};

ransom-note_1_AC.cpp

@@ -0,0 +1,27 @@
+#include <cstring>
+using std::memset;
+
+class Solution {
+public:
+    bool canConstruct(string ransomNote, string magazine) {
+        const int DICT_SIZE = 26;
+        int cnt[DICT_SIZE];
+        memset(cnt, 0, DICT_SIZE * sizeof(int));
+        
+        int nr = ransomNote.size();
+        int i;
+        for (i = 0; i < nr; ++i) {
+            --cnt[ransomNote[i] - 'a'];
+        }
+        int nm = magazine.size();
+        for (i = 0; i < nm; ++i) {
+            ++cnt[magazine[i] - 'a'];
+        }
+        for (i = 0; i < DICT_SIZE; ++i) {
+            if (cnt[i] < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+};