From 6d59cc920833847aee9ea3ae1b3cefd48af1e833 Mon Sep 17 00:00:00 2001
From: vbakarian <vako.bakarian@gmail.com>
Date: Wed, 10 Jan 2018 20:56:04 -0500
Subject: [PATCH] problems workshop

---
 problems/problem1.js  | 24 +++++++++++-------------
 problems/problem10.js | 11 +++++++----
 problems/problem11.js | 20 ++++++++++++--------
 problems/problem12.js | 39 +++++++++++++++++++++++++--------------
 problems/problem13.js | 20 ++++++++++++++------
 problems/problem14.js | 11 ++++++++++-
 problems/problem2.js  | 14 +++++++-------
 problems/problem3.js  | 19 +++++++++----------
 problems/problem4.js  | 23 +++++++++++++++++++----
 problems/problem5.js  | 17 +++++++++--------
 problems/problem6.js  | 25 ++++++++++++++++++++-----
 problems/problem7.js  | 32 ++++++++++++++++++++++++++------
 problems/problem8.js  | 15 +++++++--------
 problems/problem9.js  | 21 ++++++++++++++-------
 14 files changed, 190 insertions(+), 101 deletions(-)

diff --git a/problems/problem1.js b/problems/problem1.js
index 6d7505c..6c59314 100644
--- a/problems/problem1.js
+++ b/problems/problem1.js
@@ -1,23 +1,21 @@
-var assert = require('assert');
-
+const assert = require('assert');
 // we need 5 test cases. I provided 1 input
-let inputs = [
-  ""
-]
+let inputs = ["","abc","231","orange","apple","google"]
 
-let outputs = [
-  
-]
+let outputs = [undefined,"a","2","o","a","g"]
 
-// Make this function return the first letter of the string that is passed to it. If the string does not have a first letter, return undefined
+// Make this function return the first character of the string that is passed to it. If the string does not have a first letter, return undefined
 function f(str) {
-    
+  if (str.length == 0) {
+    return undefined;
+  }
+  return str[0];
 }
 
 function runTest(i) {
-    var expected = outputs[i];
-    var actual = f(inputs[i]);
-    assert.deepEqual(actual, expected);
+  var expected = outputs[i];
+  var actual = f(inputs[i]);
+  assert.deepEqual(actual, expected);
 }
 
 runTest(0);
diff --git a/problems/problem10.js b/problems/problem10.js
index e7eddde..0a1605c 100644
--- a/problems/problem10.js
+++ b/problems/problem10.js
@@ -1,11 +1,10 @@
 var assert = require('assert');
 
 // we need 5 test cases. 
-let inputs = [
-  
+let inputs = ["lol","i tried","this is good","uppercase","lowercase"
 ]
 
-let outputs = [
+let outputs = ["Lol","I Tried","This Is Good","Uppercase","Lowercase"
   
 ]
 
@@ -17,7 +16,11 @@ f("ALL YOUR BASE ARE BELONG"); // All Your Base Are Belong
 
 */
 function f(str) {
-    
+    var splitStr = str.toLowerCase().split(' ');
+    for (var i = 0; i < splitStr.length; i++) {
+        splitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].substring(1);     
+    }
+    return splitStr.join(' '); 
 }
 
 function runTest(i) {
diff --git a/problems/problem11.js b/problems/problem11.js
index a9db8bc..98557c4 100644
--- a/problems/problem11.js
+++ b/problems/problem11.js
@@ -1,23 +1,27 @@
 var assert = require('assert');
 
 // we need 5 test cases. 
-let inputs = [
-  
-]
+let inputs = [[1,2,3],[3,4,2,"x"],[],["12",21,2],["",""]]
 
-let outputs = [
-  
-]
+let outputs = [6,9,0,23,0]
 
 /*
 Make this function return the sum of all the numbers in the input array. If any element in the array is not a number, skip it. If the array is empty, return zero.
 */
 function f(arr) {
-    
+    var sum = 0;
+    for (var i = 0; i < arr.length; i++) {
+        if (typeof arr[i] == 'number') {
+            sum += arr[i];
+        } else if (arr.length === 0) {
+            return 0;
+        }
+    }
+    return sum;
 }
 
 function runTest(i) {
-    if(i > inputs.length) throw new Error("You do not have enough test cases");
+    if (i > inputs.length) throw new Error("You do not have enough test cases");
     var expected = outputs[i];
     var actual = f(inputs[i]);
     assert.deepEqual(actual, expected);
diff --git a/problems/problem12.js b/problems/problem12.js
index 2947d1b..22cb5e7 100644
--- a/problems/problem12.js
+++ b/problems/problem12.js
@@ -1,13 +1,9 @@
 var assert = require('assert');
 
 // we need 5 test cases. 
-let inputs = [
-  
-]
+let inputs = [ [[0,1,2,3],[1,3,4,5]] ];
 
-let outputs = [
-  
-]
+let outputs = [[0,2,4,5]]
 
 /*
 Make this function return the elements that are unique to array1 and array2.
@@ -20,19 +16,34 @@ uniqueElements([1,2,3], [1,2,3]); // []
 uniqueElements(2,3); // undefined, not arrays
 */
 function f(arr1, arr2) {
-    
-}
+    var newArray = [];
+    var found = false;
+       for( var i=0; i < arr1.length; i++){
+          found = false;
+          
+          for (var j=0; j< arr2.length; j++){
+              if(arr1[i] === arr2[j]){
+                found = true;
+              }
+          }
+          if(found === false){
+            newArray.push(arr1[i]);
+          }
+       }
+       return newArray;
+       
+  }
+  
+  function uniqueElements(arr1,arr2){
+     return [].concat(f(arr1,arr2),f(arr2,arr1));
+  }
 
 function runTest(i) {
-    if(i > inputs.length) throw new Error("You do not have enough test cases");
+    if (i > inputs.length) throw new Error("You do not have enough test cases");
     var expected = outputs[i];
-    var actual = f(inputs[i]);
+    var actual = uniqueElements(...inputs[i]);
     assert.deepEqual(actual, expected);
 }
 
 runTest(0);
-runTest(1);
-runTest(2);
-runTest(3);
-runTest(4);
 
diff --git a/problems/problem13.js b/problems/problem13.js
index 90669e3..920605f 100644
--- a/problems/problem13.js
+++ b/problems/problem13.js
@@ -1,12 +1,11 @@
 var assert = require('assert');
 
 // we need 5 test cases. 
-let inputs = [
-  
+let inputs = ["laval","radar","montreal","javascript","testing"
+
 ]
 
-let outputs = [
-  
+let outputs = [true,true,false,false,false
 ]
 
 /*
@@ -16,11 +15,20 @@ RADAR -> Yes
 JAVASCRIPT -> No
 */
 function f(str) {
-    
+    var reverse = "";
+    for (var i = str.length - 1; i >= 0; i--) {
+        reverse += str[i];
+    }
+    if (str === reverse) {
+        return true;
+    } else {
+        return false;
+    }
+
 }
 
 function runTest(i) {
-    if(i > inputs.length) throw new Error("You do not have enough test cases");
+    if (i > inputs.length) throw new Error("You do not have enough test cases");
     var expected = outputs[i];
     var actual = f(inputs[i]);
     assert.deepEqual(actual, expected);
diff --git a/problems/problem14.js b/problems/problem14.js
index eb49b73..a106288 100644
--- a/problems/problem14.js
+++ b/problems/problem14.js
@@ -31,7 +31,16 @@ Lorem ipsumos dolor sit amet consectetur
  even though there is a space before the a in adipisicing
 */
 function f(str) {
-    
+    var n = Math.floor(str.length / 40);
+    var newStr = str.split('');
+    for (var i = 1; i <= n; i++) {
+        if (newStr[i * 40] !== ' ') {
+            newStr.splice(i * 40, 0, '\n');
+
+        }
+        else if (newStr[i * 40] == ' ') { newStr.splice(i * 40, 1, '\n'); }
+    }
+    return newStr.join('');
 }
 
 function runTest(i) {
diff --git a/problems/problem2.js b/problems/problem2.js
index d54ae74..455205d 100644
--- a/problems/problem2.js
+++ b/problems/problem2.js
@@ -1,17 +1,17 @@
 var assert = require('assert');
 
 // we need 5 test cases.
-let inputs = [
+let inputs = ["hello","google","great","123",""]
 
-]
-
-let outputs = [
-  
-]
+let outputs = ["o","e","t","3",undefined]
 
 // Make this function return the last letter of the string that is passed to it. If the string does not have a last letter, return undefined
 function f(str) {
-    
+    if(str.length == 0){
+        return undefined;
+    }
+   return str[str.length - 1];
+
 }
 
 function runTest(i) {
diff --git a/problems/problem3.js b/problems/problem3.js
index 11358c6..2f06a09 100644
--- a/problems/problem3.js
+++ b/problems/problem3.js
@@ -1,20 +1,19 @@
-var assert = require('assert');
+const assert = require('assert');
 
 // we need 7 test cases. I've provided 2.
-let inputs = [
-  [2, 4],
-  [-3, 3]
-]
+  let inputs = [[2, 4], ["a","b"], [2,"a"],[-3,3],[4,5],[10,21],[3,4]]
 
-let outputs = [
-  6,
-  0
-]
+let outputs = [6,undefined,undefined,0,9,31,7]
 
 /*
 Make this function return the sum of the two numbers that are passed to it. If one of the numbers is not passed, or if anything other than numbers are passed, return undefined.
 */
-function f(x, y) {
+function f(array) {
+  var total = array[0] + array[1];
+  if( typeof total != 'number' ){
+    return undefined;
+  }
+  return total;
     
 }
 
diff --git a/problems/problem4.js b/problems/problem4.js
index 4082082..a0def0b 100644
--- a/problems/problem4.js
+++ b/problems/problem4.js
@@ -1,14 +1,26 @@
-var assert = require('assert');
+const assert = require('assert');
 
 // we need 8 test cases. I've provided the first 2
 let inputs = [
   ["hello", 4],
-  ["", 2]
+  ["hef", 2],
+  ["", 1],
+  ["absolutely", 0],
+  ["incredible", 3],
+  ["decodemtl", 5],
+  ["spotify", 2],
+  ["javascript", 2]
 ]
 
 let outputs = [
   "o",
-  undefined
+  "f",
+  undefined,
+  "a",
+  "r",
+  "e",
+  "o",
+  "v"
 ]
 
 /*
@@ -21,7 +33,10 @@ f("abc", 0); // a
 
 */
 function f(str, index) {
-    
+  if(str[index] == null){
+    return undefined;
+  }
+    return str[index];
 }
 
 function runTest(i) {
diff --git a/problems/problem5.js b/problems/problem5.js
index b1e2e44..6fa338c 100644
--- a/problems/problem5.js
+++ b/problems/problem5.js
@@ -1,19 +1,20 @@
 var assert = require('assert');
 
 // we need 5 test cases. 
-let inputs = [
-  [2, 7]
-]
+let inputs = [[2, 7], ["a","b"], [2,"a"],[-3,3],[4,5]]
 
-let outputs = [
-  14
-]
+let outputs = [14,undefined,undefined,-9,20]
 
 /*
 Make this function return the product of the two numbers that are passed to it. If one of the numbers is not passed, or if anything other than numbers are passed, return undefined.
 */
-function f(x, y) {
-    
+function f(array) {
+  var total = array[0] * array[1];
+  if(isNaN(total)){
+    return undefined;
+  }else{
+    return total;
+  }
 }
 
 function runTest(i) {
diff --git a/problems/problem6.js b/problems/problem6.js
index d31ae17..edb0d85 100644
--- a/problems/problem6.js
+++ b/problems/problem6.js
@@ -4,11 +4,20 @@ var assert = require('assert');
 // we need 6 test cases. 
 let inputs = [
   ["add", 10, 20],
-  ["chair", 20, 10]
+  ["chair", 20, 10],
+  ["mult",23,120],
+  ["derp",23,120],
+  ["add",23,120],
+  ["div",120,120]
 ]
 
 let outputs = [
-  30
+  30,
+  undefined,
+  2760,
+  undefined,
+  143,
+  undefined
 ]
 
 /*
@@ -22,13 +31,19 @@ f("spoof", 10, 10); // undefined
 
 */
 function f(operation, firstArgument, secondArgument) {
-    
+    if (operation == "add"){
+      return firstArgument + secondArgument;
+    }else if (operation == "mult"){
+      return firstArgument * secondArgument;
+    }else{
+      return undefined;
+    }
 }
 
 function runTest(i) {
     if(i > inputs.length) throw new Error("You do not have enough test cases");
     var expected = outputs[i];
-    var actual = f(inputs[i]);
+    var actual = f(...inputs[i]);
     assert.deepEqual(actual, expected);
 }
 
@@ -37,4 +52,4 @@ runTest(1);
 runTest(2);
 runTest(3);
 runTest(4);
-runTest(5);
+runTest(5);
\ No newline at end of file
diff --git a/problems/problem7.js b/problems/problem7.js
index c3bf4b1..a8a5636 100644
--- a/problems/problem7.js
+++ b/problems/problem7.js
@@ -2,11 +2,23 @@ var assert = require('assert');
 
 // we need 7 test cases. 
 let inputs = [
-  
+    ["foo", 3],
+    ["fo", 3],
+    ["foo", -1],
+    ["bar", -1],
+    ["lel", 3],
+    ["hue", 3],
+    ["fa", 3],
 ]
 
 let outputs = [
-  
+    "foofoofoo",
+    "fofofo",
+    "",
+    "",
+    "lellellel",
+    "huehuehue",
+    "fafafa"
 ]
 
 /*
@@ -15,16 +27,24 @@ If a negative number or zero is specified, return an empty string. If any invali
 
 For example:
 
-f("foo", 3) // "foofoofoo"
+f("foo", 3) //  "foofoofoo"
 f("fo", 3) // "fofofo"
 f("foo", -1) // undefined
 */
-function f(str, n) {
-    
+function f(array) {
+    var append = "";
+    if (array[1] < 0 || array[1] == 0) {
+        return "";
+    } else {
+        for (var i = 0; i < array[1]; i++) {
+            append = append + array[0];
+        }
+    }
+    return append;
 }
 
 function runTest(i) {
-    if(i > inputs.length) throw new Error("You do not have enough test cases");
+    if (i > inputs.length) throw new Error("You do not have enough test cases");
     var expected = outputs[i];
     var actual = f(inputs[i]);
     assert.deepEqual(actual, expected);
diff --git a/problems/problem8.js b/problems/problem8.js
index 6165932..64acd11 100644
--- a/problems/problem8.js
+++ b/problems/problem8.js
@@ -1,24 +1,23 @@
 var assert = require('assert');
 
 // we need 5 test cases. 
-let inputs = [
-  
-]
+let inputs = ["hello", "hello world", "What's up", "How are you", "Goodbye"]
 
-let outputs = [
-  
-]
+let outputs = ["olleh","dlrow olleh","pu s'tahW","uoy era woH","eybdooG"]
 
 /*
 Make this function return the input string, reversed. For example "hello" would return "olleh" and "how are you" would return "uoy era woh".
 You must use a for loop for this exercise.
 */
 function f(str) {
-    
+    var reverse = "";
+    for (var i = str.length - 1; i >= 0; i--)
+        reverse += str[i];
+    return reverse;
 }
 
 function runTest(i) {
-    if(i > inputs.length) throw new Error("You do not have enough test cases");
+    if (i > inputs.length) throw new Error("You do not have enough test cases");
     var expected = outputs[i];
     var actual = f(inputs[i]);
     assert.deepEqual(actual, expected);
diff --git a/problems/problem9.js b/problems/problem9.js
index 5c52ef5..0e806bd 100644
--- a/problems/problem9.js
+++ b/problems/problem9.js
@@ -1,12 +1,9 @@
 var assert = require('assert');
 
 // we need 5 test cases. 
-let inputs = [
-  
-]
+let inputs = ["testing this", "will it work", "we shall find out", "looks like it works", ""]
 
-let outputs = [
-  
+let outputs = ["testing","work","shall","works",""
 ]
 
 /*
@@ -14,11 +11,21 @@ Make this function return the longest word in the input string. If the input str
 If multiple words have the same length, return the last one that matches.
 */
 function f(str) {
-    
+    var split = str.split(" ");
+    var longestWord = "";
+    if (split == "") {
+        return "";
+    }
+    for (var i = 0; i < split.length; i++) {
+        if (split[i].length >= longestWord.length) {
+            longestWord = split[i];
+        }
+    }
+    return longestWord;
 }
 
 function runTest(i) {
-    if(i > inputs.length) throw new Error("You do not have enough test cases");
+    if (i > inputs.length) throw new Error("You do not have enough test cases");
     var expected = outputs[i];
     var actual = f(inputs[i]);
     assert.deepEqual(actual, expected);