codewars, math function, class + tests

codewars/Adding Big Numbers/add.js

@@ -0,0 +1,14 @@
+function add(a, b) {
+    let result = "";
+    let value = 0;
+    a = a.split("");
+    b = b.split("");
+
+    while (a.length || b.length || value) {
+      value += ~~a.pop() + ~~b.pop();
+      result = (value % 10) + result;
+      value = value > 9;
+    }
+
+    return result;
+  }

codewars/Anagram difference/anagram.js

@@ -0,0 +1,30 @@
+function anagramDifference(first, second) {
+    if (first === "" && second === "") {
+      return 0;
+    } else if (first === "" || second === "") {
+      if (first === "") {
+        return second.length;
+      } else {
+        return first.length;
+      }
+    }
+    let сount = {};
+    if (first !== "" && second !== "") {
+      for (let letter of first) {
+        сount[letter] = (сount[letter] ?? 0) + 1;
+      }
+
+      for (let letter of second) {
+        if (сount[letter]) {
+          сount[letter] -= 1;
+        } else {
+          сount[letter] = -1;
+        }
+      }
+    }
+    let remove = 0;
+    for (let count of Object.values(сount)) {
+      remove += Math.abs(count);
+    }
+    return remove;
+  } 

codewars/Array Deep Count/deepcount.js

@@ -0,0 +1,11 @@
+function deepCount(array) {
+    let sum = 0;
+
+    for (let i of array) {
+      sum += 1;
+      if (Array.isArray(i)) {
+        sum += deepCount(i);
+      }
+    }
+    return sum;
+  } 

codewars/Build Tower/buildtower.js

@@ -0,0 +1,12 @@
+function towerBuilder(numOfFloors) {
+    const tower = [];
+    for (let floor = 0; floor < numOfFloors; floor++) {
+      const numOfStars = 2 * floor + 1;
+      const numOfSpaces = numOfFloors - floor - 1;
+      const stars = '*'.repeat(numOfStars);
+      const spaces = ' '.repeat(numOfSpaces);
+      const floorString = spaces + stars + spaces;
+      tower.push(floorString);
+    }
+    return tower;
+  }

codewars/Convert string to camel case/camelcase.js

@@ -0,0 +1,15 @@
+function toCamelCase(str) {
+    if (str.length === 0) {
+      return str;
+    }
+    const arr = str.split(/[-_]/);
+
+    const newArr = arr.map((word, index) => {
+      if (index === 0) {
+        return word[0] + word.substr(1).toLowerCase();
+      } else {
+        return word.substr(0, 1).toUpperCase() + word.substr(1).toLowerCase();
+      }
+    });
+    return newArr.join("");
+  } 

codewars/Duplicate Encoder/dublicate.js

@@ -0,0 +1,13 @@
+function duplicateEncode(word) {
+    word = word.toLowerCase();
+    const count = {};
+    for (const char of word) {
+      count[char] = (count[char] ?? 0) + 1;
+    }
+
+    let brackets = "";
+    for (const char of word) {
+      brackets += count[char] === 1 ? "(" : ")";
+    }
+    return brackets;
+  } 

codewars/Find the missing letter/missingletter.js

@@ -0,0 +1,9 @@
+function findMissingLetter(array) {
+    for (let i = 0; i < array.length - 1; i++) {
+      const icode = array[i].charCodeAt(0);
+      const inextcode = array[i + 1].charCodeAt(0);
+      if (inextcode !== icode + 1) {
+        return String.fromCharCode(icode + 1);
+      }
+    }
+  } 

codewars/Flatten a Nested Map/map.js

@@ -0,0 +1,24 @@
+function flattenMap(input) {
+    const result = {};
+
+    function flatten(current, prefix) {
+      for (const [key, value] of Object.entries(current)) {
+        const newKey = prefix ? `${prefix}/${key}` : key; 
+
+        if (
+          value !== null &&
+          typeof value === "object" &&
+          !Array.isArray(value) &&
+          typeof value !== "function"
+        ) {
+          flatten(value, newKey);
+        } else {
+          result[newKey] = value;
+        }
+      }
+    }
+
+    flatten(input, "");
+
+    return result;
+  } 

codewars/Fun with tree - max sum/.gitkeep

@@ -1 +0,0 @@
-

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

@@ -0,0 +1,18 @@
+function maxSum(root) {
+    if (root === null) {
+      return 0; 
+    }
+    function dfs(node) {
+      if (node === null) {
+        return Number.NEGATIVE_INFINITY; 
+      }
+      if (node.left === null && node.right === null) {
+        return node.value;
+      }
+      const leftSum = dfs(node.left);
+      const rightSum = dfs(node.right);
+      return node.value + Math.max(leftSum, rightSum);
+    }
+
+    return dfs(root);
+  }

codewars/Linked Lists - Sorted Insert/linkedlist.js

@@ -0,0 +1,19 @@
+function Node(data) {
+    this.data = data;
+    this.next = null;
+  }
+
+  function sortedInsert(head, data) {
+    const newNode = new Node(data);
+    if (!head || data < head.data) {
+      newNode.next = head;
+      return newNode;
+    }
+    let current = head;
+    while (current.next && current.next.data < data) {
+      current = current.next;
+    }
+    newNode.next = current.next;
+    current.next = newNode;
+    return head;
+  }

codewars/Merge two arrays/merge2arrays.js

@@ -0,0 +1,12 @@
+function mergeArrays(a, b) {
+    let result = [];
+    let i = 0;
+    let j = 0;
+
+    while (i < a.length || j < b.length) {
+      if (i < a.length) result.push(a[i++]);
+      if (j < b.length) result.push(b[j++]);
+    }
+
+    return result;
+  }

codewars/Moving Zeros To The End/movingzeros.js

@@ -0,0 +1,14 @@
+function moveZeros(arr) {
+    const zeros = [];
+    const noZeros = [];
+
+    for (let i = 0; i < arr.length; i++) {
+      if (arr[i] === 0) {
+        zeros.push(arr[i]);
+      } else {
+        noZeros.push(arr[i]);
+      }
+    }
+    zeros.forEach(zero => noZeros.push(zero));
+    return noZeros;
+  } 

codewars/Permutations/permutations.js

@@ -0,0 +1,18 @@
+function permutations(string) {
+    if (string.length <= 1) {
+      return [string];
+    }
+    let shufflings = [];
+    for (let i = 0; i < string.length; i++) {
+      let char = string[i];
+      if (string.indexOf(char) != i) {
+        continue;
+      }
+      let remainingStr = string.slice(0, i) + string.slice(i + 1);
+      for (let permutation of permutations(remainingStr)) {
+        shufflings.push(char + permutation);
+      }
+    }
+
+    return [...new Set(shufflings)];
+  }

codewars/Product of consecutive Fib numbers/productfib.js

@@ -0,0 +1,10 @@
+function productFib(prod) {
+    let first = 1;
+    let second = 1;
+    while (first * second < prod) {
+      let x = second;
+      second += first;
+      first = x;
+    }
+    return [first, second, first * second === prod];
+  } 

codewars/Simple Pig Latin/piglatin.js

@@ -0,0 +1,22 @@
+function pigIt(str) {
+    str = str.split(" ");
+    let ayLetters = "ay";
+    let result = [];
+
+    for (let word of str) {
+      if (word === "!" || word === "?") {
+        result.push(word);
+        break;
+      }
+      word = word.split("");
+      let firstLetter = word.splice(0, 1)[0];
+      word.push(firstLetter, ayLetters);
+      let pigIt = "";
+      for (let char of word) {
+        pigIt += char;
+      }
+      result.push(pigIt);
+    }
+    let newStr = result.join(" ");
+    return newStr.trimEnd();
+  } 

codewars/Snail/snail.js

@@ -0,0 +1,36 @@
+snail = function (array) {
+    if (array.length === 0) {
+      return [];
+    }
+    let bottom = 0;
+    let top = array.length - 1;
+    let left = 0;
+    let right = array[0].length - 1;
+    let arranged = [];
+
+    while (bottom <= top && left <= right) {
+      for (let i = left; i <= right; i++) {
+        arranged.push(array[bottom][i]);
+      }
+      bottom++;
+
+      for (let i = bottom; i <= top; i++) {
+       arranged.push(array[i][right]);
+      }
+      right--;
+
+      if (bottom <= top && left <= right) {
+        for (let i = right; i >= left; i--) {
+          arranged.push(array[top][i]);
+        }
+        top--;
+
+        for (let i = top; i >= bottom; i--) {
+          arranged.push(array[i][left]);
+        }
+        left++;
+      }
+    }
+
+    return arranged;
+  }; 

codewars/Sum of Digits - Digital Root/sumofdigits.js

@@ -0,0 +1,14 @@
+function digitalRoot(n) {
+    let str = n.toString();
+    let sum = 0;
+
+    for (const char of str) {
+      let num = parseInt(char);
+      sum += num;
+    }
+    str = sum.toString();
+    if (str.length > 1) {
+      return digitalRoot(str);
+    }
+    return sum;
+  } 

codewars/Sum of Intervals/sumofintervals.js

@@ -0,0 +1,22 @@
+function sumIntervals(intervals) {
+    intervals.sort((a, b) => a[0] - b[0]);
+
+    let sum = 0;
+    let End = Number;
+
+    for (const [start, finish] of intervals) {
+      if (start <= End && finish >= End) {
+        sum += finish - End;
+        if (End < finish) {
+          End = finish;
+        }
+      } else if (End > finish) {
+        continue;
+      } else {
+        sum += finish - start;
+        End = finish;
+      }
+    }
+
+    return sum;
+  } 

codewars/Sum of pairs/sumofpairs,js

@@ -0,0 +1,11 @@
+function sumPairs(ints, s) {
+  let noticed = {};
+  for (let i = 0; i < ints.length; i++) {
+    let x = s - ints[i];
+    if (x in noticed) {
+      return [x, ints[i]];
+    }
+    noticed[ints[i]] = true;
+  }
+  return undefined;
+}