Merge branch 'master' of https://github.com/emon535/HackerRank

Author: emon535

Algorithm/Graph/problem.js

@@ -0,0 +1,14 @@
+
+function findCapitalCity(robber_distance, cityNodes, cityFrom, cityTo, cityWeight) {
+    let graph = Array(cityNodes).fill(null).map(()=>Array(cityNodes).fill(null));
+        
+    const points = cityFrom.map(function(cityFromValue, index) {
+        graph[cityFromValue][cityTo[index]] = cityWeight[index];
+        console.log("to=>",cityFromValue,"from=>",cityTo[index]); 
+        
+        // graph[cityTo[index]][cityFromValue] = cityWeight[index];
+        // return [cityFrom, cityTo[index]];
+    });
+
+    console.log(graph,points);
+}

Algorithm/Sort/HeapSort.js

@@ -0,0 +1,48 @@
+var array_length;
+/* to create MAX  array */
+function heap_root(input, i) {
+    var left = 2 * i + 1;
+    var right = 2 * i + 2;
+    var max = i;
+
+    if (left < array_length && input[left] > input[max]) {
+        max = left;
+    }
+
+    if (right < array_length && input[right] > input[max]) {
+        max = right;
+    }
+
+    if (max != i) {
+        swap(input, i, max);
+        heap_root(input, max);
+    }
+}
+
+function swap(input, index_A, index_B) {
+    var temp = input[index_A];
+
+    input[index_A] = input[index_B];
+    input[index_B] = temp;
+}
+
+function heapSort(input) {
+
+    array_length = input.length;
+
+    for (var i = Math.floor(array_length / 2); i >= 0; i -= 1) {
+        heap_root(input, i);
+    }
+
+    for (i = input.length - 1; i > 0; i--) {
+        swap(input, 0, i);
+        array_length--;
+
+
+        heap_root(input, 0);
+    }
+}
+
+var arr = [3, 0, 2, 5, -1, 4, 1];
+heapSort(arr);
+console.log(arr);

Algorithm/Sort/MergeSort.js

@@ -0,0 +1,34 @@
+let merge = (left, right) => {
+    let result = [],
+        leftlen = left.length,
+        rightlen = right.length,
+        l = 0,
+        r = 0;
+
+    while (1 < leftlen && r < rightlen) {
+        if (left[l] < right[r]) {
+            result.push(left[l]);
+            l++;
+        }
+        else {
+            result.push(right[r])
+            r++;
+        }
+        return result.concat(left.slice(l)).concat(right.slice(r));
+    }
+}
+
+let mergeSort = (arr) => {
+    let length = arr.length;
+    if (length < 2) {
+        return arr;
+    }
+
+    let mid = Math.floor(length / 2),
+        left = arr.slice(0, mid),
+        right = arr.slice(mid)
+
+    return merge(mergeSort(left), mergeSort(right));
+};
+
+console.log("Merge and Sorted;", mergeSort([9, 3, 1, 6, 4, 110, 8, 110, 82]))

Algorithm/Sort/QuickSort.js

@@ -0,0 +1,28 @@
+// https://www.youtube.com/watch?v=7h1s2SojIRw
+
+let swap = (arr, i, j) => {
+    let tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+};
+
+let partition = (arr, low, high) => {
+    let q = low, i;
+    for (i = low; i < high; i++) {
+        if (arr[i] < arr[high]) {
+            swap(arr, i, q);
+            q++;
+        }
+    }
+    swap(arr, i, q);
+    return q;
+};
+
+let quickSort = (arr, low, high) => {
+    if (low < high) {
+        let pivot = partition(arr, low, high);
+        quickSort(arr, low, pivot - 1);
+        quickSort(arr, pivot + 1, high);
+        return arr;
+    }
+};

Codewars/AbbrevName.js

@@ -0,0 +1,5 @@
+// https://www.codewars.com/kata/abbreviate-a-two-word-name/javascript
+
+function abbrevName(name) {
+    return name.split(' ').map(x => x.substr(0, 1).toUpperCase()).join('.');
+}

Codewars/CountingDuplicates.js

@@ -0,0 +1,21 @@
+
+// https://www.codewars.com/kata/counting-duplicates/train/javascript
+
+function duplicateCount(text) {
+    //...
+    text = text.split("").map(v => v.toLowerCase());;
+    var mapA = text.reduce(function (prev, cur) {
+        prev[cur] = (prev[cur] || 0) + 1;
+        return prev;
+    }, {});
+
+    let count = 0;
+
+    for (key in mapA) {
+        if (mapA[key] > 1) {
+            count++;
+        }
+    }
+
+    return count;
+}

Codewars/camelCaseMethod.js

@@ -0,0 +1,13 @@
+String.prototype.camelCase = function () {
+    //your code here
+    let str = this.valueOf().split(" ").filter(value => {
+        return Boolean(value);
+    }).map(value => {
+        return value.charAt(0).toUpperCase() + value.slice(1);
+    }).join("");
+
+
+
+    console.log(str)
+    return str;
+}

Codewars/playingWithDigits.js

@@ -0,0 +1,24 @@
+
+// https://www.codewars.com/kata/playing-with-digits/train/javascript
+
+function digPow(n, p) {
+    // ...
+    let arrN = []
+    let checkIntTypeRegex = /^-?[0-9]+$/;
+
+    arrN = n.toString().split("");
+    let val = 0;
+
+
+    arrN.forEach((item, index) => {
+        console.log(p);
+        val += Math.pow(item, p)
+        console.log(val);
+        p++;
+    })
+
+    return er.test(val / n) ? val / n : -1
+
+    // Alternative Solutions:
+    // var  x = arrN.reduce((sum, value, index)=>sum+Math.pow(value. p+index), 0);
+}

Codewars/trippleDouble.js

@@ -0,0 +1,26 @@
+
+//https://www.codewars.com/kata/triple-trouble-1/train/javascript
+
+function tripledouble(num1, num2) {
+    //code me
+    let result = [];
+    let regex = /(\w)\1{2,}/g;
+    let matches = num1.toString().match(regex);
+    if (matches) {
+        result = matches.map(eachMatch => {
+            let repeated = eachMatch.toString().split("").slice(0, 2).join("");
+            let re = new RegExp(repeated, "g");
+
+            console.log("num1 = ", num1, "num2 =", num2, "match", eachMatch, "repeated", repeated, "pattern", re);
+            if (re.test(num2)) {
+                console.log("check=>", num2, "with", re);
+                return 1;
+
+            }
+        })
+    }
+
+    result = result.filter(Boolean);
+    if (result.length == 0) return 0
+    else return 1;
+}

HackerRank/Algorithms/CompareTheTriplate.js

@@ -0,0 +1,19 @@
+
+// Complete the compareTriplets function below.
+function compareTriplets(a, b) {
+
+    let result = []
+    let alice = 0;
+    let bob = 0;
+
+    a.forEach((aVal, index) => {
+        console.log(aVal, b[index])
+        if (aVal > b[index]) {
+            alice++;
+        } else if (aVal < b[index]) {
+
+            bob++;
+        }
+    })
+    return [alice, bob]
+}