Mar 4, 2019

Author: dalindev

Diff for: 013__easy__roman-to-integer.js

@@ -0,0 +1,78 @@
+/**
+
+Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.
+
+Symbol       Value
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000
+For example, two is written as II in Roman numeral, just two one's added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.
+
+Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:
+
+I can be placed before V (5) and X (10) to make 4 and 9.
+X can be placed before L (50) and C (100) to make 40 and 90.
+C can be placed before D (500) and M (1000) to make 400 and 900.
+Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999.
+
+Example 1:
+
+Input: "III"
+Output: 3
+Example 2:
+
+Input: "IV"
+Output: 4
+Example 3:
+
+Input: "IX"
+Output: 9
+Example 4:
+
+Input: "LVIII"
+Output: 58
+Explanation: L = 50, V= 5, III = 3.
+Example 5:
+
+Input: "MCMXCIV"
+Output: 1994
+Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+
+ */
+
+/**
+ *
+ * O(n) time
+ * O(1) space
+ *
+ * 15m
+ */
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var romanToInt = function(s) {
+  if (!s) return 0;
+  const map = {
+      'I': 1,
+      'V': 5,
+      'X': 10,
+      'L': 50,
+      'C': 100,
+      'D': 500,
+      'M': 1000
+  }
+  let sum = map[s[s.length-1]];
+  for (let i = s.length-2; i >= 0; i--) {
+      if (map[s[i]] >= map[s[i+1]]) {
+          sum += map[s[i]];
+      } else {
+          sum -= map[s[i]];
+      }
+  }
+  return sum;
+};

Diff for: 169__easy__majority-element.js

@@ -0,0 +1,67 @@
+/**
+ *
+Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.
+
+You may assume that the array is non-empty and the majority element always exist in the array.
+
+Example 1:
+
+Input: [3,2,3]
+Output: 3
+Example 2:
+
+Input: [2,2,1,1,1,2,2]
+Output: 2
+
+ */
+
+/**
+ * Because we know majority element is more than 50%, it will always win the count
+ * O(n) time
+ * O(1) space
+ *
+ * 10m
+ *
+ * Runtime: 60 ms, faster than 98.78%
+ * Memory Usage: 37.1 MB, less than 97.09%
+ *
+ */
+var majorityElement = function(nums) {
+  let count = 1;
+  let curr_num = nums[0];
+
+  for (let i = 1; i < nums.length; i++) {
+      if (curr_num == nums[i]) count++;
+      else count--;
+
+      if (count === 0) {
+          count = 1;
+          curr_num = nums[i];
+      }
+  }
+  return curr_num;
+};
+
+/**
+ * Use hashmap, this is slower than 1st one and using O(n) space
+ *
+ * O(n) time
+ * O(n) space
+ *
+ * 10m
+ */
+var majorityElement = function(nums) {
+  let map = {};
+  let n = nums.length;
+  let half = ~~(n/2);
+
+  for (let i = 0; i < n; i++) {
+      let num = nums[i];
+
+      map[num] = (map[num] || 0) + 1;
+      if (map[num] > half ) {
+          return num;
+      }
+  }
+  return false;
+};

Diff for: 237__easy__delete-node-in-a-linked-list.js

@@ -0,0 +1,39 @@
+/**
+ *
+  Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.
+
+  Given linked list -- head = [4,5,1,9], which looks like following:
+
+  Example 1:
+
+  Input: head = [4,5,1,9], node = 5
+  Output: [4,1,9]
+  Explanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.
+  Example 2:
+
+  Input: head = [4,5,1,9], node = 1
+  Output: [4,5,9]
+  Explanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.
+
+
+  Note:
+
+  The linked list will have at least two elements.
+  All of the nodes' values will be unique.
+  The given node will not be the tail and it will always be a valid node of the linked list.
+  Do not return anything from your function.
+
+ */
+
+/**
+ *
+ * O(n) time
+ * O(1) space
+ *
+ * 20m (10sec next time...)
+ */
+var deleteNode = function(node) {
+  // very tricky but interesting!
+  node.val = node.next.val;
+  node.next = node.next.next;
+};