[main] Added problems

Author: cthacker-udel

pythonProblems/repeatLimitedString/repeatedLimitedString.py

@@ -0,0 +1,19 @@
+from typing import List
+
+class Solution:
+    def any_available_letters(self, letter: str, available_letters: List[str], availability: dict(str, bool)) -> str:
+        pass
+
+    def repeatedLimitedString(self, s: str, repeatLimit: int) -> str:
+        constructed_string = ""
+        letters = sorted(set(s), reverse=True)
+        letter_occurrence = [s.count(x) for x in letters]
+        repeat_count = dict.fromkeys(letters, 0)
+        for each_letter in s:
+            
+        return constructed_string
+
+
+if __name__ == "__main__":
+    sol = Solution()
+    print(sol.repeatedLimitedString("cczazcc", 3))

pythonProblems/repeatLimitedString/test.py

@@ -0,0 +1,84 @@
+from typing import List
+from pprint import pprint
+
+
+class Solution:
+    def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
+        base_len = len(matrix)
+        col_len = len(matrix[0])
+        range_base = range(base_len)
+        range_col = range(col_len)
+        longest_paths = [[1] * col_len for x in range_base]
+        for i in range(len(matrix)):
+            for j in range(len(matrix[0])):
+                self.find_longest_path(matrix, longest_paths, i, j)
+        max_len = 1
+        pprint(longest_paths)
+        for each_row in longest_paths:
+            max_len = max(max_len, max(each_row))
+        return max_len
+
+    def find_longest_path(
+        self,
+        matrix: List[List[int]],
+        dfs_table: List[List[int]],
+        row: int,
+        col: int,
+        current_length: int = 1,
+    ) -> None:
+        if row != -1 and col != -1 and row < len(matrix) and col < len(matrix[0]):
+            current_element = matrix[row][col]
+            left_element = matrix[row][col - 1] if col > 0 else 1
+            right_element = matrix[row][col + 1] if col < len(matrix[0]) - 1 else 1
+            bottom_element = matrix[row + 1][col] if row < len(matrix) - 1 else 1
+            top_element = matrix[row - 1][col] if row > 0 else 1
+
+            if dfs_table[row][col] != 1:
+                return
+
+            if top_element > current_element:
+                self.find_longest_path(
+                    matrix, dfs_table, row - 1, col, current_length + 1
+                )  # top
+            if bottom_element > current_element:
+                self.find_longest_path(
+                    matrix, dfs_table, row + 1, col, current_length + 1
+                )
+            if right_element > current_element:
+                self.find_longest_path(
+                    matrix, dfs_table, row, col + 1, current_length + 1
+                )
+            if left_element > current_element:
+                self.find_longest_path(
+                    matrix, dfs_table, row, col - 1, current_length + 1
+                )
+
+            dfs_left = (
+                dfs_table[row][col - 1]
+                if col > 0 and matrix[row][col - 1] > matrix[row][col]
+                else 0
+            )
+            dfs_right = (
+                dfs_table[row][col + 1]
+                if col < len(matrix[0]) - 1 and matrix[row][col + 1] > matrix[row][col]
+                else 0
+            )
+            dfs_bottom = (
+                dfs_table[row + 1][col]
+                if row < len(matrix) - 1 and matrix[row + 1][col] > matrix[row][col]
+                else 0
+            )
+            dfs_top = (
+                dfs_table[row - 1][col]
+                if row > 0 and matrix[row - 1][col] > matrix[row][col]
+                else 0
+            )
+            dfs_table[row][col] = (
+                max(dfs_left, max(dfs_right, max(dfs_bottom, dfs_top))) + 1
+            )
+
+
+if __name__ == "__main__":
+    sol = Solution()
+    a = [[9, 9, 4], [6, 6, 8], [2, 1, 1]]
+    print(sol.longestIncreasingPath(a))

tsProblems/cleanString/cleanString.js

@@ -0,0 +1,22 @@
+"use strict";
+exports.__esModule = true;
+exports.cleanString = void 0;
+function cleanString(s) {
+    var stack = [];
+    for (var i = 0; i < s.length; i++) {
+        switch (s[i]) {
+            case "#": {
+                stack = stack.slice(0, -1);
+                break;
+            }
+            default: {
+                stack.push(s[i]);
+                break;
+            }
+        }
+    }
+    return stack.join("");
+}
+exports.cleanString = cleanString;
+console.log(cleanString("abc##d######"));
+console.log(cleanString("abc#d##c"));

tsProblems/cleanString/cleanString.ts

@@ -0,0 +1,19 @@
+export function cleanString(s: string): string {
+  let stack: string[] = [];
+  for (let i = 0; i < s.length; i++) {
+    switch (s[i]) {
+      case "#": {
+        stack = stack.slice(0, -1);
+        break;
+      }
+      default: {
+        stack.push(s[i]);
+        break;
+      }
+    }
+  }
+  return stack.join("");
+}
+
+console.log(cleanString("abc##d######"));
+console.log(cleanString("abc#d##c"));

tsProblems/divisibilityBy7/divisibilityBy7.js

@@ -0,0 +1,17 @@
+"use strict";
+exports.__esModule = true;
+exports.seven = void 0;
+function seven(m) {
+  var steps = 0;
+  var result = m;
+  while (result > 99) {
+    var mstr = result.toString();
+    var last_digit = mstr.slice(-1);
+    var remaining = mstr.slice(0, -1);
+    result = Number.parseInt(remaining) - Number.parseInt(last_digit) * 2;
+    steps++;
+  }
+  return [result, steps];
+}
+exports.seven = seven;
+console.log(seven(477557101));

tsProblems/divisibilityBy7/divisibilityBy7.ts

@@ -0,0 +1,14 @@
+export function seven(m: number): number[] {
+  let steps = 0;
+  let result = m;
+  while (result > 99) {
+    const mstr = result.toString();
+    const last_digit = mstr.slice(-1);
+    const remaining = mstr.slice(0, -1);
+    result = Number.parseInt(remaining) - Number.parseInt(last_digit) * 2;
+    steps++;
+  }
+  return [result, steps];
+}
+
+console.log(seven(1021));

tsProblems/hoopCount/hoopCount.ts

@@ -0,0 +1,5 @@
+export function hoopCount(n: number): string {
+  return n > 10
+    ? "Great, now move on to tricks"
+    : "Keep at it until you get it";
+}