CodeWars

codewars/Adding Big Numbers/Adding Big Numbers.js

@@ -0,0 +1,16 @@
+function add(num1, num2) {
+    let result = '';
+    let carry = 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 sum = parseInt(num1[i]) + parseInt(num2[i]) + carry;
+        let digit = sum % 10;
+        carry = Math.floor(sum / 10);
+        result = digit + result;
+    }
+    if (carry > 0) {
+        result = carry + result;
+    }
+    return result;
+}

codewars/Anagram difference/Anagram difference.py

@@ -0,0 +1,3 @@
+def anagram_difference(word1, word2):
+    from collections import Counter
+    return sum((Counter(word1) - Counter(word2)).values()) + sum((Counter(word2) - Counter(word1)).values())

codewars/Array Deep Count/Array Deep Count.py

@@ -0,0 +1,7 @@
+def deep_count(a):
+    count = 0
+    for element in a:
+        if isinstance(element, list):
+            count += deep_count(element)
+        count += 1
+    return count

codewars/Build Tower/Build Tower.py

@@ -0,0 +1,8 @@
+def tower_builder(n_floors):
+    tower = []
+    for i in range(1, n_floors + 1):
+        num_spaces = n_floors - i
+        num_stars = 2 * i - 1
+        tower.append(" " * num_spaces + "*" * num_stars + " " * num_spaces)
+    return tower
+print(tower_builder(2))

codewars/Convert string to camel case/Convert string to camel case.py

@@ -0,0 +1,10 @@
+def to_camel_case(s):
+    if not s:
+        return ""
+    words = s.replace('-', ' ').replace('_', ' ').split()
+    camel_case = words[0] + ''.join(word.capitalize() for word in words[1:])
+    return camel_case
+print(to_camel_case("the-stealth-warrior"))
+print(to_camel_case("The_Stealth_Warrior"))
+print(to_camel_case("The_Stealth-Warrior"))
+print(to_camel_case(""))

codewars/Duplicate Encoder/Duplicate Encoder.py

@@ -0,0 +1,9 @@
+def duplicate_encode(s):
+    char_count ={}
+    for char in s.lower():
+        char_count[char] = char_count.get(char, 0) + 1
+    result = ""
+    for char in s:
+        result += "(" if char_count[char.lower()] == 1 else ")"
+    return result
+print(duplicate_encode("(( @"))

codewars/Find the missing letter/Find the missing letter.py

@@ -0,0 +1,5 @@
+def find_missing_letter(chars):
+    for i in range(len(chars) - 1):
+        if ord(chars[i + 1]) - ord(chars[i]) > 1:
+            return chr(ord(chars[i]) + 1)
+print(find_missing_letter(['a', 'b', 'c', 'd', 'f']))

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

@@ -0,0 +1,45 @@
+function flattenMap(map) {
+    let flattenedMap = {};
+
+    function flattenRecursive(map, prefix = "") {
+        for (let [key, value] of Object.entries(map)) {
+            let newPrefix = prefix ? prefix + key + "/" : key + "/";
+
+            if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                flattenRecursive(value, newPrefix);
+            } else {
+                flattenedMap[newPrefix.slice(0, -1)] = value;
+            }
+        }
+    }
+
+    flattenRecursive(map);
+    return flattenedMap;
+}
+
+// Test case
+const testMap = {
+    a: {
+        b: {
+            c: 12,
+            d: "Hello World"
+        },
+        e: [1, 2, 3]
+    }
+};
+
+// Expected flattened structure
+const expectedOutput = {
+    'a/b/c': 12,
+    'a/b/d': 'Hello World',
+    'a/e': [1, 2, 3]
+};
+
+const actualOutput = flattenMap(testMap);
+
+const assert = require('assert');
+
+// Ensure deep equality
+assert.deepEqual(actualOutput, expectedOutput);
+
+console.log("Test passed!");

codewars/Fun with tree - max sum/Fun with trees: max sum.py

@@ -0,0 +1,21 @@
+class TreeNode:
+    def __init__(self, value, left=None, right=None):
+        self.value = value
+        self.left = left
+        self.right = right
+
+def max_sum(root):
+    # If the root is None, the tree is empty, return 0
+    if root is None:
+        return 0
+
+    # If it's a leaf node, return its value
+    if root.left is None and root.right is None:
+        return root.value
+
+    # Recursively find the maximum sum for the left and right subtrees
+    left_sum = max_sum(root.left) if root.left is not None else float('-inf')
+    right_sum = max_sum(root.right) if root.right is not None else float('-inf')
+
+    # Return the current node's value plus the maximum of the left or right subtree sums
+    return root.value + max(left_sum, right_sum)

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

@@ -0,0 +1,25 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+def buildOneTwoThree():
+    head = Node(1)
+    second =Node(2)
+    third = Node(3)
+    head.next = second
+    second.next = third
+    return head
+def sorted_insert(head, data):
+    newNode = Node(data)
+    if head is None or head.data >= data:
+        newNode.next = head
+        head = newNode
+    else:
+        current = head
+        while current.next is not None and current.next.data < data:
+            current = current.next
+        newNode.next = current.next
+        current.next = newNode
+    return head
+head = buildOneTwoThree()
+sorted_insert(head, 5)

codewars/Merge two arrays/Merge two arrays.js

@@ -0,0 +1,21 @@
+function mergeArrays(array1, array2) {
+    let combinedResult = [];
+    let index1 = 0;
+    let index2 = 0;
+
+    while (index1 < array1.length || index2 < array2.length) {
+        if (index1 < array1.length) {
+            combinedResult.push(array1[index1]);
+            index1 += 1;
+        }
+        if (index2 < array2.length) {
+            combinedResult.push(array2[index2]);
+            index2 += 1;
+        }
+    }
+    return combinedResult;
+}
+
+const array2 = ['a', 'b', 'c', 'd', 'e', 'f'];
+const array1 = [1, 2, 3];
+console.log(mergeArrays(array1, array2));

codewars/Moving Zeros To The End/Moving Zeros To The End.py

@@ -0,0 +1,8 @@
+def move_zeros(lst):
+    slow = 0
+    for fast in range(len(lst)):
+        if lst[fast] != 0:
+            lst[slow], lst[fast] = lst[fast], lst[slow]
+            slow += 1
+    return lst
+print(move_zeros([1, 0, 1, 2, 0, 1, 3]))

codewars/Permutations/Permutations.py

@@ -0,0 +1,12 @@
+def permutations(s):
+    if len(s) == 0:
+        return ['']
+    perm_list = []
+    for i in range(len(s)):
+        m = s[i]
+        remaining_list = s[:i] + s[i+1:]
+        subperm_list = permutations(remaining_list)
+        for p in subperm_list:
+            perm_list.append(m + p)
+    return set(perm_list)
+print(permutations('abc'))

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

@@ -0,0 +1,7 @@
+def productFib(prod):
+    n = 0
+    nPlus = 1
+    while n * nPlus < prod:
+        nPlus = n + nPlus
+        n = nPlus - n
+    return [n, nPlus, n * nPlus == prod]

codewars/Simple Pig Latin/Simple Pig Latin.py

@@ -0,0 +1,20 @@
+import string
+
+def pig_it(text):
+    words = text.split()
+    transformed_words = []
+
+    for word in words:
+        if word[-1] in string.punctuation:
+            punctuation = word[-1]
+            word = word[:-1]
+        else:
+            punctuation = ''
+
+        if word:
+            transformed_word = word[1:] + word[0] + 'ay' + punctuation
+            transformed_words.append(transformed_word)
+        else:
+            transformed_words.append(punctuation)
+
+    return ' '.join(transformed_words)

codewars/Snail/Snail.py

@@ -0,0 +1,13 @@
+def snail(array):
+    if len(array) == 0:
+        return []
+    if len(array) == 1:
+        return array[0]
+
+    top = array[0][:-1]
+    right = [a[-1] for a in array]
+    bottom = array[-1][:-1][::-1]
+    left = [b[0] for b in array[1:-1]][::-1]
+    inner = [c[1:-1] for c in array[1:-1]]
+
+    return top + right + bottom + left + snail(inner)

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

@@ -0,0 +1,4 @@
+def digital_root(n):
+    while n > 9:
+        n = sum((int(digit)) for digit in str(n))
+    return n

codewars/Sum of Intervals/Sum of Intervals.py

@@ -0,0 +1,11 @@
+def sum_of_intervals(intervals):
+    intervals = sorted(intervals)
+    merged = [intervals[0]]
+
+    for interval in intervals[1:]:
+        if interval[0] <= merged[-1][1]:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], interval[1]))
+        else:
+            merged.append(interval)
+
+    return sum(end - start for start, end in merged)

codewars/Sum of pairs/Sum of Pairs.py

@@ -0,0 +1,9 @@
+def sum_pairs(ints, s):
+    seen = {}
+    for i, num in enumerate(ints):
+        complement = s - num
+        if complement in seen:
+            return [complement, num]
+        else:
+            seen[num] = i
+    return None

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

@@ -0,0 +1,27 @@
+def is_solved (board):
+    for row in board:
+        if row[0] == row[1] == row[2] and row[0] != 0:
+            return row[0]
+    for col in range(3):
+        if board[0][col] == board[1][col] == board[2][col] and board[0][col] != 0:
+            return board[0][col]
+    if board[0][0] == board[1][1] == board[2][2] and board[0][0] != 0:
+        return board[0][0]
+    if board[0][2] == board[1][1] == board [2][0] and board[0][2] != 0:
+        return board[0][2]
+    for row in board:
+        if 0 in row:
+            return -1
+    return 0
+board = [[0, 0, 1],
+         [0, 1, 2],
+         [2, 1, 0]]
+winner = is_solved(board)
+if winner == -1:
+    print("The game is not finished")
+elif winner == 1:
+    print("X won!")
+elif winner == 2:
+    print("0 won!")
+else:
+    print("It's a cat's game.")

codewars/Valid Parentheses/Valid Parentheses.py

@@ -0,0 +1,10 @@
+def valid_parentheses(s):
+    stack = []
+    for char in s:
+        if char == '(':
+            stack.append(char)
+        elif char == ')':
+            if not stack:
+                return False
+            stack.pop()
+    return not stack

codewars/Where my anagrams at/Where my anagrams at.py

@@ -0,0 +1,3 @@
+def anagrams(word, words):
+    sorted_word = sorted(word)
+    return [w for w in words if sorted(w) == sorted_word]

rpgsaga/saga/src/abstract/Hero.ts

@@ -0,0 +1,69 @@
+export abstract class Hero {
+    protected health: number;
+    protected strength: number;
+    protected readonly name: string;
+
+    constructor(name: string, health: number, strength: number) {
+        this.name = name;
+        this.health = health;
+        this.strength = strength;
+    }
+
+    abstract attack(target: Hero, useAbility?: boolean): void;
+
+    public getName(): string {
+        return this.name;
+    }
+
+    public getHealth(): number {
+        return this.health;
+    }
+
+    protected takeDamage(damage: number): void {
+        this.health = Math.max(this.health - damage, 0);
+    }
+}
+
+export class Knight extends Hero {
+    attack(target: Hero, useAbility: boolean = false): void {
+        let damage = this.strength;
+        if (useAbility) {
+            damage = Math.floor(this.strength * 1.3);
+            Logger.log(`${this.name} uses Vengeance Strike!`);
+        }
+        target.takeDamage(damage);
+        Logger.log(`${this.name} deals ${damage} damage to ${target.getName()}`);
+    }
+}
+
+export class Mage extends Hero {
+    private isStunned: boolean = false;
+
+    attack(target: Hero, useAbility: boolean = false): void {
+        if (useAbility) {
+            this.isStunned = true;
+            Logger.log(`${this.name} uses Charm! ${target.getName()} misses next turn.`);
+        } else {
+            target.takeDamage(this.strength);
+            Logger.log(`${this.name} deals ${this.strength} damage to ${target.getName()}`);
+        }
+    }
+
+    public isImmuneToFreeze(): boolean {
+        return true;
+    }
+}
+
+export class Archer extends Hero {
+    private burnTurns: number = 0;
+
+    attack(target: Hero, useAbility: boolean = false): void {
+        if (useAbility && this.burnTurns === 0) {
+            this.burnTurns = 3;
+            Logger.log(`${this.name} uses Flaming Arrows! ${target.getName()} is burning.`);
+        } else {
+            target.takeDamage(this.strength);
+            Logger.log(`${this.name} deals ${this.strength} damage to ${target.getName()}`);
+        }
+    }
+}