commit all easy implementation

Author: codeWithAimeric

2DArrayDS.js

@@ -16,4 +16,4 @@ function hourglassSum(arr) {
         }
     }
     return Math.max(...resTab);
-}
+}

acmIcpcTeam.js

@@ -0,0 +1,44 @@
+/*
+ * Complete the 'acmTeam' function below.
+ *
+ * The function is expected to return an INTEGER_ARRAY.
+ * The function accepts STRING_ARRAY topic as parameter.
+ */
+
+function acmTeam(topic) {
+    // Write your code here
+    let tempTopic1 = '';
+    let tempTopic2 = '';
+    let count = 0;
+    let valMax = 0;
+    let countMax = 0;
+    let resTab = [];
+    for(let i=0; i<topic.length-1; i++){
+        for(let j=i+1; j<topic.length; j++){
+            tempTopic1 = topic[i];
+            tempTopic2 = topic[j];
+            for(let k=0; k<tempTopic1.length; k++){
+                if(tempTopic1[k] == 0 && tempTopic2[k] == 0){
+                    continue;
+                }else{
+                    count++;
+                }
+            }
+            if(count > valMax){
+                valMax = count;
+                countMax=1;
+            }else if(count == valMax){
+                countMax++
+            }
+            count = 0; 
+        }
+    }
+    resTab.push(valMax);
+    resTab.push(countMax);
+    return resTab;
+}
+
+// let topics = ['10101', '11110', '00010'];
+// let topics = ['10101', '11100', '11010', '00101'];
+let topics = ['11101', '10101', '11001', '10111', '10000', '01110'];
+console.log(acmTeam(topics));

appendAndDelete.js

@@ -0,0 +1,34 @@
+/*
+ * Complete the 'appendAndDelete' function below.
+ *
+ * The function is expected to return a STRING.
+ * The function accepts following parameters:
+ *  1. STRING s
+ *  2. STRING t
+ *  3. INTEGER k
+ */
+
+function appendAndDelete(s, t, k) {
+    // Write your code here
+    let sArr = s.split("");
+    let tArr = t.split("");
+    let count = 0;
+    for (let i = 0; i === count && i < s.length; i++) {
+        if (sArr[i] === tArr[i]) {
+            count++;
+        }
+    }
+
+    let tMinusCount = t.length - count;
+    let sMinusCount = s.length - count;
+
+    let STK = k - (tMinusCount + sMinusCount);
+
+    if (tMinusCount + sMinusCount < k && t.length + s.length > k && STK % 2 !== 0) {
+        return "No";
+    } else if (tMinusCount + sMinusCount <= k) {
+        return "Yes";
+    } else {
+        return "No";
+    }
+}

backUp.js

@@ -26,4 +26,8 @@ var unique = a.filter(onlyUnique);
 let a = 12;
 let aReverseString = a.toString().split("").reverse().join("");
 //transform this string into number
-let aNumber = Number(a);
+let aNumber = Number(a);
+
+//count number of occurence in a string 
+console.log(("str1,str2,str3,str4".match(/,/g) || []).length); //logs 3
+console.log(("str1,str2,str3,str4".match(new RegExp("str", "g")) || []).length); //logs 4

beautifulTriplets.js

@@ -0,0 +1,46 @@
+/*
+ * Complete the 'beautifulTriplets' function below.
+ *
+ * The function is expected to return an INTEGER.
+ * The function accepts following parameters:
+ *  1. INTEGER d
+ *  2. INTEGER_ARRAY arr
+ */
+
+function beautifulTriplets(d, arr) {
+    // Write your code here
+    let count = arr[0];
+    let max = arr[arr.length - 1];
+    let result = 0;
+  
+    let { values } = new Array(arr.length).fill(0).reduce(
+      (target, item, index) => {
+        target["values"][arr[index]] = target["values"][arr[index]]
+          ? (target["values"][arr[index]] += 1)
+          : 1;
+  
+        return target;
+      },
+      { values: {} }
+    );
+  
+    while (count <= max) {
+      values[count] &&
+        values[count + d] &&
+        values[count + d * 2] &&
+        (result += Math.max(
+          values[count],
+          values[count + d],
+          values[count + d * 2]
+        ));
+  
+      count++;
+    }
+  
+    return result;
+}
+
+
+let d=3;
+let arr=[1, 2, 4, 5, 7, 8, 10];//3
+console.log(beautifulTriplets(d, arr));

cavityMap.js

@@ -0,0 +1,40 @@
+/*
+ * Complete the 'cavityMap' function below.
+ *
+ * The function is expected to return a STRING_ARRAY.
+ * The function accepts STRING_ARRAY grid as parameter.
+ */
+
+function cavityMap(grid) {
+    // Write your code here
+    const cavities = grid.map(item => item.split(''));
+
+    return cavities.reduce((target, list, index, source) => {
+      const result = list
+        .reduce((listTarget, item, itemIndex) => {
+          listTarget.push(
+            index >= 1 &&
+              itemIndex >= 1 &&
+              index < source.length - 1 &&
+              itemIndex < list.length &&
+              item > source[index][itemIndex - 1] &&
+              item > source[index][itemIndex + 1] &&
+              item > source[index - 1][itemIndex] &&
+              item > source[index + 1][itemIndex]
+              ? 'X'
+              : item
+          );
+  
+          return listTarget;
+        }, [])
+        .join('');
+  
+      target.push(result);
+  
+      return target;
+    }, []);
+}
+
+let grid = ['989', '191', '111']; //[ '989', '1X1', '111' ]
+console.log(cavityMap(grid));
+

chocolateFeast.js

@@ -0,0 +1,36 @@
+/*
+ * Complete the 'chocolateFeast' function below.
+ *
+ * The function is expected to return an INTEGER.
+ * The function accepts following parameters:
+ *  1. INTEGER n
+ *  2. INTEGER c
+ *  3. INTEGER m
+ */
+
+function chocolateFeast(n, c, m) {
+    // Write your code here
+    let res = 0;
+    let div = 0;
+    let mod = 0;
+    let temp = 0;
+    let result = 0;
+    res = Math.floor(n/c);
+    div = Math.floor(res/m);
+    mod = res%m;
+    result = res + div;
+    temp = div + mod; 
+    while (temp >= m) {
+        res = temp; 
+        div = Math.floor(res/m);
+        mod = res %m;
+        result += div;
+        temp = div +mod;
+    }
+    return result; 
+}
+
+let n = 15;
+let c = 3; 
+let m = 2;
+console.log(chocolateFeast(n, c, m)); //9

cutTheSticks.js

@@ -0,0 +1,29 @@
+/*
+ * Complete the 'cutTheSticks' function below.
+ *
+ * The function is expected to return an INTEGER_ARRAY.
+ * The function accepts INTEGER_ARRAY arr as parameter.
+ */
+
+function cutTheSticks(arr) {
+    // Write your code here
+    let resTab = [];
+    let minVal = 0;
+    console.log(arr);
+    resTab.push(arr.length);
+    while(arr.length > 1){
+        minVal = Math.min(...arr);
+        for(let i=arr.length-1; i>=0; i--){
+            arr[i] -= minVal;
+            if(arr[i] == 0){
+                arr.splice(i, 1);
+            }
+        }
+        if(arr.length>0){
+            resTab.push(arr.length);
+        }
+    }
+    return resTab;
+}
+
+

equalizeTheArray.js

@@ -0,0 +1,41 @@
+/*
+ * Complete the 'equalizeArray' function below.
+ *
+ * The function is expected to return an INTEGER.
+ * The function accepts INTEGER_ARRAY arr as parameter.
+ */
+
+function equalizeArray(arr) {
+    // Write your code here
+    let count = 0;
+    let maxVal = 0;
+    let tempVal = 0;
+    let valDuplicate = 0;
+    let countOperation = 0;
+    for(let i=0; i<arr.length-1; i++){
+        for(let j=0; j<arr.length; j++){
+            if(arr[i] == arr[j]){
+                count++;
+                tempVal = arr[i];
+            }
+        }
+        if(count > maxVal){
+            maxVal = count;
+            valDuplicate = tempVal;
+        }
+        count = 0;
+    }
+   
+    for(let j=0; j<arr.length; j++){
+        if(arr[j] != valDuplicate){
+            countOperation++;
+        }
+    }
+    return countOperation; 
+}
+
+let arr = [1, 2, 3, 1, 2, 3, 3, 3];//4
+// let arr = [3, 3, 2, 1, 3, 3];//2
+// let arr = [36 ,12 ,60 ,99, 78 ,33 ,4 ,21 ,22 ,9 ,12 ,21 ,34 ,76, 21, 3, 3, 37, 65, 27 ,21 ,42 ,11 ,14 ,21 ,88 ,46 ,63 ,79 ,6 ,3,7 ,94, 99 ,68 ,76, 6, 21 ,86, 49,56, 22, 90, 74, 83, 20, 21, 94, 60, 76, 75, 96, 99, 92, 65, 77, 26, 51, 21, 77, 22, 97, 34, 56];
+console.log(equalizeArray(arr));
+

fairRotations.js

@@ -0,0 +1,20 @@
+/*
+ * Complete the 'fairRations' function below.
+ *
+ * The function is expected to return a STRING.
+ * The function accepts INTEGER_ARRAY B as parameter.
+ */
+
+function fairRations(B) {
+    // Write your code here
+    let count = new Array(B.length - 1).fill(0).reduce((target, item, index) => {
+        !!(B[index] % 2) && (B[index + 1]++, (target += 2));
+    
+        return target;
+    }, 0);
+    
+    return !(B[B.length - 1] % 2) ? count : "NO";
+}
+
+B = [2, 3, 4, 5, 6]   
+console.log(fairRations(B));

flatlandSpaceStations.js

@@ -0,0 +1,26 @@
+// Complete the flatlandSpaceStations function below.
+function flatlandSpaceStations(n, c) {
+    let resMin = 0; 
+    let resTab = [];
+    let distance = 0;
+    let tempTab = [];
+    if(c.length == n){
+        return 0;
+    }
+    for(let i=0; i<n; i++){
+        if(c.includes(i)) continue; 
+        for(let j=0; j<c.length; j++){
+            distance = Math.abs(c[j] - i);
+            tempTab.push(distance);
+        }
+        resMin = Math.min(...tempTab);
+        resTab.push(resMin);
+        tempTab = [];
+    }
+    
+    return Math.max(...resTab);
+}
+
+let n=20;
+let c = [13, 1, 11, 10, 6];//6
+console.log(flatlandSpaceStations(n, c));

halloweenSale.js

@@ -0,0 +1,29 @@
+/*
+ * Complete the 'howManyGames' function below.
+ *
+ * The function is expected to return an INTEGER.
+ * The function accepts following parameters:
+ *  1. INTEGER p
+ *  2. INTEGER d
+ *  3. INTEGER m
+ *  4. INTEGER s
+ */
+
+function howManyGames(p, d, m, s) {
+    // Return the number of games you can buy
+    if (s < p) return 0;
+    
+    let sum = p;
+    let itemsCount = 0;
+    while(sum <= s) {
+        p = Math.max(p-d, m)
+        sum += p;
+        itemsCount++;    
+    }
+    
+    return itemsCount;
+}
+
+// let p=16; let d=2; let m=1; let s=9981; //9917
+let p=1; let d=100; let m=1; let s=9777; //9777
+console.log(howManyGames(p, d, m, s));