[main] Added problems

Author: cthacker-udel

cProblems/sumPower/sumPower.c

@@ -0,0 +1,58 @@
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <stdio.h>
+
+unsigned long long sumDig(int n)
+{
+    char *strNum;
+    strNum = itoa(n, strNum, 10);
+    int total = 0;
+    for (int i = 0; i < strlen(strNum); i++)
+    {
+        total += strNum[i] - '0';
+    }
+    return total;
+}
+
+unsigned long long power_sum_dig_term(unsigned n)
+{
+    int *collector_arr = malloc(sizeof(int) * 1);
+    int collector_len = 1;
+    collector_arr[0] = 81;
+    int power = 3;
+    int starter = 9;
+    int curr_num = 81;
+    int power_limit = 6;
+    printf("Before while\n");
+    while (collector_len < n)
+    {
+        for (int i = 2;; i++)
+        {
+            for (int j = 2;; j++)
+            {
+                unsigned long long pow_num = (unsigned long long)pow(i, j);
+                if (pow_num % i == 0 && sumDig(pow_num) == i && log(pow_num) / log(i) == j && pow_num > curr_num)
+                {
+                    printf("in if\n");
+                    collector_arr = (int *)realloc(collector_arr, sizeof(int) * (collector_len + 1));
+                    collector_arr[collector_len - 1] = pow_num;
+                }
+            }
+        }
+    }
+    printf("Result = %d\n", collector_arr[collector_len - 1]);
+    return collector_arr[collector_len - 1];
+}
+
+// 2  -- 9   | 9 * 9          | 81
+// 3  -- 8   | 8 * 8 * 8      | 512
+// 4  -- 7   | 7 * 7 * 7 * 7  | 2401
+// 3  -- 17  | 17 * 17 * 17   | 4913
+// 3  -- 18  | 18 * 18 * 18   | 5832
+// 3  -- 26  | 26 * 26 * 26   | 17576
+
+int main(void)
+{
+    printf("Result = %d\n", power_sum_dig_term(2));
+}

jsProblems/blindfoldedchess/blindfoldedchess.js

@@ -0,0 +1,40 @@
+const fs = require("fs");
+
+/**
+ *
+ * @param {number[][]} moves - The list of available moves
+ * @param {number[]} curr_pattern - The current pattern we have
+ * @param {number} curr_x - The current x
+ * @param {number} curr_y - The current y
+ * @param {number[][]} guesses - The array of guesses we have made, cannot exceed 500
+ */
+function blindfoldChess(moves) {
+  let moves = {}; // hashmap consisting of the initial moves, and their chains
+  let visited_spots = {}; // hashmap consisting of the initial moves, and all spots we visited along that path
+  let curr_x = 0;
+  let curr_y = 0;
+  for (let i = 0; i < moves.length; i++) {
+    moves[moves[i]] = [moves[i]];
+    curr_x += moves[i][0];
+    curr_y += moves[i][1];
+    visited_spots[moves[i]];
+  }
+}
+
+// So what we need to do, is to pick a starting move, and then simulate the subsequent moves while removing duplicate moves from the equation
+// Then we map out each move, at each point, and what that resulting move places the piece at, as we are adding moves to the current chain, we check has that location already been
+// visited, if so, we don't add it to the chain, and move on to another move. Repeating this process for each initial move.
+
+const kingMoves = [
+  [-1, 1],
+  [1, 0],
+  [0, -1],
+  [0, 1],
+  [-1, 0],
+  [1, -1],
+  [-1, -1],
+  [1, 1],
+];
+
+fs.writeFileSync("output.txt", JSON.stringify(blindfoldChess(kingMoves)));
+console.log(blindfoldChess(kingMoves));

jsProblems/blindfoldedchess/output.txt

@@ -0,0 +1 @@
+[[0,1],[-1,0],[-1,2],[-2,1],[0,0],[-2,0],[0,2],[0,1],[1,-1],[1,1],[0,0],[2,-1],[0,-1],[2,1],[-1,0],[1,-1],[0,0],[-1,-1],[1,-2],[-1,-2],[1,0],[-1,2],[1,1],[0,0],[-1,1],[1,0],[-1,0],[1,2],[-2,1],[0,0],[-1,-1],[-1,1],[0,-1],[-2,-1],[0,1],[0,0],[2,-1],[1,-2],[1,0],[0,-1],[0,-2],[2,0],[-2,0],[0,-1],[-1,-2],[-1,0],[-2,-1],[0,-2],[0,0],[0,2],[2,1],[1,0],[1,2],[0,1],[2,0],[0,0]]

jsProblems/isExactlyThree/isExactlyThree.js

@@ -0,0 +1,12 @@
+function isExactlyThree(n) {
+  let ct = 1;
+  for (let i = 2; i <= Math.ceil(Math.sqrt(n)) + 1; i++) {
+    if (ct > 3) {
+      return false;
+    }
+    if (n % i == 0) {
+      ct++;
+    }
+  }
+  return ct == 3;
+}

jsProblems/multCurry/multCurry.js

@@ -0,0 +1,37 @@
+/**
+ *
+ * @param {number[]} arr
+ */
+function multCurry(arr) {
+  return (mult) => arr.map((eachNumber) => eachNumber * mult);
+}
+
+/**
+ *
+ * @param {number[]} arr
+ */
+function mirror(arr) {
+  return arr.concat(arr.slice().reverse());
+}
+
+class Book {
+  title;
+  author;
+
+  constructor(title, author) {
+    this.title = title;
+    this.author = author;
+  }
+
+  getTitle() {
+    return `Title: ${this.title}`;
+  }
+
+  getAuthor() {
+    return `Author: ${this.author}`;
+  }
+}
+
+const PP = new Book("Pride and Prejudice", "Jane Austen");
+const H = new Book("Hamlet", "William Shakespeare");
+const WP = new Book("War and Peace", "Leo Tolstoy");

jsProblems/runningAthlete/runningAthlete.js

@@ -0,0 +1,39 @@
+/**
+ *
+ * @param {string[]} act
+ * @param {string} txt
+ */
+function runningAthlete(act, txt) {
+  let resultStr = "";
+  for (let i = 0; i < act.length; i++) {
+    // O(n)
+    switch (act[i]) {
+      case "run": {
+        switch (txt[i]) {
+          case "_": {
+            resultStr += "_";
+            break;
+          }
+          case "|": {
+            resultStr += "/";
+          }
+        }
+        break;
+      }
+      case "jump": {
+        switch (txt[i]) {
+          case "_": {
+            resultStr += "x";
+            break;
+          }
+          case "|": {
+            resultStr += "|";
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+  return resultStr;
+}

output.txt

@@ -0,0 +1 @@
+[[-1,1],[1,0],[0,-1],[0,1],[-1,0],[1,-1],[-1,-1],[1,1]]

pythonProblems/lollipops/lollipops.py

@@ -0,0 +1,21 @@
+import math
+
+def santa():
+    num_tests = int(input())
+    for i in range(num_tests):
+        the_str = input()
+        distinct_letters = []
+        days = 0
+        for eachchar in the_str:
+            if eachchar not in distinct_letters and len(distinct_letters) == 3:
+                days += 1
+                distinct_letters = [eachchar]
+            elif eachchar in distinct_letters:
+                continue
+            else:
+                distinct_letters.append(eachchar)
+        print(days + 1)
+
+
+if __name__ == '__main__':
+    santa()

pythonProblems/topkfrequent/topkfrequent.py

@@ -0,0 +1,26 @@
+from operator import itemgetter
+from typing import List
+
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        hashmap = {}
+        for eachnumber in nums: # O(n)
+            if eachnumber in hashmap:
+                hashmap[eachnumber] += 1
+            else:
+                hashmap[eachnumber] = 1
+        keys = sorted(list(hashmap.items()), key=itemgetter(1))
+        t_keys = keys[len(keys) - k:]
+        nums = []
+        for eachentry in t_keys:
+            nums.append(eachentry[0])
+        return nums
+
+    
+
+if __name__ == '__main__':
+    elems = [1, 1, 1, 2, 2, 3]
+    k = 2
+    sol = Solution()
+    print(sol.topKFrequent(elems, k))

tsProblems/blindfoldedChess/blindfoldedChess.ts

@@ -0,0 +1,43 @@
+const fs = require("fs");
+
+/**
+ *
+ * @param {number[][]} moves - The list of available moves
+ * @param {number[]} curr_pattern - The current pattern we have
+ * @param {number} curr_x - The current x
+ * @param {number} curr_y - The current y
+ * @param {number[][]} guesses - The array of guesses we have made, cannot exceed 500
+ */
+function blindfoldChess(moves: number[][]) {
+  let move_chains: { [key: string]: number[][] } = {}; // hashmap consisting of the initial moves, and their chains
+  let visited_spots: { [key: string]: number[][] } = {}; // hashmap consisting of the initial moves, and all spots we visited along that path
+  let curr_x = 0;
+  let curr_y = 0;
+  for (let i = 0; i < moves.length; i++) {
+    move_chains[`${moves[i][0]},${moves[i][1]}`] = [moves[i]];
+    curr_x += moves[i][0];
+    curr_y += moves[i][1];
+    visited_spots[`${moves[i][0]},${moves[i][1]}`] = [
+      ...visited_spots[`${moves[i][0]},${moves[i][1]}`],
+      [curr_x, curr_y],
+    ];
+  }
+}
+
+// So what we need to do, is to pick a starting move, and then simulate the subsequent moves while removing duplicate moves from the equation
+// Then we map out each move, at each point, and what that resulting move places the piece at, as we are adding moves to the current chain, we check has that location already been
+// visited, if so, we don't add it to the chain, and move on to another move. Repeating this process for each initial move.
+
+// const kingMoves = [
+//   [-1, 1],
+//   [1, 0],
+//   [0, -1],
+//   [0, 1],
+//   [-1, 0],
+//   [1, -1],
+//   [-1, -1],
+//   [1, 1],
+// ];
+
+// fs.writeFileSync("output.txt", JSON.stringify(blindfoldChess(kingMoves)));
+// console.log(blindfoldChess(kingMoves));