Codewars + Func + Classes + Hard Polymorphism

codewars/Adding Big Numbers/Adding Big Numbers.js

@@ -0,0 +1,12 @@
+function add(num1, num2) {
+    let sum = "";
+    let k = 0;
+    while (num1.length < num2.length) num1 = "0" + num1;
+    while (num2.length < num1.length) num2 = "0" + num2;
+    for (let i = num1.length - 1; i >= 0; i--) {
+        let digitSum = +num1[i] + +num2[i] + k;
+        sum = (digitSum % 10) + sum;
+        k = Math.floor(digitSum / 10);}
+    if (k) sum = k + sum;
+    return sum;
+}

codewars/Anagram difference/Anagram difference.py

@@ -0,0 +1,9 @@
+def anagram_difference(w1, w2):
+    count_w1 = [0] * 26
+    count_w2 = [0] * 26
+    for char in w1:
+        count_w1[ord(char) - ord('a')] += 1
+    for char in w2:
+        count_w2[ord(char) - ord('a')] += 1
+    deletions = sum(abs(count_w1[i] - count_w2[i]) for i in range(26))
+    return deletions

codewars/Array Deep Count/Array_Deep_Count.py

@@ -0,0 +1,7 @@
+def deep_count(x):
+    summ = 0
+    for i in x:
+        summ += 1
+        if isinstance(i, list):
+            summ += deep_count(i)
+    return summ

codewars/Build Tower/Build_Tower.ts

@@ -0,0 +1,9 @@
+export function towerBuilder(floors: number): string[] {
+    const tower: string[] = [];
+    for (let i = 0; i < floors; i++) {
+        const stars = '*'.repeat(2 * i + 1);
+        const spaces = ' '.repeat(floors - i - 1);
+        tower.push(spaces + stars + spaces);
+    }
+    return tower;
+}

codewars/Convert string to camel case/Convert_string_to_camel_case.ts

@@ -0,0 +1,9 @@
+export function toCamelCase(input: string): string {
+    if (input === "") return input;
+    const words = input.split(/[-_]/);
+    const transformedWords = words.map((word, index) => {
+        if (index === 0) return word;
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    });
+    return transformedWords.join("");
+}

codewars/Duplicate Encoder/Duplicate_Encoder.ts

@@ -0,0 +1,12 @@
+export function duplicateEncode(word: string): string {
+    const lowerCaseWord = word.toLowerCase();
+    const charCount: { [key: string]: number } = {};
+    for (const char of lowerCaseWord) {
+        charCount[char] = (charCount[char] || 0) + 1;
+    }
+    let result = '';
+    for (const char of lowerCaseWord) {
+        result += charCount[char] === 1 ? '(' : ')';
+    }
+    return result;
+}

codewars/Find the missing letter/Find_the_missing_letter.ts

@@ -0,0 +1,7 @@
+export function findMissingLetter(array: string[]): string {
+    for (let i = 0; i < array.length - 1; i++) {
+        if (array[i].charCodeAt(0) + 1 !== array[i + 1].charCodeAt(0)) {
+            return String.fromCharCode(array[i].charCodeAt(0) + 1);
+        }}
+    return '';
+}

codewars/Flatten a Nested Map/Flatten a Nested Map.js

@@ -0,0 +1,14 @@
+function flattenMap(input) {
+    const result = {};
+    function traverse(current, path) {
+        for (const key in current) {
+            const newPath = path ? `${path}/${key}` : key;
+            const value = current[key];
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                traverse(value, newPath);
+            } else {
+                result[newPath] = value;
+            }}}
+    traverse(input, '');
+    return result;
+}

codewars/Fun with tree - max sum/Fun with trees_max sum.py

@@ -0,0 +1,23 @@
+class TreeNode:
+    def __init__(self, value, left=None, right=None):
+        self.value = value
+        self.left = left
+        self.right = right
+
+def max_sum(root: TreeNode) -> int:
+    if root is None:
+        return 0
+    def dfs(node):
+        if not node:
+            return float('-inf')
+        if not node.left and not node.right:
+            return node.value
+        left_sum = dfs(node.left)
+        right_sum = dfs(node.right)
+        return node.value + max(left_sum, right_sum)
+    return dfs(root)
+root = TreeNode(
+    5,
+    TreeNode(4, TreeNode(-80), TreeNode(-60)),
+    TreeNode(10, TreeNode(-90)))
+print(max_sum(root))

codewars/Linked Lists - Sorted Insert/Linked Lists - Sorted Insert.py

@@ -0,0 +1,15 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+def sorted_insert(head, data):
+    new_node = Node(data)
+    if head is None or data < head.data:
+        new_node.next = head
+        return new_node
+    current = head
+    while current.next is not None and current.next.data < data:
+        current = current.nex
+    new_node.next = current.next
+    current.next = new_node
+    return head

codewars/Merge two arrays/Merge two arrays.js

@@ -0,0 +1,12 @@
+function mergeArrays(array1, array2) {
+    const maxLength = Math.max(array1.length, array2.length);
+    const mergedArray = [];
+    for (let i = 0; i < maxLength; i++) {
+        if (i < array1.length) {
+            mergedArray.push(array1[i]);
+        }
+        if (i < array2.length) {
+            mergedArray.push(array2[i]);
+        }}
+    return mergedArray;
+}

codewars/Moving Zeros To The End/Moving_Zeros_To_The_End.js

@@ -0,0 +1,11 @@
+function moveZeros(array) {
+    let nonZeroElements = [];
+    let zeroElements = [];
+    for (let element of array) {
+        if (element === 0) {
+            zeroElements.push(element);
+        } else {
+            nonZeroElements.push(element);
+        }}
+    return nonZeroElements.concat(zeroElements);
+}

codewars/Permutations/So_Many_Permutations.js

@@ -0,0 +1,11 @@
+function permutations(input) {
+    if (input.length === 1) return [input];
+    const res = [];
+    for (let i = 0; i < input.length; i++) {
+        const currentChar = input[i];
+        if (input.indexOf(currentChar) === i) {
+            const remainingChars = input.slice(0, i) + input.slice(i + 1);
+            res.push(...permutations(remainingChars).map(perm => currentChar + perm));
+        }}
+    return res;
+}

codewars/Product of consecutive Fib numbers/Product of consecutive Fib numbers.ts

@@ -0,0 +1,10 @@
+export function productFib(prod: number): [number, number, boolean] {
+    let fib1: number = 1;
+    let fib2: number = 1;
+    while (fib1 * fib2 < prod) {
+        const nextFib: number = fib1 + fib2;
+        fib1 = fib2;
+        fib2 = nextFib;
+    }
+    return [fib1, fib2, fib1 * fib2 === prod];
+}

codewars/Simple Pig Latin/Simple Pig Latin.js

@@ -0,0 +1,9 @@
+function pigIt(sentence) {
+    const suffix = "ay";
+    return sentence.split(" ").map(word => {
+        if (/^[a-zA-Z]+$/.test(word)) {
+            return word.slice(1) + word[0] + suffix;
+        }
+        return word;
+    }).join(" ");
+}

codewars/Snail/Snail.js

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

codewars/Sum of Digits - Digital Root/Sum of DigitsDigital Root.py

@@ -0,0 +1,10 @@
+def digital_root(n):
+    k=n
+    b=0
+    while len(str(k))>1:
+        b=0
+        k=str(k)
+        for i in k:
+            b+=int(i)
+        k=b
+    return (k)

codewars/Sum of Intervals/Sum of Intervals.ts

@@ -0,0 +1,14 @@
+export function sumOfIntervals(intervals: [number, number][]): number {
+    intervals.sort((a, b) => a[0] - b[0]);
+    let totalLength = 0;
+    let lastEnd = -Infinity;
+    for (const [start, end] of intervals) {
+        if (start > lastEnd) {
+            totalLength += end - start;
+        } else if (end > lastEnd) {
+            totalLength += end - lastEnd;
+        }
+        lastEnd = Math.max(lastEnd, end);
+    }
+    return totalLength;
+}

codewars/Sum of pairs/Sum of Pairs.ts

@@ -0,0 +1,11 @@
+export function sumPairs(ints: number[], sum: number): [number, number] | undefined {
+    const seen = new Set<number>();
+    for (const num of ints) {
+        const complement = sum - num;
+        if (seen.has(complement)) {
+            return [complement, num];
+        }
+        seen.add(num);
+    }
+    return undefined;
+}

codewars/Tic-Tac-Toe Checker/Tic-Tac-Toe Checker.py

@@ -0,0 +1,17 @@
+def is_solved(board):
+    def check_line(a, b, c):
+        return a if a != 0 and a == b and a == c else None
+    for i in range(3):
+        if check_line(board[i][0], board[i][1], board[i][2]):
+            return board[i][0]
+        if check_line(board[0][i], board[1][i], board[2][i]):
+            return board[0][i]
+    if check_line(board[0][0], board[1][1], board[2][2]):
+        return board[0][0]
+    if check_line(board[0][2], board[1][1], board[2][0]):
+        return board[0][2]
+    for i in range(3):
+        for j in range(3):
+            if board[i][j] == 0:
+                return -1
+    return 0

codewars/Valid Parentheses/Valid_Parenthesis.py

@@ -0,0 +1,10 @@
+def valid_parentheses(parens):
+    count = 0
+    for char in parens:
+        if char == "(":
+            count += 1
+        elif char == ")":
+            count -= 1
+            if count < 0:
+                return False
+    return count == 0

codewars/Where my anagrams at/Where my anagrams at.js

@@ -0,0 +1,4 @@
+function anagrams(targetWord, wordList) {
+    const sortedTarget = targetWord.split("").sort().join("");
+    return wordList.filter(word => word.split("").sort().join("") === sortedTarget);
+}

rpgsaga/.gitlab-ci.yml

@@ -24,4 +24,4 @@ test_saga:
   rules:
     - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
       changes:
-        - rpgsaga/**/*
+        - rpgsaga/**/*

rpgsaga/.vscode/launch.json

@@ -11,7 +11,6 @@
             "skipFiles": [
                 "<node_internals>/**"
             ],
-            "program": "${workspaceFolder}/saga/src/index.ts",
             "outFiles": [
                 "${workspaceFolder}/**/*.js"
             ]

rpgsaga/saga/eslint.config.mjs

@@ -152,6 +152,11 @@ export default [{
         }, {
             selector: "typeProperty",
             format: ["snake_case", "camelCase"],
+        }, { 
+            selector: ['memberLike'],
+            modifiers: ['protected'],
+            format: ['camelCase'],
+            leadingUnderscore: 'allow',
         }],
     },
 }];