DEV 25, 2018

Author: dalindev

561__easy__array-partition-i.js

@@ -1,11 +1,23 @@
-/**
- * @param
- * @return
- */
+/*
+
+  Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as possible.
+
+  Example 1:
+  Input: [1,4,3,2]
+
+  Output: 4
+  Explanation: n is 2, and the maximum sum of pairs is 4 = min(1, 2) + min(3, 4).
+  Note:
+  n is a positive integer, which is in the range of [1, 10000].
+  All the integers in the array will be in the range of [-10000, 10000].
+
+*/
 
 /**
- *
- *
+ * O(nlogn) time
+ * O(n) space if merge sort, O(1) if quick sort.
+ * ALSO NOTE: if use counting sort, time and space will be O(n+k) where k is the range of input
+ * Runtime: 120 ms, faster than 97.91% of JavaScript
  */
 var arrayPairSum = function(nums) {
   nums = nums.sort((a, b) => a - b);
@@ -15,3 +27,29 @@ var arrayPairSum = function(nums) {
   }
   return res;
 };
+
+/**
+ * Use bucket sort
+ * time O(n)
+ * space O(n)
+ * Runtime: 76 ms, faster than 100.00%
+ */
+var arrayPairSum = function(nums) {
+  let arr = new Array(20001).fill(0); // num range of [-10000, 10000]
+  let base = 10000;
+
+  for (let i = 0; i < nums.length; i++) {
+    arr[nums[i] + base]++;
+  }
+
+  let sum = 0;
+  let adding = true;
+  for (let i = 0; i < arr.length; i++) {
+    while (arr[i] > 0) {
+      if (adding) sum += i - base;
+      adding = !adding;
+      arr[i]--;
+    }
+  }
+  return sum;
+};

852__easy__peak-index-in-a-mountain-array.js

@@ -0,0 +1,50 @@
+/**
+
+Let's call an array A a mountain if the following properties hold:
+
+A.length >= 3
+There exists some 0 < i < A.length - 1 such that A[0] < A[1] < ... A[i-1] < A[i] > A[i+1] > ... > A[A.length - 1]
+Given an array that is definitely a mountain, return any i such that A[0] < A[1] < ... A[i-1] < A[i] > A[i+1] > ... > A[A.length - 1].
+
+Example 1:
+
+Input: [0,1,0]
+Output: 1
+Example 2:
+
+Input: [0,2,1,0]
+Output: 1
+Note:
+
+3 <= A.length <= 10000
+0 <= A[i] <= 10^6
+A is a mountain, as defined above.
+
+ */
+
+/**
+ * Binary search
+ * O(n) time
+ * O(1) space
+ *
+ * 20m
+ */
+var peakIndexInMountainArray = function(A) {
+  let left = 0;
+  let right = A.length - 1;
+  let curr = ~~(A.length / 2);
+
+  while (left < right) {
+    if (A[curr - 1] < A[curr] && A[curr] > A[curr + 1]) {
+      // low < high > low, peak found!
+      return curr;
+    } else if (A[curr - 1] < A[curr] && A[curr] < A[curr + 1]) {
+      // ex: 5 - 6 - 7, up-trend so peak at right hand side
+      left = curr;
+      curr = ~~((left + right) / 2);
+    } else {
+      right = curr;
+      curr = ~~((left + right) / 2);
+    }
+  }
+};

922__easy__sort-array-by-parity-ii.js

@@ -0,0 +1,51 @@
+/*
+
+Given an array A of non-negative integers, half of the integers in A are odd, and half of the integers are even.
+
+Sort the array so that whenever A[i] is odd, i is odd; and whenever A[i] is even, i is even.
+
+You may return any answer array that satisfies this condition.
+
+
+Example 1:
+
+Input: [4,2,5,7]
+Output: [4,5,2,7]
+Explanation: [4,7,2,5], [2,5,4,7], [2,7,4,5] would also have been accepted.
+
+
+Note:
+
+2 <= A.length <= 20000
+A.length % 2 == 0
+0 <= A[i] <= 1000
+
+*/
+
+/**
+ * check even and odd index until both not satisfies the condition then swap them (in place swap)
+ * time O(n)
+ * space O(1)
+ * Runtime: 104 ms, faster than 85.27% of JavaScript
+ */
+var sortArrayByParityII = function(A) {
+  let n = A.length;
+  let evenIdx = 0;
+  let oddIdx = 1;
+
+  while (evenIdx < n && oddIdx < n) {
+    while (evenIdx < n && A[evenIdx] % 2 == 0) {
+      evenIdx += 2;
+    }
+    while (oddIdx < n && A[oddIdx] % 2 != 0) {
+      oddIdx += 2;
+    }
+    if (evenIdx < n && oddIdx < n) {
+      [A[evenIdx], A[oddIdx]] = [A[oddIdx], A[evenIdx]];
+      evenIdx += 2;
+      oddIdx += 2;
+    }
+  }
+
+  return A;
+};