Sev pol

codewars/Adding Big Numbers/AddingBigNumbers.js

@@ -0,0 +1,15 @@
+function add(a, b) {
+    while (a.length < b.length) a = '0' + a;
+    while (b.length < a.length) b = '0' + b;
+    let c = 0;
+    let d = '';
+    for (let i = a.length - 1; i >= 0; i--) {
+        let sum = Number(a[i]) + Number(b[i]) + c;
+        c = Math.floor(sum / 10);
+        d = (sum % 10) + d;
+    }
+    if (c > 0) {
+        d = c + d;
+    }
+    return d;
+}

codewars/Array Deep Count/ArrayDeepCount.js

@@ -0,0 +1,13 @@
+function deepCount(a) {
+    let b = 0;
+    function Counter(c) {
+        for(let i of c) {
+            b++;
+            if (Array.isArray(i)) {
+                Counter(i);
+            }
+        }
+    }
+    Counter(a);
+    return b;
+}

codewars/Build Tower/BuildTower.ts

@@ -0,0 +1,9 @@
+export const towerBuilder = (nFloors: number): string[] => {
+    let a: string[] = [];
+    for (let i: number = 0; i < nFloors; i++) {
+        let b: string = ' '.repeat(nFloors-i-1);
+        let c: string = '*'.repeat(2*i+1);
+        a.push(b+c+b);
+    }
+    return a;
+}

codewars/Convert string to camel case/ConvertStringToCamelCase.ts

@@ -0,0 +1,7 @@
+export function toCamelCase(str: string): string {
+    let a: string[] = str.split(/[_-]/);
+    for (let i: number = 1; i<a.length; i++) {
+        a[i] = a[i][0].toUpperCase() + a[i].slice(1);
+    }
+    return a.join('');
+}

codewars/Duplicate Encoder/DuplicateEncoder.ts

@@ -0,0 +1,12 @@
+export function duplicateEncode(word: string): string {
+    let a: string = "";
+    word = word.toLowerCase();
+    for (let i of word) {
+        if (word.split(i).length>2) {
+            a += ")"
+        } else {
+            a += "("
+        }
+    }
+    return a;
+}

codewars/Find the missing letter/FindTheMissingLetter.ts

@@ -0,0 +1,7 @@
+export function findMissingLetter(array: string[]): string | void {
+    for (let i in array) {
+        if (array[i].charCodeAt(0)+1 !== array[Number(i)+1].charCodeAt(0)) {
+            return String.fromCharCode(array[i].charCodeAt(0)+1)
+        }
+    }
+}

codewars/Flatten a Nested Map/FlatterANestedMap.js

@@ -0,0 +1,15 @@
+function flattenMap(map) {
+    function remake(obj, key, res) {
+        for (let k in obj) {
+            let newKey =  key ? `${key}/${k}` : k;
+            if (typeof obj[k] === 'object' && obj[k] !== null && !Array.isArray(obj[k])) {
+                remake(obj[k], newKey, res);
+            } else {
+                a[newKey] = obj[k];
+            }
+        }
+    }
+    let a = {};
+    remake(map, '', a);
+    return a;
+}

codewars/Fun with tree - max sum/FunWithTree_MaxSum.js

@@ -0,0 +1,27 @@
+class TreeNode {
+    constructor(value, left = null, right = null) {
+        this.value = value;
+        this.left = left;
+        this.right = right;
+    }
+}
+
+function maxSum(root) {
+    if (root === null) {
+        return 0;
+    }
+    function findMaxSum(node) {
+        if (node.left === null && node.right === null) {
+            return node.value;
+        }
+        let maxSum = -Infinity;
+        if (node.left !== null) {
+            maxSum = Math.max(maxSum, findMaxSum(node.left));
+        }
+        if (node.right !== null) {
+            maxSum = Math.max(maxSum, findMaxSum(node.right));
+        }
+        return node.value + maxSum;
+    }
+    return findMaxSum(root)
+}

codewars/Merge two arrays/MergeTwoArrays.js

@@ -0,0 +1,13 @@
+function mergeArrays(a, b) {
+    c = [];
+    max = a.length>b.length ? a.length : b.length;
+    for (let i = 0; i<max; i++) {
+        if (a[i] !== undefined) {
+            c.push(a[i]);
+        }
+        if (b[i] !== undefined) {
+            c.push(b[i]);
+        }
+    }
+    return c;
+}

codewars/Moving Zeros To The End/MovingZerosToTheEnd.js

@@ -0,0 +1,13 @@
+function moveZeros(arr) {
+    let a = [];
+    let count = 0;
+    for (let i of arr) {
+        if (i !== 0) {
+            a.push(i);
+        } else {
+            count += 1;
+        }
+    }
+    a.push(...new Array(count).fill(0));
+    return a;
+}

codewars/Permutations/SoManyPermutations.js

@@ -0,0 +1,20 @@
+function permutations(string) {
+    function perm(arr, n, res) {
+        if (n === 1) {
+            res.add(arr.join(''));
+        } else {
+            for (let i = 0; i < n; i++) {
+                perm(arr, n - 1, res);
+                if (n % 2 === 0) {
+                    [arr[i], arr[n - 1]] = [arr[n - 1], arr[i]];
+                } else {
+                    [arr[0], arr[n - 1]] = [arr[n - 1], arr[0]];
+                }
+            }
+        }
+    }
+    let a = new Set();
+    let b = string.split('');
+    perm(b, b.length, a);
+    return Array.from(a);
+}

codewars/Product of consecutive Fib numbers/ProductOfConsecutiveFibNumbers.ts

@@ -0,0 +1,10 @@
+export const productFib = (prod: number): [number, number, boolean] => {
+    let a: number = 0;
+    let b: number = 1;
+    while (a*b < prod) {
+        let c: number = a + b;
+        a = b;
+        b = c;
+    }
+    return [a, b, a*b === prod];
+}

codewars/Sum of Digits - Digital Root/SumOfDigits_DigitalRoot.ts

@@ -0,0 +1,10 @@
+export const digitalRoot = (n: number): number => {
+    while (n>9) {
+        let a: string = n.toString();
+        n = 0;
+        for (let i of a) {
+            n += Number(i);
+        }
+    }
+    return n;
+};

codewars/Sum of pairs/SumOfPairs.ts

@@ -0,0 +1,12 @@
+export function sumPairs(ints: number[], s: number): [number, number] | void {
+    const a = new Map<number, number>();
+    for (let i: number = 0; i < ints.length; i++) {
+        const n: number = ints[i];
+        const c: number = s - n;
+        if (a.has(c)) {
+            return [c, n];
+        }
+        a.set(n, i);
+    }
+    return undefined;
+}

codewars/Valid Parentheses/ValidParentheses(retired).js

@@ -0,0 +1,14 @@
+function validParentheses(parens) {
+    let a = 0;
+    for(let i of parens) {
+        if (i === '(') {
+            a++;
+        } else if (i===')') {
+            a--;
+            if (a<0) {
+                return false;
+            }
+        }
+    }
+    return a === 0;
+}

codewars/Where my anagrams at/WhereMyAnagramsAt(retired).js

@@ -0,0 +1,4 @@
+function anagrams(word, words) {
+    let a = word.split('').sort().join('');
+    return words.filter(w => w.split('').sort().join('') === a);
+}