Solution for #64

solutions/116.js

@@ -0,0 +1,21 @@
+// flatten the array
+//
+const solution = (arr) => {
+  if (arr.length === 0) {
+    return arr;
+  }
+  let elem = arr.shift();
+  if (elem.length) {
+    elem.forEach((elem) => {
+      arr.push(elem);
+    });
+    solution(arr);
+  } else {
+    solution(arr).push(elem);
+  }
+  return arr;
+};
+
+module.exports = {
+  solution: solution,
+};

solutions/13.js

@@ -1,3 +1,16 @@
+//Rahul Kalra
+//Checking to see if the string is palindrome
+const solution2 = (palindromeInput) =>{
+  let reverse = "";
+  for(let i = palindromeInput.length - 1; i >= 0; i--){
+    reverse += palindromeInput[i];
+  }
+  if(reverse === palindromeInput){
+    return true;
+  }
+  return false;
+};
+
 // vdewinter
 // Return true if input string is a palindrome
 
@@ -15,4 +28,6 @@ const solution = (str) => {
 
 module.exports = {
   solution,
+  solution2
 };
+

solutions/15.js

@@ -9,6 +9,18 @@ const solution = (fullString, subString) => {
     return fullString.includes(subString);
 };
 
+// Colin Xie
+const solution1 = (fullString, subString) => {
+  for(let i = 0; i < fullString.length; i++){
+    let subFull = fullString.substring(i,i + subString.length);
+    if(subFull  === subString){
+      return true;
+    }
+  }
+  return false;
+};
+
 module.exports = {
   solution,
+  solution1,
 };

solutions/21.js

@@ -0,0 +1,35 @@
+// Rahul Kalra
+// Return array of largest 3 values in descending order from a given array
+
+const max = (array) =>{
+  let max = array[0];
+  for(let i = 0; i < array.length; i++){
+    if(max <= array[i+1]){
+      max = array[i+1];
+    }
+  }
+    return max;
+};
+
+const removeNum = (array, max) =>{
+  let newArray = [];
+  for(let i = 0; i < array.length; i++){
+    if(!(max === array[i])){
+      newArray.push(array[i]);
+    }
+  }
+  return newArray;
+};
+
+const solution = (array) =>{
+  let a = 0;
+  let newArray = [];
+  for(let i = 0; i < 3; i++){
+    a = max(array);;
+    array = removeNum(array, a); 
+    newArray.push(a);
+  }
+  return [newArray[0], newArray[1], newArray[2]];
+};
+
+module.exports = {solution};

solutions/31.js

@@ -3,12 +3,12 @@
 // input: ['hi','hello','hola']
 // output 'hello'
 
-// Solutions by Colin Xie @ColinX13
-
+// Solution by Colin Xie @ColinX13
+// Solution1 by Maricris Bonzo @Seemcat
 /**
  * @param {string[]} arr - the array of strings
  * @return {string} word - the longest word in the array
-*/
+ */
 const solution = (arr) => {
   let maxLength = 0;
   let word = 0;
@@ -20,6 +20,20 @@ const solution = (arr) => {
   }
   return word;
 };
+
+const solution1 = (arr) => {
+  let big = arr[0];
+  let i = 1;
+  while(i < arr.length){
+    if (big.length < arr[i].length){
+      big = arr[i];
+    }
+    i++;
+  };
+  return big;
+};
+
 module.exports = {
   solution,
+  solution1
 };

solutions/32.js

@@ -0,0 +1,23 @@
+//Rahul Kalra
+//Finding Singleton
+
+const solution = (array) =>{
+  let data = {};
+  let newArray = [];
+  for(let i = 0; i < array.length; i++){
+    if(!(data[array[i]])){
+      data[array[i]] = 1;
+    }
+      else{
+        data[array[i]]++;
+      }
+    }
+    for(let key in data){
+      if(data[key] === 1){
+        newArray.push(Number(key));
+      }
+    }
+  return newArray;
+};
+
+module.exports = {solution};

solutions/34.js

@@ -1,6 +1,5 @@
 // Daniel
 // Number of repeating elements in an array
-
 const solution = (arr, k) => {
   let total = 0;
   for (i=0; i < arr.length; i++) {
@@ -9,7 +8,26 @@ const solution = (arr, k) => {
     }
    }
    return total;
- };
- module.exports = {
-   solution,
 };
+
+// Maricris Bonzo
+const solution1 = (array, num) => {
+  let i = 0;
+  let numOfTimes = 0;
+
+  while (i < array.length){
+    if (array[i] === num){
+      numOfTimes = numOfTimes + 1;
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return numOfTimes;
+};
+
+module.exports = {
+  solution,
+  solution1
+ };
+

solutions/56.js

@@ -27,7 +27,24 @@ const solution = (arr, total) => {
     return acc;
   }, total);
 };
+// return min number of coins
+// daniel s.
+const solution2 = (arr, value) => {
+  if (value === 0) {
+    return 0;
+  };
+  let currentMin = value;
+  arr.forEach((coin)=> {
+  let childCoins = 0;
+    if (value - coin > 0) {
+      childCoins = solution2(arr, value - coin);
+    }
+    currentMin = Math.min(currentMin, childCoins);
+  });
+  return currentMin + 1;
+};
 
 module.exports = {
   solution,
+  solution2,
 };

solutions/58.js

@@ -0,0 +1,61 @@
+// Max Fun Problem
+// Return an array of employees that creates the maximum fun
+// Input: Employee object
+// Output: [Employee objects]
+
+// Solution by Yoo Jin
+
+class Employee {
+  constructor(funVal, staffArray=[]) {
+    this.funVal = funVal;
+    this.staff = [];
+    this.addStaff(staffArray);
+  }
+
+  addStaff(staffArray) {
+    staffArray.forEach((staff) => {
+      this.staff.push(staff);
+    });
+  }
+}
+
+/**
+ * Given an Employee, return an array of employees that creates the maximum fun.
+ * There is one condition: An Employee cannot be on the guestlist if his direct manager is going to the party.
+ * @param {Employee} emp - an Employee with fun value and a list of his staff
+ * @returns {Employee []]} list - Array of employees that creates the maximum fun
+ */
+const solution = (emp) => {
+  if(!emp) {
+    return [];
+  }
+
+  if(emp.staff.length === 0) {
+    return [emp];
+  }
+
+  let funStaffListWithoutEmp = [];
+  let funValWithoutEmp = emp.staff.reduce((funVal, staff) => {
+    let staffList = solution(staff);
+    funStaffListWithoutEmp = funStaffListWithoutEmp.concat(staffList);
+    return staffList.reduce((acc, emp) => (acc + emp.funVal), funVal);
+  }, 0);
+
+  let funValWithEmp = emp.funVal;
+  let funStaffListWithEmp = [emp];
+  emp.staff.forEach((staff) => {
+    funValWithEmp = staff.staff.reduce((funVal, staff) => {
+      let staffList = solution(staff);
+      funStaffListWithEmp = funStaffListWithEmp.concat(staffList);
+      return staffList.reduce((acc, emp) => (acc + emp.funVal), funVal);
+    }, funValWithEmp);
+  });
+
+  return funValWithoutEmp > funValWithEmp ?
+    funStaffListWithoutEmp : funStaffListWithEmp;
+};
+
+module.exports = {
+  Employee,
+  solution
+};

solutions/61.js

@@ -3,11 +3,11 @@
 // Input: 16,24
 // Output: 8
 
-// Solutions by Colin Xie @ColinX13
+// Solution #0 by Colin Xie @ColinX13
+// Solution #1 by Maricris Bonzo @seemcat
 
-/*
- * Factor is determined when both remainders of num1 and num2
- * are 0 when factor is divided from them.
+/**
+ * Factor is determined when both remainders of num1 and num2 are 0 when factor is divided from them.
  * @param num1 - the first number input
  * @param num2 - the second number input
  * @return {number} factor - the greatest common factor for num1 and num2
@@ -19,6 +19,48 @@ const solution = (num1, num2) => {
     }
   }
 };
+
+const solution1 = (num1, num2) => { 
+  let num1Array = [];
+  let num2Array = [];
+  let i = 1;
+  let j = 1;
+
+  while (i <= num1) {
+    if (num1%i === 0){
+      num1Array.push(i);
+      i++;
+    } else {
+      i++;
+    }
+  };
+
+  while (j <= num2) {
+    if (num2%j === 0){
+      num2Array.push(j);
+      j++;
+    } else {
+      j++;
+    }
+  };
+
+  let k = 0;
+  let commonNumbers = [];
+
+  while (k < num2Array.length){
+    if (num1Array.indexOf(num2Array[k]) === -1){
+      k++;
+    } else {
+      commonNumbers.push(num2Array[k]);
+      k++;
+    };
+  };
+
+  let GCD = Math.max.apply(Math, commonNumbers);
+  return GCD;
+};
+
 module.exports = {
   solution,
+  solution1
 };

solutions/8.js

@@ -9,6 +9,19 @@ const solution = (string) => {
   return newString;
 };
 
+// Maricris Bonzo: seemcat
+
+const solution1 = (string) => {
+  let indexLength = string.length - 1;
+  let reverseString = '';
+
+  for(i = 0; i <= indexLength; i++){
+    reverseString = string[i] + reverseString;
+  }
+  return reverseString;
+};
+
 module.exports = {
   solution,
+  solution1
 };

solutions/sol18.py

@@ -0,0 +1,17 @@
+#Himanshu Nachane (@Himanshu1495)
+'''return missing number in an input array of consecutively increasing numbers.
+
+i: [5,6,8,9]
+o: 7
+'''
+
+def missing_num(arr):
+	first_element = arr[0]
+	last_element = arr[-1]
+	new_sum = 0
+	for x in range(first_element,last_element+1):
+		new_sum += x
+	return new_sum - sum(arr)
+
+
+