added hatchways solutions and sortedArray in O(n) time solution

Author: DevDelvo

hatchwaysHelp/aecio-1-10-2020.js

@@ -0,0 +1,33 @@
+// "getTwoNumber"
+// g e t_t w 
+//  0 1 2
+// "get_two_number"
+
+function toSnakeCase(str) {
+  let newStr = "";
+  for (let i = 0; i < str.length; i++) {
+    const currentChar = str[i];
+    if (i !== str.length - 1) {
+      const nextChar = str[i + 1];
+      // if the next character is capitalized => add _ and the capitalized number
+      // add the character
+      if (nextChar === nextChar.toUpperCase()) {
+        newStr += `${currentChar}_`;
+      } else {
+        newStr += currentChar.toLowerCase();
+      }
+    } else {
+      newStr += currentChar.toLowerCase();
+    }
+
+  }
+  return newStr;
+}
+
+
+
+
+// {keyA:1, keyB: {keyC:'a', keyD:[]}}
+//{key_a:1, key_b: {key_c:'a', key_d:{}}}
+
+console.log(toSnakeCase("getTwoNumbeR"))

hatchwaysHelp/shums-2-3-2010.js

@@ -0,0 +1,37 @@
+const addresses = [{ uid: 1, aid: 10, address: "1 Best Street" },
+{ uid: 2, aid: 20, address: "2 Best Street" }];
+
+const names = [{ uid: 2, name: "Kevin" }, { uid: 3, name: "Shums" }];
+
+// result = [{uid: 2, aid: 20, address: "2 Best Street", name: "Kevin"},
+// {uid: 1, aid: 10, address: "1 Best Street"},
+// { uid: 3, name: "Shums"}]
+//
+
+const join = (names, addresses) => {
+  const joined = [];
+  // for (let i = 0; i < addresses.length; i++) {
+  //   const join = {};
+  //   const address = addresses[i];
+  // }
+
+  const addressByUid = addresses.reduce((acc, curr) => {
+    acc[curr.uid] = curr;
+    return acc;
+  }, {});
+
+  names.forEach((el) => {
+    const { uid, name } = el
+    if (addressByUid[uid]) {
+      addressByUid[uid].name = name;
+    } else if (addressByUid[uid] === undefined) {
+      addressByUid[uid] = {
+        uid, name
+      };
+    }
+  })
+
+  return Object.values(addressByUid);
+}
+
+console.log(join(names, addresses));

hatchwaysInterviewPrep/mergingIntervals.js

@@ -1,20 +1,20 @@
-// Given a set of time intervals in any order, 
-// merge all overlapping intervals into one and output 
+// Given a set of time intervals in any order,
+// merge all overlapping intervals into one and output
 // the result which should have only mutually exclusive intervals.
 // Let the intervals be represented as pairs of integers for simplicity.
 
-// For example, let the given set of intervals be 
+// For example, let the given set of intervals be
 // { { 1, 3 }, { 2, 4 }, { 5, 7 }, { 6, 8 } }.
-// The intervals { 1, 3 } and { 2, 4 } overlap with each other, 
-// so they should be merged and become { 1, 4 }.Similarly { 5, 7 } 
+// The intervals { 1, 3 } and { 2, 4 } overlap with each other,
+// so they should be merged and become { 1, 4 }.Similarly { 5, 7 }
 // and { 6, 8 } should be merged and become { 5, 8 }
 //  [1,3] [2, 6], [4,5]
 //  [1,6] [4,5]
-const test1  = [[1,3], [2, 4], [3, 4], [5,7], [6,8]]
+const test1 = [[1, 3], [2, 4], [3, 4], [5, 7], [6, 8]]
 
 function mergeIntervals(arr) {
   arr = arr.sort((a, b) => a[0] - b[0]);
-  
+
   const stack = [arr[0]];
   for (let i = 1; i < arr.length; i++) {
     const current = arr[i];

hatchwaysInterviewPrep/thirdMax.js

@@ -7,44 +7,44 @@
 // Input: [3, 2, 1]   1
 // Input: [1, 4, 2, 6, 9] 4
 
-function thirdMax (arr, n) {
+function thirdMax(arr, n) {
   // let maxNum = -Infinity;
   // let secondMaxNum = -Infinity;
   // let thirdMaxNum = -Infinity;
   // // let arr = new Array(6).fill(-Infinity);
-  
+
   // for (const num of arr) {
   //   if (num > maxNum) {
   //     maxNum = num;
   //   } else if (num < maxNum && num > secondMaxNum) {
   //     secondMaxNum = num;
   //   } else if (num < secondMaxNum && num > thirdMaxNum) {
-  //     thirdMaxNum = 
+  //     thirdMaxNum =
   //   }
   // }
   arr = arr.sort((a, b) => a - b);
   const arrSet = new Set(arr);
-  
-  if (arr.length > 3) arr[arr.length - 1]
+
+  if (arr.length < 3) arr[arr.length - 1]
   return arr[arr.length - n];
-  
-  
+}
+
  public int findKthLargest(int[] nums, int k) {
 
-    final PriorityQueue<Integer> pq = new PriorityQueue<>();
-    for(int val : nums) {
-        pq.offer(val);
+  final PriorityQueue < Integer > pq = new PriorityQueue<>();
+  for (int val : nums) {
+    pq.offer(val);
 
-        if(pq.size() > k) {
-            pq.poll();
-        }
+    if (pq.size() > k) {
+      pq.poll();
     }
-    return pq.peek();
+  }
+  return pq.peek();
 }
- [3, 1, 5, 9 , 6, 7] k = 3  
- 
-  
-  [9, 6, 7]
+[3, 1, 5, 9, 6, 7] k = 3
+
+
+[9, 6, 7]
 }
 
 public int findKthLargest(int[] nums, int k) {

squaresOfSortedArray.js

@@ -7,7 +7,7 @@
 // Example 2:
 // Input: [-7,-3,2,3,11]
 // Output: [4,9,9,49,121]
- 
+
 // Note:
 // 1 <= A.length <= 10000
 // -10000 <= A[i] <= 10000
@@ -29,10 +29,10 @@ const squaresOfSortedArray = (arr) => {
     let negativeIdx = positiveIdx - 1;
     let tempIdx = 0;
     let res = [];
-    while ( negativeIdx >= 0 && positiveIdx < arr.length) {
+    while (negativeIdx >= 0 && positiveIdx < arr.length) {
         let negSquard = Math.pow(arr[negativeIdx], 2);
         let posSquared = Math.pow(arr[positiveIdx], 2);
-        
+
         if (negSquard < posSquared) {
             res[tempIdx] = negSquard;
             negativeIdx--;
@@ -53,5 +53,24 @@ const squaresOfSortedArray = (arr) => {
     return res
 }
 
-console.log(squaresOfSortedArray([-4,-1,0,3,10])) // [0,1,9,16,100]
-console.log(squaresOfSortedArray([-7,-3,2,3,11])) // [4,9,9,49,121]
+const squaresOfSortedArray2 = (arr) => {
+    if (!arr.length) return [];
+    const sortedSquares = Array(arr.length).fill(0);
+    let left = 0;
+    let right = arr.length - 1;
+    for (let i = sortedSquares.length - 1; i >= 0; i--) {
+        if (Math.abs(arr[left] > arr[right])) {
+            sortedSquares[i] = Math.pow(arr[left], 2);
+            left++;
+        } else {
+            sortedSquares[i] = Math.pow(arr[right], 2);
+            right--;
+        }
+    }
+    return sortedSquares;
+}
+
+// console.log(squaresOfSortedArray([-4,-1,0,3,10])) // [0,1,9,16,100]
+// console.log(squaresOfSortedArray([-7,-3,2,3,11])) // [4,9,9,49,121]
+console.log(squaresOfSortedArray2([-4, -1, 0, 3, 10])) // [0,1,9,16,100]
+console.log(squaresOfSortedArray2([-7, -3, 2, 3, 11])) // [4,9,9,49,121]