2015-12-17 21:00:10

usernameafer · usernameafer · commit a90ce82863b6 · 2015-12-17T07:55:47.000-05:00
diff --git a/AddDigits.cc b/AddDigits.cc
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+public:
+  int addDigits(int num) { return (num - 1) % 9 + 1; }
+};
+
+int main(int argc, char const *argv[]) {
+  Solution s;
+  return 0;
+}
diff --git a/ContainsDuplicate.cc b/ContainsDuplicate.cc
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+public:
+  set<int> int_set;
+  bool containsDuplicate(vector<int> &nums) {
+    for (int i = 0; i < nums.size(); i++) {
+      int temp = nums[i];
+      if (int_set.find(temp) != int_set.end())
+        return true;
+      int_set.insert(temp);
+    }
+    return false;
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  /* code */
+  return 0;
+}
diff --git a/DeleteNodeinaLinkedList.cc b/DeleteNodeinaLinkedList.cc
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+struct ListNode {
+  int val;
+  ListNode *next;
+  ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution {
+public:
+  void deleteNode(ListNode *node) {
+    if (!node)
+      return;
+    if (node->next == NULL) {
+      delete node;
+    } else {
+      ListNode *temp = node->next;
+      node->val = node->next->val;
+      node->next = node->next->next;
+      delete temp;
+    }
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  Solution sol;
+  return 0;
+}
diff --git a/ExcelSheetColumnNumber.cc b/ExcelSheetColumnNumber.cc
@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+public:
+  int titleToNumber(string s) {
+    int ans = 0;
+    int len = s.size();
+    for (int dx = 0; dx < len; dx++) {
+      ans = ans * 26 + (s[dx] - 'A' + 1);
+    }
+
+    return ans;
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  /* code */
+  return 0;
+}
diff --git a/InvertBinaryTree.cc b/InvertBinaryTree.cc
@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+struct TreeNode {
+  int val;
+  TreeNode *left;
+  TreeNode *right;
+  TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+  TreeNode *invertTree(TreeNode *root) {
+    invert_tree_util(root);
+    return root;
+  }
+
+  void invert_tree_util(TreeNode *root) {
+    if (root == NULL)
+      return;
+    swap(root->left, root->right);
+    invert_tree_util(root->left);
+    invert_tree_util(root->right);
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  /* code */
+  return 0;
+}
diff --git a/LowestCommonAncestorofaBinarySearchTree.cc b/LowestCommonAncestorofaBinarySearchTree.cc
@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+struct TreeNode {
+  int val;
+  TreeNode *left;
+  TreeNode *right;
+  TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+  TreeNode *lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q) {
+    if (root == NULL)
+      return NULL;
+    if (root == p || root == q)
+      return root;
+
+    TreeNode *left_lca = lowestCommonAncestor(root->left, p, q);
+    TreeNode *right_lca = lowestCommonAncestor(root->right, p, q);
+
+    if (left_lca && right_lca)
+      return root;
+    return (left_lca != NULL) ? left_lca : right_lca;
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  /* code */
+  return 0;
+}
diff --git a/MajorityElement.cc b/MajorityElement.cc
@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+public:
+  int majorityElement(vector<int> &num) {
+    int counter = 0;
+    int answer = 0;
+    for (int i = 0; i < num.size(); ++i) {
+      if (counter == 0) {
+        answer = num[i];
+        counter++;
+
+      } else {
+        if (num[i] != answer) {
+          counter--;
+        } else
+          counter++;
+      }
+    }
+
+    return answer;
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  /* code */
+  return 0;
+}
diff --git a/MaximumDepthofBinaryTree.cc b/MaximumDepthofBinaryTree.cc
@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+struct TreeNode {
+  int val;
+  TreeNode *left;
+  TreeNode *right;
+  TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+class Solution {
+public:
+  int maxDepth(TreeNode *root) {
+    if (root == NULL)
+      return 0;
+
+    int res = 0;
+    queue<TreeNode *> q;
+    q.push(root);
+    while (!q.empty()) {
+      ++res;
+      for (int i = 0, n = q.size(); i < n; ++i) {
+        TreeNode *p = q.front();
+        q.pop();
+
+        if (p->left != NULL)
+          q.push(p->left);
+        if (p->right != NULL)
+          q.push(p->right);
+      }
+    }
+
+    return res;
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  /* code */
+  return 0;
+}
diff --git a/MoveZeroes.cc b/MoveZeroes.cc
@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+#include <vector>
+
+
+using namespace std;
+
+class Solution {
+public:
+  void moveZeroes(vector<int> &nums) {
+
+    if (nums.size() == 0)
+      return;
+
+    int insertPos = 0;
+    for (int num : nums) {
+      if (num != 0)
+        nums[insertPos++] = num;
+    }
+    while (insertPos < nums.size()) {
+      nums[insertPos++] = 0;
+    }
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  Solution sol;
+  vector<int> data;
+  data.push_back(0);
+  data.push_back(1);
+  data.push_back(0);
+  data.push_back(3);
+  data.push_back(12);
+  sol.moveZeroes(data);
+
+  for (int num : data) {
+    cout << num << " ";
+  }cout << endl;
+
+  return 0;
+}
diff --git a/NimGame.cc b/NimGame.cc
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+public:
+  bool canWinNim(int n) { return (n % 4 == 0) ? false : true; }
+};
+
+int main(int argc, char const *argv[]) {
+  Solution sol;
+  cout << sol.canWinNim(100) << endl;
+  return 0;
+}
diff --git a/Numberof1Bits.cc b/Numberof1Bits.cc
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+int hammingWeight(uint32_t n) {
+  uint32_t i = n;
+  i = i - ((i >> 1) & 0x55555555);
+  i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
+  return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
+}
+
+int main(int argc, char const *argv[]) {
+  /* code */
+  return 0;
+}
diff --git a/RomantoInteger.cc b/RomantoInteger.cc
diff --git a/SameTree.cc b/SameTree.cc
diff --git a/ValidAnagram.cc b/ValidAnagram.cc
