[main] Added functions

Author: cthacker-udel

cProblems/apple/apple.c

@@ -0,0 +1,4 @@
+const char *apple(int x)
+{
+    return (x * x) > 1000 ? "It's hotter than th e sun!!" : "Help yourself to a honeycomb Yorkie for the glovebox.";
+}

cProblems/evenFib/evenFib.c

@@ -0,0 +1,42 @@
+#include <stdlib.h>
+#include <stdio.h>
+typedef unsigned long long ull;
+
+ull even_fib(ull limit)
+{
+    ull *fib = (ull *)malloc(sizeof(ull) * 3);
+    ull *evens = (ull *)malloc(sizeof(ull) * 1);
+    fib[0] = 0;
+    fib[1] = 1;
+    fib[2] = 1;
+    evens[0] = 0;
+    int len = 3;
+    int ind = 2;
+    int evenIndex = 0;
+    ull new_number = 0;
+    while (new_number < limit)
+    {
+        len++;
+        fib = (ull *)realloc(fib, sizeof(ull) * len);
+        ind++;
+        new_number = fib[ind - 1] + fib[ind - 2];
+        fib[ind] = new_number;
+        if (new_number % 2 == 0 && new_number < limit)
+        {
+            evenIndex++;
+            evens = (ull *)realloc(evens, sizeof(ull) * (evenIndex + 1));
+            evens[evenIndex] = new_number;
+        }
+    }
+    ull sum = 0;
+    for (int i = 0; i < evenIndex + 1; i++)
+    {
+        sum += evens[i];
+    }
+    return sum;
+}
+
+int main(void)
+{
+    printf("Result = %u\n", even_fib(10));
+}

cProblems/findMaxProduct/find_max_product.c

@@ -0,0 +1,25 @@
+#include <stddef.h>
+#include <limits.h>
+#include <stdio.h>
+
+int find_max_product(size_t length, const int array[length])
+{
+    int max_product = INT_MIN;
+    for (int i = 0; i < length; i++)
+    {
+        // the # of digits apart
+        int total_product = 1;
+        for (int j = i; j < length; j += i + 1)
+        {
+            total_product *= array[j];
+        }
+        max_product = total_product > max_product ? total_product : max_product;
+    }
+    return max_product;
+}
+
+int main(void)
+{
+    int arr[7] = {11, 6, -2, 0, 5, -4, 2};
+    printf("%d\n", find_max_product(sizeof(int) * 7, arr));
+}

cProblems/rangeBitCounting/rangeBitCounting.c

@@ -0,0 +1,25 @@
+#include <stdlib.h>
+#include <stdio.h>
+typedef unsigned int ui;
+
+ui range_bit_count(ui a, ui b)
+{
+    int totalCount = 0;
+    for (int i = a; i <= b; i++)
+    {
+        int count = 0;
+        int _i = i;
+        while (_i > 0)
+        {
+            count += _i % 2;
+            _i /= 2;
+        }
+        totalCount += count;
+    }
+    return totalCount;
+}
+
+int main(void)
+{
+    printf("%d\n", range_bit_count(2, 7));
+}

cppProblems/sumIntervals/sumIntervals.cpp

@@ -0,0 +1,88 @@
+/**
+ * Whether or not the card can be played
+ * 
+ * @param {string} resources - Your current resources
+ * @param {string} required - The resources required 
+ */
+const canPlay = (resources, required) => {
+    /**
+     * @type {Map}
+     */
+    const requiredLetters = new Map();
+    for (let i = 0; i < required.length; i++) {
+        if (requiredLetters.has(required.charAt(i))) {
+            requiredLetters.set(required.charAt(i), requiredLetters.get(required.charAt(i)) + 1);
+        } else {
+            requiredLetters.set(required.charAt(i), 1);
+        }
+    }
+    const resourcesLetters = new Map();
+    for (let i = 0; i < resources.length; i++) {
+        if (resourcesLetters.has(resources.charAt(i))) {
+            resourcesLetters.set(resources.charAt(i), resourcesLetters.get(resources.charAt(i)) + 1);
+        } else {
+            resourcesLetters.set(resources.charAt(i), 1);
+        }
+    }
+    return [...resourcesLetters.keys()].every(e => requiredLetters.has(e) && resourcesLetters.get(e) >= requiredLetters.get(e));
+}
+
+/**
+ * Makes the play on the card, given the resources and playIn and playOut values
+ * 
+ * @param {string} resources - Your current resources
+ * @param {string} playIn - The resources you are losing
+ * @param {string} playOut - The resources you are gaining
+ */
+const makePlay = (resources, playIn, playOut) => {
+    
+}
+
+class GraphNodeEdge {
+    /**
+     * @type {GraphNode}
+     */
+    connected_node;
+    /**
+     * @type {GraphNode}
+     */
+    target_node;
+    /**
+     * @type {string}
+     */
+    weight;
+}
+
+class GraphNode {
+    /**
+     * @type {Array<GraphNodeEdge>}
+     */
+    edges;
+
+    /**
+     * Adds a node to the list of connected nodes this current node contains
+     * 
+     * @param {GraphNode} new_node - The node we are adding 
+     */
+    add_edge(new_node) {
+        this.edges.push({ connected_node: this, target_node: new_node, weight: })
+    }
+
+
+}
+
+class Graph {
+    root;
+
+}
+
+const findCombo = function(starting, cards) {
+    // create a graph, of all potential plays the user can make from resources I, and then assign a weight to each edge, see if there is any vertex that contains the resource D, and if there is, follow
+    // the path back and see if it's possible to reach the beginning of the path from the end.
+    // root being the initial resources
+    
+    return {
+        preparation: [],
+        loop: []
+    }
+}

jsProblems/findCombo/findCombo.js

@@ -0,0 +1,20 @@
+Object.defineProperty( Array.prototype, "foldr", { value: function foldr(fn,z) {
+    return function _foldr(a) {
+        if (a.length > 0) {
+            value_ =  fn(a[0], z);
+            if (value_ === 
+            return fn(a[0], _foldr(a.slice(1)));
+        }
+        return z;
+    } (this)
+  } } );
+  
+  Object.defineProperty( String.prototype, "foldr", { value: [].foldr } );
+
+
+const nil = (x, z) => false;
+let i = 0;
+const arg = [1, 2, 3];
+const logging = fn => function logging(...a) { i++; return fn(...a); } ;
+console.log(arg.foldr(logging(nil), true));
+console.log(i);

jsProblems/foldr/foldr.js

@@ -0,0 +1,3 @@
+function howManyLightsabersDoYouOwn(name) {
+    return name === "Zach" ? 18 : 0;
+}

jsProblems/lightsabercount/howManyLightsabersDoYouOwn.js

@@ -0,0 +1,73 @@
+from typing import List
+
+
+def generate_determinant(matrix: List[List[int]], column_index: int) -> List[List[int]]:
+    """
+    Generates the determinant from the column index given, which means that the column is removed alongside the row in which the element is present
+
+    Args:
+        matrix (List[List[int]]): The matrix given
+        column_index (int): The index of the column to remove
+
+    Returns:
+        List[List[int]]: The matrix modified to have the determinant applied
+    """
+    cloned_matrix: List[List[int]] = [x[:] for x in matrix]
+    i = 0
+    del cloned_matrix[i]
+    for each_row in cloned_matrix:
+        del cloned_matrix[i][column_index]
+        i += 1
+    return cloned_matrix
+
+
+def determinant(matrix: List[List[int]]) -> int:
+    """
+    Generates a determinant of the matrix passed into the function
+
+    Args:
+        matrix (List[List[int]]): The matrix we are given to calculate the determinant of
+
+    Returns:
+        int: The determinant of the matrix, as described above.
+    """
+    ## what we have to do, is to first have 2 cases: 1x1, and 2x2, then we just basically do this
+    # for each part of the matrix, we generate the determinant of the first row, by passing in the generated matrix into this same function, which will eventually
+    # return a value for whichever matrix we pass into it
+    if len(matrix) == 1:
+        return matrix[0][0]
+    elif len(matrix) == 2:
+        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]
+    else:
+        determinant_sum = 0
+        minus_ = False
+        # generate determinant of first row
+        for j in range(len(matrix[0])):
+            if minus_:
+                determinant_sum -= matrix[0][j] * determinant(
+                    generate_determinant(matrix, j)
+                )
+            else:
+                determinant_sum += matrix[0][j] * determinant(
+                    generate_determinant(matrix, j)
+                )
+            minus_ = not minus_
+        return determinant_sum
+
+
+if __name__ == "__main__":
+    m1 = [[4, 6], [3, 8]]
+    m5 = [[2, 4, 2], [3, 1, 1], [1, 2, 0]]
+    m6 = [
+        [
+            2,
+        ]
+    ]
+    print(determinant([[5]]))
+    print(determinant(m5))
+
+    """
+    | 2 4 2 |
+    | 3 1 1 |
+    | 1 2 0 |
+    """

pythonProblems/4kyu/determinant/determinant.py

@@ -0,0 +1,37 @@
+from typing import List
+
+
+def find_uniq(arr: List[str]) -> str:
+    """
+    Given an array of strings, return the one string among all of them that contains similar letters
+
+    Args:
+        arr (List[str]): The list of strings we are generating the unique string from
+
+    Returns:
+        str: The unique string that does not contain any similar letters among all of the other elements
+    """
+    unique_strings = {}
+    modified_arr = ["".join(sorted(set(x.lower().replace(" ", "")))) for x in arr]
+
+    for ind, element in enumerate(modified_arr):
+        if element in unique_strings:
+            unique_strings[element] = -1
+        else:
+            unique_strings[element] = ind
+    for ind, element in enumerate(unique_strings.items()):
+        if element[1] != -1:
+            return arr[element[1]]
+
+
+if __name__ == "__main__":
+    arr2 = ["Aa", "aaa", "aaaaa", "BbBb", "Aaaa", "AaAaAa", "a"]
+    arr3 = ["abc", "acb", "bac", "foo", "bca", "cab", "cba"]
+    arr = ["    ", "a", "  "]
+    arr4 = ["Tom Marvolo Riddle", "I am Lord Voldemort", "Harry Potter"]
+    arr5 = ["i", "t", "t", "t"]
+    print(find_uniq(arr))
+    print(find_uniq(arr2))
+    print(find_uniq(arr3))
+    print(find_uniq(arr4))
+    print(find_uniq(arr5))