codewars and moodle

.vscode/settings.json

@@ -1,7 +1,7 @@
 {
     "files.exclude": {
-        "rpgsaga": true,
-        "codewars": true,
-        "onlineshop": true,
+        "rpgsaga": false,
+        "codewars": false,
+        "onlineshop": false,
     }
 }

codewars/Anagram difference/anagramdif.js

@@ -0,0 +1,19 @@
+function getSumOfDeletedLetters(word1, word2) {
+    // второе слово в обратный порядок
+    const reversedWord2 = word2.split('').reverse().join('');
+    let sum = 0;
+    // по каждой букве первого слова
+    for (let i = 0; i < word1.length; i++) {
+      if (word1[i] !== reversedWord2[i]) {
+        sum++;
+      }
+    }
+
+    return sum;
+  }
+
+  // Пример использования
+  const word1 = 'code wars';
+  const word2 = 'hack er rank';
+  const result1 = getSumOfDeletedLetters(word1, word2);
+  console.log(result1); 

codewars/Array Deep Count/arraydeepcount.js

@@ -0,0 +1,21 @@
+function countElements(arr) {
+    let count = 0;
+
+    function countRecursive(subArr) {
+      for (let i = 0; i < subArr.length; i++) {
+        if (Array.isArray(subArr[i])) {
+          countRecursive(subArr[i]);
+        } else {
+          count++;
+        }
+      }
+    }
+
+    countRecursive(arr);
+
+    return count;
+  }
+
+  // Пример использования
+  const array = [1, 2, [3, 4, [5, 6]], 7, [8, 9]];
+  console.log(countElements(array)); // Output: 9

codewars/Build Tower/tower.js

@@ -0,0 +1,15 @@
+function build (pyramidHeight) {
+    for (let i = 1; i <= pyramidHeight; i++) {
+      let row = '';
+      for(let j = 1; j <= (pyramidHeight - i); j++) {
+        row += ' ';
+      }
+      for(let k = 1; k <= (2 * i - 1); k++) {
+        row += '*';
+      }
+      console.log(row);
+    }
+  }
+
+  console.log(build(5))
+

codewars/Convert string to camel case/convert.js

@@ -0,0 +1,13 @@
+function convertToCamelCase(input) {      
+    var words = input.split(/[-_]/);   // Разделить строку по тире или нижнему подчеркиванию   
+    for (var i = 1; i < words.length; i++) {    
+      words[i] = words[i].charAt(0).toUpperCase() + words[i].slice(1).toLowerCase();   
+    }      // Соединить слова, пропустив разделители   
+    var camelCase = words.join("");      
+    return camelCase; 
+  }  
+
+    // Пример использования 
+    var input = "hello-world"; 
+    var camelCase = convertToCamelCase(input); 
+    console.log(camelCase); // Выводит "helloWorld" 

codewars/Duplicate Encoder/duplicate.js

@@ -0,0 +1,19 @@
+function transformString(str) {
+    let lowerCaseStr = str.toLowerCase(); 
+    let result = ""; 
+    for (let i = 0; i < lowerCaseStr.length; i++) {
+      let currentChar = lowerCaseStr[i];
+      let count = lowerCaseStr.split(currentChar).length - 1;
+      if (count === 1) {
+        result += "(";
+      } else {
+        result += ")";
+      }
+    }
+    return result;
+  }
+
+  // Пример использования:
+  let inputString = "din";
+  let transformedString = transformString(inputString);
+  console.log(transformedString); 

codewars/Find the missing letter/missing.js

@@ -0,0 +1,11 @@
+function findMissingLetter(array) {
+    for (let i = 0; i < array.length - 1; i++) {
+      if (array[i + 1].charCodeAt(0) - array[i].charCodeAt(0) > 1) {
+        return String.fromCharCode(array[i].charCodeAt(0) + 1);
+      }
+    }
+  }
+
+  //Пример использования: 
+  console.log(findMissingLetter(['a', 'b', 'c', 'e'])); 
+  console.log(findMissingLetter(['O','Q','R','S'])); 

codewars/Flatten a Nested Map/flatten.js

@@ -0,0 +1,28 @@
+function flattenMap(map, parentKey = '') {
+    let flatMap = {};
+
+    for (let key in map) {
+      if (typeof map[key] === 'object') {
+        let nestedMap = flattenMap(map[key], parentKey + key + '/');
+        flatMap = { ...flatMap, ...nestedMap };
+      } else {
+        flatMap[parentKey + key] = map[key];
+      }
+    }
+
+    return flatMap;
+  }
+
+
+  let hierarchicalMap = {
+    prop1: 'value1',
+    prop2: {
+      nestedProp1: 'value2',
+      nestedProp2: {
+        deeplyNestedProp: 'value3'
+      }
+    }
+  };
+
+  let flatMap = flattenMap(hierarchicalMap);
+  console.log(flatMap);

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

@@ -0,0 +1,44 @@
+class Node {
+    constructor(value, left=null, right=null) {
+      this.value = value;
+      this.left = left;
+      this.right = right;
+    }
+  }
+
+  class BinaryTree {
+    constructor(root) {
+      this.root = root;
+    }
+
+    maxsum() {
+      // Рекурсивная функция для обхода дерева и подсчета максимальной суммы
+      const traverse = (node, currentSum) => {
+        if (node === null) {
+          return currentSum;
+        }
+
+        // Вычисляем сумму для левого и правого поддерева
+        const leftSum = traverse(node.left, currentSum + node.value);
+        const rightSum = traverse(node.right, currentSum + node.value);
+
+        // Возвращаем максимальную сумму из левого и правого поддерева
+        return Math.max(leftSum, rightSum);
+      };
+
+      // Начинаем обход с корневого узла и текущей суммой 0
+      return traverse(this.root, 0);
+    }
+  }
+
+  // Пример использования
+  const leaf1 = new Node(4);
+  const leaf2 = new Node(3);
+  const leaf3 = new Node(5);
+  const leaf4 = new Node(6);
+  const node3 = new Node(2, leaf1, leaf2);
+  const node2 = new Node(1, leaf3, leaf4);
+  const root = new Node(0, node2, node3);
+
+  const tree = new BinaryTree(root);
+  console.log(tree.maxsum()); //должна вывести: 11 (0 -> 1 -> 5 -> 5)

codewars/Merge two arrays/mergewoarrays.js

@@ -0,0 +1,24 @@
+function mergeArrays(numbers, letters) {
+    const mergedArray = [];
+    const maxLength = Math.max(numbers.length, letters.length);
+    for (let i = 0; i < maxLength; i++) {
+      // Если есть элемент в числовом массиве на данной позиции, добавляем его в объединенный массив
+      if (i < numbers.length) {
+        mergedArray.push(numbers[i]);
+      }
+
+      // Если есть элемент в массиве с буквами на данной позиции, добавляем его в объединенный массив
+      if (i < letters.length) {
+        mergedArray.push(letters[i]);
+      }
+    }
+
+    return mergedArray;
+  }
+
+  // Пример использования
+  const numbers = [1, 2, 3, 4, 5];
+  const letters = ['a', 'b', 'c', 'd', 'e', 'f'];
+
+  const mergedArray = mergeArrays(numbers, letters);
+  console.log(mergedArray); 

codewars/Moving Zeros To The End/zeros.js

@@ -0,0 +1,18 @@
+function moveZerosToEnd(arr) {
+    let zeros = []; 
+    const nonZeros = arr.filter((element) => {  
+      if (element === 0) {   
+        zeros.push(element);
+        return false; 
+      }
+      return true; 
+    });
+
+    return nonZeros.concat(zeros); 
+  }
+
+  // Пример использования:
+
+  const inputArray = [false, 0, 1, "hello", 0, 3, "world"];
+  const resultArray = moveZerosToEnd(inputArray);
+  console.log(resultArray); 

codewars/Permutations/permutations.js

@@ -0,0 +1,37 @@
+function getPermutationsWithoutDuplicates(string) {
+    const result = [];
+    // Проверка на непустую входную строку
+    if (!string || typeof string !== 'string') {
+      throw new Error('Invalid input. Please provide a non-empty string.');
+    }
+    function permute(str, prefix = '') {
+      if (str.length === 1) {
+        result.push(prefix + str);
+        return;
+      }
+
+      for (let i = 0; i < str.length; i++) {
+        const currentChar = str[i];
+        const remainingChars = str.slice(0, i) + str.slice(i + 1);
+
+        // Проверка на дубликаты
+        if (str.indexOf(currentChar) !== i) {
+          continue;
+        }
+
+        permute(remainingChars, prefix + currentChar);
+      }
+    }
+
+    permute(string);
+
+    // Удаление дубликатов
+    const uniquePermutations = [...new Set(result)];
+
+    return uniquePermutations;
+  }
+
+  // Пример использования
+  const inputString1 = 'abc';
+  const permutations = getPermutationsWithoutDuplicates(inputString1);
+  console.log(permutations); 

codewars/Product of consecutive Fib numbers/fib.js

@@ -0,0 +1,7 @@
+function productFib(prod) {
+    let [a, b] = [0, 1];
+    while (a * b < prod) {
+      [a, b] = [b, a + b];
+    }
+    return [a, b, a * b === prod];
+  }

codewars/Simple Pig Latin/simple.js

@@ -0,0 +1,17 @@
+function modifyString(input) {
+    const words = input.split(' ');
+    const modifiedWords = words.map(word => {
+      const firstLetter = word.charAt(0);
+      const restOfWord = word.slice(1);
+      const modifiedWord = restOfWord + firstLetter + 'ау';
+      return modifiedWord;
+    });
+    const result = modifiedWords.join(' \t');
+    return result;
+  }
+
+  // Пример использования
+  const inputString12 = 'привет всем';
+  const modifiedString = modifyString(inputString12);
+  console.log(modifiedString);
+

codewars/Snail/snail.js

@@ -0,0 +1,33 @@
+function snail(arr) {
+    const n = arr.length;
+    const result = [];
+    if (n !== arr[0].length) {
+      return null;
+    }
+    let row = 0, col = 0;
+    let count = n;
+    while (count > 0) {
+      for (let i = 0; i < count; i++) {
+        result.push(arr[row][col++]);
+      }
+      col--;
+      row++;
+      for (let i = 0; i < count - 1; i++) {
+        result.push(arr[row++][col]);
+      }
+      row--;
+      col--;
+      for (let i = 0; i < count - 1; i++) {
+        result.push(arr[row][col--]);
+      }
+      col++;
+      row--;
+      for (let i = 0; i < count - 2; i++) {
+        result.push(arr[row--][col]);
+      }
+      row++;
+      col++;
+      count -= 2;
+    }
+    return result;
+  }

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

@@ -0,0 +1,17 @@
+function recursiveSum(num) {
+    if (num < 10) {
+      return num;
+    }
+    let digitsSum = 0;
+    while (num > 0) {
+      digitsSum += num % 10;
+      num = Math.floor(num / 10);
+    }
+    return recursiveSum(digitsSum);
+  }
+
+  // Пример использования
+  const number = 123456789;
+  const result = recursiveSum(number);
+  console.log("Рекурсивная сумма числа", number, "до однозначного значения равна", result);
+

codewars/Sum of Intervals/sumint.js

@@ -0,0 +1,23 @@
+function sumIntervals(intervals) {
+    // Сортируем интервалы по началу
+    intervals.sort(function(a, b) {
+      return a[0] - b[0];
+    });
+
+    let totalLength = 0;
+    let currentInterval = intervals[0];
+
+    for(let i = 1; i < intervals.length; i++) {
+      const interval = intervals[i];
+
+      if(interval[0] <= currentInterval[1]) {
+        currentInterval[1] = Math.max(currentInterval[1], interval[1]);
+      } else {
+        totalLength += currentInterval[1] - currentInterval[0] + 1;
+        currentInterval = interval;
+      }
+    }
+    totalLength += currentInterval[1] - currentInterval[0] + 1;
+
+    return totalLength;
+  }

codewars/Sum of pairs/smpairs.js

@@ -0,0 +1,15 @@
+function sumPairs(numbers, targetSum) {
+    const map = new Map(); // используем Map для хранения чисел и их индексов
+
+    for (let i = 0; i < numbers.length; i++) {
+      const complement = targetSum - numbers[i]; 
+
+      if (map.has(complement)) { 
+        const complementIndex = map.get(complement); 
+        return [complement, numbers[i]]; 
+      }
+
+      map.set(numbers[i], i); 
+    }
+
+  }