[main] Added functions

Author: cthacker-udel

.gitignore

@@ -4,4 +4,6 @@ obj
 bin
 *.cache
 *.cache
-*.log
+*.log
+
+tsProblems/node_modules

esoteric/bf/bf.py

@@ -0,0 +1,59 @@
+def brain_luck(code, program_input):
+    TAPE_LEN = 4000
+    CODE_LEN = len(code)
+
+    tape = [0] * TAPE_LEN
+    bracket_idxs = {}
+    tape_idx = 0
+    code_idx = 0
+    output = ""
+
+    while code_idx < CODE_LEN:
+        if code[code_idx] == ",":
+            tape[tape_idx] = ord(program_input[0])
+            program_input = program_input[1:]
+        elif code[code_idx] == "+":
+            tape[tape_idx] = (tape[tape_idx] + 1) % 256
+        elif code[code_idx] == "-":
+            tape[tape_idx] -= 1
+            if tape[tape_idx] < 0:
+                tape[tape_idx] = 255
+        elif code[code_idx] == ">":
+            tape_idx += 1
+        elif code[code_idx] == "<":
+            tape_idx -= 1
+        elif code[code_idx] == ".":
+            output += chr(tape[tape_idx])
+        elif code[code_idx] == "[":
+            if code_idx in bracket_idxs and code[code_idx] == 0:
+                code_idx = bracket_idxs[code_idx]
+            else:
+                get_matching_bracket(code, code_idx, bracket_idxs)
+                if code[code_idx] == 0:
+                    code_idx = bracket_idxs[code_idx]
+
+        elif code[code_idx] == "]" and tape[tape_idx] != 0:
+            code_idx = bracket_idxs[code_idx]
+
+        code_idx += 1
+
+    return output
+
+
+def get_matching_bracket(code, idx, bracket_idxs):
+    match_idx = idx + 1
+
+    while match_idx < len(code) and (
+        code[match_idx] != "]" or match_idx in bracket_idxs
+    ):
+        if code[match_idx] == "[" and match_idx not in bracket_idxs:
+            get_matching_bracket(code, match_idx, bracket_idxs)
+        match_idx += 1
+
+    bracket_idxs[idx] = match_idx
+    bracket_idxs[match_idx] = idx
+
+
+if __name__ == "__main__":
+    x = ",>+>>>>++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++<<<<<<[>[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<[>++++++++++[-<-[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<[>>>+<<<-]>>[-]]<<]>>>[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<+>>[-]]<<<<<<<]>>>>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]++++++++++<[->-<]>++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<<<<<<<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<-[>>.>.<<<[-]]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+>-]>[<+>-]<<<-]"
+    print(brain_luck(x, "\n"))

esoteric/questionexclamation/interpreter.py

@@ -0,0 +1,9 @@
+def interpreter(tape: str) -> str:
+    output = ""
+    tape_value = 0
+    for each_char in tape:
+        if each_char == "?":
+            tape_value += 1
+        elif each_char == "!":
+            output += chr(tape_value)
+            tape_value = 0

esoteric/questionexclamation/link.txt

@@ -0,0 +1 @@
+https://esolangs.org/wiki/(%3F!)

javaProblems/kataExampleTest/kataExampleTest.java

@@ -0,0 +1,9 @@
+public class kataExampleTest {
+    public static String[] kataExampleTwist() {
+        String[] websites = {};
+        for (int i = 0; i < 100; i++) {
+            
+        }
+        return websites;
+    }
+}

jsProblems/dictionarySequence/dictionarySequence.js

@@ -0,0 +1,12 @@
+function* letters() {
+  yield* "abcdefghijklmnopqrstuvwxyz";
+  yield* "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  while (true) {
+    console.log(yield* letters());
+  }
+}
+
+let iter = letters();
+for (let i = 0; i < 109; i++) {
+  console.log(iter.next().value);
+}

pythonProblems/firstMissingPositive/firstMissingPositive.py

@@ -0,0 +1,166 @@
+from typing import List
+
+
+class Solution:
+    def countingSort(self, arr, exp1):
+        n = len(arr)
+
+        # The output array elements that will have sorted arr
+        output = [0] * (n)
+
+        # initialize count array as 0
+        count = [0] * (10)
+
+        # Store count of occurrences in count[]
+        for i in range(0, n):
+            index = arr[i] / exp1
+            count[int((index) % 10)] += 1
+
+        # Change count[i] so that count[i] now contains actual
+        #  position of this digit in output array
+        for i in range(1, 10):
+            count[i] += count[i - 1]
+
+        # Build the output array
+        i = n - 1
+        while i >= 0:
+            index = arr[i] / exp1
+            output[count[int((index) % 10)] - 1] = arr[i]
+            count[int((index) % 10)] -= 1
+            i -= 1
+
+        # Copying the output array to arr[],
+        # so that arr now contains sorted numbers
+        i = 0
+        for i in range(0, len(arr)):
+            arr[i] = output[i]
+
+    # Method to do Radix Sort
+    def radixSort(self, arr, max1):
+
+        # Do counting sort for every digit. Note that instead
+        # of passing digit number, exp is passed. exp is 10^i
+        # where i is current digit number
+        exp = 1
+        while max1 / exp > 0:
+            self.countingSort(arr, exp)
+            exp *= 10
+        return arr
+
+    def firstMissingPositive(self, nums: List[int]) -> int:
+        """
+        Find the first missing positive number in O(n) time, meaning that we cycle through the array once and only once, no double fors
+
+        Args:
+            nums (List[int]): list of numbers to analyze
+
+        Returns:
+            int: the first missing positive
+        """
+        altered_nums = set()
+        the_sum = 0
+        for each_number in nums:
+            if each_number > 0 and each_number not in altered_nums:
+                altered_nums.add(each_number)
+                the_sum += each_number
+
+        arr = self.radixSort(list(altered_nums), max(altered_nums))
+
+        print(arr)
+
+        if len(arr) == 0:
+            return 1
+
+        min_number = arr[0]
+        max_number = arr[-1]
+        range_sum = ((min_number + max_number) * (max_number - min_number + 1)) // 2
+        if range_sum == the_sum and min_number == 1:
+            return max_number + 1
+        else:
+            if min_number == 1:
+                ## cycle through, find gap, return
+                for i in range(len(arr) - 1):
+                    if arr[i + 1] - arr[i] > 1:
+                        return arr[i] + 1
+                return -1
+            return 1
+
+    def firstMissingPositiveV2(self, nums: List[int]) -> int:
+
+        n = len(nums)
+        r_n = range(n)
+        for i in r_n:
+            if nums[i] <= 0 or nums[i] > n:
+                nums[i] = n + 1
+
+        for i in r_n:
+            i_abs = abs(nums[i])
+
+            if i_abs > n:
+                continue
+
+            i_abs -= 1
+            if nums[i_abs] > 0:
+                nums[i_abs] = -1 * nums[i_abs]
+
+        for i in r_n:
+            if nums[i] >= 0:
+                return i + 1
+
+        return n + 1
+
+
+if __name__ == "__main__":
+    a = [1, 2, 0]
+    b = [3, 4, -1, 1]
+    c = [7, 8, 9, 11, 12]
+    d = [2]
+    e = [1, 1]
+    f = [
+        3,
+        17,
+        7,
+        16,
+        16,
+        8,
+        -4,
+        5,
+        -4,
+        3,
+        -2,
+        18,
+        34,
+        5,
+        1,
+        -7,
+        3,
+        3,
+        27,
+        8,
+        23,
+        3,
+        -3,
+        2,
+        27,
+        8,
+        15,
+        7,
+        -6,
+        15,
+        23,
+        -6,
+        3,
+        2,
+        5,
+        23,
+        21,
+        3,
+        2,
+    ]
+    sol = Solution()
+    print(sol.firstMissingPositiveV2(a))
+    print(sol.firstMissingPositiveV2(b))
+    print(sol.firstMissingPositiveV2(c))
+    print(sol.firstMissingPositiveV2(d))
+    print(sol.firstMissingPositiveV2(e))
+    print(sol.firstMissingPositiveV2(f))

pythonProblems/iterpi/iterpi.py

@@ -0,0 +1,17 @@
+import math
+
+
+def iter_pi(epsilon):
+    start = 1
+    total = 1
+    iterations = 1
+    while abs((total - math.pi)) > epsilon:
+        start = start / start + 2
+        total += start
+        start += 2
+        iterations += 1
+    return iterations
+
+
+if __name__ == "__main__":
+    print(iter_pi(0.1))

pythonProblems/longestword/longestword.py

@@ -0,0 +1,49 @@
+from typing import List
+
+
+def longer_word(word1: str, word2: str) -> str:
+    """
+    Returns the longer word when passed 2 words
+
+    Args:
+        word1 (str): First word
+        word2 (str): Second word
+
+    Returns:
+        str: The longer word
+    """
+    if len(word1) > len(word2):
+        return word1
+    elif len(word2) > len(word1):
+        return word2
+    else:
+        return word1
+
+
+def longest_word(sentence: str | List[str]) -> str:
+    """
+    Computes longest word recursively given a sentence
+
+    Args:
+        sentence (str): the sentence we are given
+
+    Returns:
+        str: The longest word
+    """
+    # "This has the longest word." --> ['This', 'has', 'the', 'longest', 'word']
+    # base case: 1 element in the list, then we just return it
+    split_sentence = sentence.split(" ")
+    if (
+        len(split_sentence) == 1
+    ):  # doing this, because we receive the sentence initially as a str, and if it is a list, testing if it only contains 1 element
+        return sentence[0]
+    else:
+        # magic happens, we recursively call the longest_word, with a SHORTER argument, aka reducing the problem
+        # that gives us an array of all the words in the sentence
+        return longer_word(split_sentence[0], longest_word(" ".join(split_sentence)))
+
+
+if __name__ == "__main__":
+    example_sentence = "This has the longest word."
+    print(longest_word(example_sentence))
+    print(longest_word(example_sentence) == "longest")

tsProblems/buyCar/buyCar.js

@@ -0,0 +1,23 @@
+"use strict";
+exports.__esModule = true;
+exports.nbMonths = void 0;
+function nbMonths(startPriceOld, startPriceNew, savingPerMonth, percentLossByMonth) {
+    var months = 0;
+    var currentSavings = 0;
+    var tmpStartPriceOld = startPriceOld; // avoid mutating
+    var tmpStartPriceNew = startPriceNew;
+    while (tmpStartPriceNew - (currentSavings + tmpStartPriceOld) > 0) {
+        months++;
+        if (months > 0 && months % 2 == 0) {
+            percentLossByMonth += 0.5;
+        }
+        currentSavings += savingPerMonth;
+        tmpStartPriceOld -= tmpStartPriceOld * (percentLossByMonth / 100);
+        tmpStartPriceNew -= tmpStartPriceNew * (percentLossByMonth / 100);
+    }
+    var currTotal = currentSavings + tmpStartPriceOld;
+    return [months, Math.round(currTotal - tmpStartPriceNew)];
+}
+exports.nbMonths = nbMonths;
+console.log(nbMonths(12000, 8000, 1000, 1.5));
+console.log(nbMonths(2000, 8000, 1000, 1.5));