[main] hello

cthacker-udel · cthacker-udel · commit 7a7b7f9fbc30 · 2022-11-19T13:22:06.000-05:00
diff --git a/csharpProblems/GetDrinkByProfession/obj/Debug/net6.0/GetDrinkByProfession.assets.cache b/csharpProblems/GetDrinkByProfession/obj/Debug/net6.0/GetDrinkByProfession.assets.cache
diff --git a/csharpProblems/GroupWhile/obj/Debug/net6.0/GroupWhile.assets.cache b/csharpProblems/GroupWhile/obj/Debug/net6.0/GroupWhile.assets.cache
diff --git a/csharpProblems/Position/obj/Debug/net6.0/Position.assets.cache b/csharpProblems/Position/obj/Debug/net6.0/Position.assets.cache
diff --git a/csharpProblems/RemoveDuplicateWords/obj/Debug/net6.0/RemoveDuplicateWords.assets.cache b/csharpProblems/RemoveDuplicateWords/obj/Debug/net6.0/RemoveDuplicateWords.assets.cache
diff --git a/csharpProblems/ReplaceDots/obj/Debug/net6.0/ReplaceDOts.assets.cache b/csharpProblems/ReplaceDots/obj/Debug/net6.0/ReplaceDOts.assets.cache
diff --git a/csharpProblems/Take/obj/Debug/net6.0/Take.assets.cache b/csharpProblems/Take/obj/Debug/net6.0/Take.assets.cache
diff --git a/pythonProblems/dp/dbl_linear.py b/pythonProblems/dp/dbl_linear.py
@@ -0,0 +1,32 @@
+from typing import List
+
+
+def dbl_linear(n: int) -> List[int]:
+    """
+
+    Args:
+        n (_type_): _description_
+    """
+    seq = [1]
+    ind = 0
+    gen_numbers = 1
+    y_array = []
+    z_array = []
+    while len(seq) < n:
+        for eachnum in seq[ind: ind + gen_numbers]:
+            y_array.append(2 * eachnum + 1)
+        for eachnum in seq[ind: ind + gen_numbers]:
+            z_array.append(3 * eachnum + 1)
+        ind += gen_numbers
+        gen_numbers = ind + (gen_numbers * 2) - ind
+        seq.extend(y_array)
+        seq.extend(z_array)
+        y_array = []
+        z_array = []
+    return seq[u]
+    # u = [1, 3, 4, 7, 9, 10, 13, 15, 19, 21, 22, 27, ...]
+
+
+if __name__ == '__main__':
+    u = 10
+    dbl_linear(u)
diff --git a/pythonProblems/dp/diffutil.py b/pythonProblems/dp/diffutil.py
@@ -0,0 +1,37 @@
+
+from pprint import pprint
+
+
+def diff_utility(str1: str, str2: str) -> None:
+    table = []
+    for _ in str1:
+        table_row = []
+        for __ in str2:
+            table_row.append(0)
+        table.append(table_row)
+        table_row = []
+
+    for i in range(len(str1)):
+        for j in range(len(str2)):
+            if str1[i] == str2[j]:
+                table[i][j] = 0
+            else:
+                top_value, left_value, right_value, bottom_value = float(
+                    'inf'), float('inf'), float('inf'), float('inf')
+                if i > 0:
+                    top_value = table[i - 1][j]
+                if j > 0:
+                    left_value = table[i][j - 1]
+                if j < len(table[i]) - 1:
+                    right_value = table[i][j + 1]
+                if i < len(table) - 1:
+                    bottom_value = table[i + 1][j]
+                table[i][j] = min(top_value, left_value,
+                                  right_value, bottom_value) + 1
+    pprint(table)
+
+
+if __name__ == '__main__':
+    x = 'XMJYAUZ'
+    y = 'XMJAATZ'
+    diff_utility(x, y)
diff --git a/pythonProblems/dp/ilyaqueries.py b/pythonProblems/dp/ilyaqueries.py
@@ -0,0 +1,14 @@
+
+
+if __name__ == '__main__':
+    query_string = input()
+    num_queries = int(input())
+    for eachquery in range(num_queries):
+        s_f = input().split(" ")
+        start = int(s_f[0])
+        finish = int(s_f[1])
+        count = 0
+        for i in range(start - 1, finish - 1):
+            if query_string[i] == query_string[i + 1]:
+                count += 1
+        print(count)
diff --git a/pythonProblems/dp/isValidSudoku.py b/pythonProblems/dp/isValidSudoku.py
@@ -0,0 +1,53 @@
+from typing import List
+
+
+class Solution:
+    def isValidSudoku(self, board: List[List[str]]) -> bool:
+        for eachrow in board:
+            row_values = []
+            for eachvalue in eachrow:
+                if eachvalue != '.' and eachvalue.isnumeric():
+                    row_values.append(int(eachvalue))
+            if len(set(row_values)) != len(row_values):
+                print('row')
+                return False
+        for i in range(len(board)):
+            column_values = []
+            for j in range(len(board[i])):
+                if board[j][i] != '.' and board[j][i].isnumeric():
+                    column_values.append(int(board[j][i]))
+            if len(set(column_values)) != len(column_values):
+                print('col')
+                return False
+        for i in range(0, len(board) - 2, 3):
+            grid_values = []
+            # controls row traversal
+            for j in range(0, len(board[i]) - 2, 3):
+                grid_values = []
+                for k in range(j, j + 3):
+                    # controls inner row traversal
+                    if board[i][k] != '.':
+                        grid_values.append(int(board[i][k]))
+                    if board[i + 1][k] != '.':
+                        grid_values.append(int(board[i + 1][k]))
+                    if board[i + 2][k] != '.':
+                        grid_values.append(int(board[i + 2][k]))
+                if len(set(grid_values)) != len(grid_values):
+                    print('grid', grid_values)
+                    return False
+        return True
+
+
+if __name__ == '__main__':
+    board = [
+            [".", ".", ".", ".", ".", ".", "5", ".", "."],
+            [".", ".", ".", ".", ".", ".", ".", ".", "."],
+            [".", ".", ".", ".", ".", ".", ".", ".", "."],
+            ["9", "3", ".", ".", "2", ".", "4", ".", "."],
+            [".", ".", "7", ".", ".", ".", "3", ".", "."],
+            [".", ".", ".", ".", ".", ".", ".", ".", "."],
+            [".", ".", ".", "3", "4", ".", ".", ".", "."],
+            [".", ".", ".", ".", ".", "3", ".", ".", "."],
+            [".", ".", ".", ".", ".", "5", "2", ".", "."]]
+    sol = Solution()
+    print(sol.isValidSudoku(board))
diff --git a/pythonProblems/dp/largest1BorderSquare.py b/pythonProblems/dp/largest1BorderSquare.py
@@ -0,0 +1,10 @@
+from typing import List
+
+
+class Solution:
+    def largest1BorderedSquare(self, grid: List[List[int]]) -> int:
+        ones_index = []
+        for i in range(len(grid)):
+            for j in range(len(grid[i])):
+                if grid[i][j] == 1:
+                    ones_index.append((i, j))
diff --git a/pythonProblems/dp/lcs.py b/pythonProblems/dp/lcs.py
@@ -0,0 +1,2 @@
+def lcs(sub1: str, sub2: str) -> str:
+    pass
diff --git a/pythonProblems/dp/longestRepeatingSubsequence.py b/pythonProblems/dp/longestRepeatingSubsequence.py
@@ -0,0 +1,36 @@
+
+from pprint import pprint
+
+
+def longest_repeating_subsequence(astr: str) -> int:
+    """
+    Finds the longest repeating subsequence of a str
+
+    Args:
+        astr (str): The string to find the longest subsequence of
+
+    Returns:
+        int: the longest subsequence
+    """
+    table = []
+    for _ in astr:
+        table_row = []
+        for __ in astr:
+            table_row.append(0)
+        table.append(table_row)
+        table_row = []
+
+    for i in range(len(astr)):
+        for j in range(len(astr)):
+            if i == 0 or j == 0:
+                continue
+            elif astr[i - 1] == astr[j - 1] and i != j:
+                table[i][j] = table[i - 1][j - 1] + 1
+            else:
+                table[i][j] = max(table[i - 1][j], table[i][j - 1])
+    return max(max(row) for row in table)
+
+
+if __name__ == '__main__':
+    substr = 'ATACTCGGA'
+    print(longest_repeating_subsequence(substr))
diff --git a/pythonProblems/dp/maxPalindromicSubsequenceLength.py b/pythonProblems/dp/maxPalindromicSubsequenceLength.py
@@ -0,0 +1,23 @@
+from pprint import pprint
+
+dp = {}
+
+
+def maxPalindromicSubsequenceLength(astr: str) -> int:
+    if len(astr) <= 1:
+        return len(astr)
+    if astr in dp:
+        return dp[astr]
+    if astr[0] != astr[-1]:
+        result = max(maxPalindromicSubsequenceLength(
+            astr[:-1]), maxPalindromicSubsequenceLength(astr[1:]))
+        dp[astr] = result
+        return result
+    result = 2 + maxPalindromicSubsequenceLength(astr[1:len(astr) - 1])
+    dp[astr] = result
+    return result
+
+
+if __name__ == '__main__':
+    astr = 'ABBDCACB'
+    print(maxPalindromicSubsequenceLength(astr))
diff --git a/pythonProblems/dp/stonesWinner.py b/pythonProblems/dp/stonesWinner.py
@@ -0,0 +1,21 @@
+
+from typing import List
+
+
+def solve_stones(num_piles: int, stone_piles: List[int]) -> str:
+    if num_piles % 2 != 0 and num_piles > 0:  # is number of stone piles odd
+        return "Mike"
+    if stone_piles == 0:
+        return "Joe"
+    min_elem = min(stone_piles)
+    if stone_piles.index(min_elem) % 2 != 0:  # if it's odd, Mike loses
+        return "Mike"
+    else:
+        return "Joe"
+
+
+if __name__ == '__main__':
+    num_test_cases = int(input())
+    for _ in range(num_test_cases):
+        num_piles, piles = int(input()), [int(x) for x in input().split(" ")]
+        print(solve_stones(num_piles, piles))
diff --git a/pythonProblems/dp/sudokuSolver.py b/pythonProblems/dp/sudokuSolver.py
@@ -0,0 +1,62 @@
+from pprint import pprint
+from typing import List
+
+
+class Solution:
+    """
+    """
+
+    def solveSudoku(self, board: List[List[str]]) -> None:
+        """
+        Do not return anything, modify board in-place instead.
+        """
+        for i in range(0, len(board) - 2, 3):
+            grid_values = []
+            # controls row traversal
+            for j in range(0, len(board[i]) - 2, 3):
+                grid_values = []
+                for k in range(j, j + 3):
+                    # controls inner row traversal
+                    grid_values.append([board[i][k], (i, k)])
+                    grid_values.append([board[i + 1][k], (i + 1, k)])
+                    grid_values.append([board[i + 2][k], (i + 2, k)])
+                for eachcoord in grid_values:
+                    if eachcoord[0] == '.':
+                        coord_y = eachcoord[1][0]
+                        coord_x = eachcoord[1][1]
+                        # analyze column, row, and then grid values
+                        for eachnum in range(1, 10):
+                            if len([x for x in grid_values if x[0] == str(eachnum)]) == 0:
+                                # number is not in grid, analyze row values
+                                row_values = []
+                                for eachnumber in board[coord_y]:
+                                    if eachnumber != '.':
+                                        row_values.append(eachnumber)
+                                if eachnum not in row_values:
+                                    col_values = []
+                                    for eachrow in board:
+                                        if eachrow[coord_x] != '.':
+                                            col_values.append(
+                                                eachrow[coord_x])
+                                    if str(eachnum) not in col_values:
+                                        board[coord_y][coord_x] = str(eachnum)
+                                        eachcoord[0] = str(eachnum)
+                                        break
+                                else:
+                                    break
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    bd = [
+        ["5", "3", ".", ".", "7", ".", ".", ".", "."],
+        ["6", ".", ".", "1", "9", "5", ".", ".", "."],
+        [".", "9", "8", ".", ".", ".", ".", "6", "."],
+        ["8", ".", ".", ".", "6", ".", ".", ".", "3"],
+        ["4", ".", ".", "8", ".", "3", ".", ".", "1"],
+        ["7", ".", ".", ".", "2", ".", ".", ".", "6"],
+        [".", "6", ".", ".", ".", ".", "2", "8", "."],
+        [".", ".", ".", "4", "1", "9", ".", ".", "5"],
+        [".", ".", ".", ".", "8", ".", ".", "7", "9"]]
+    sol.solveSudoku(bd)
+    pprint(bd)
diff --git a/pythonProblems/dp/vogon.py b/pythonProblems/dp/vogon.py
@@ -0,0 +1,20 @@
+def vogon(arr_len: int, destroyer_machine_cost: int):
+    planets = [int(x) for x in input().split(" ")]
+    orbit_map = {}
+    for eachplanet in planets:  # O(n)
+        if eachplanet in orbit_map:
+            orbit_map[eachplanet] += 1
+        else:
+            orbit_map[eachplanet] = 1
+    min_cost = 0
+    for eachkey in orbit_map:
+        min_cost += destroyer_machine_cost if destroyer_machine_cost < orbit_map[eachkey] else orbit_map[eachkey]
+    return min_cost
+
+
+if __name__ == '__main__':
+    test_cases = int(
+        input())
+    for i in range(test_cases):
+        arr_len, machine_cost = [int(x) for x in input().split(" ")]
+        print(vogon(arr_len, machine_cost))
diff --git a/pythonProblems/findus/findus.py b/pythonProblems/findus/findus.py
@@ -0,0 +1,65 @@
+from typing import List
+
+
+def find_us(n1: int, n2: int, k: int, prime_factors: List[int], digits: List[int]):
+    """
+    """
+    def generate_permutations(astr: str, permutes: List[str] | None = None, ind: int = 0) -> List[str]:
+        """
+        """
+        if permutes is None:
+            permutes = []
+        if ind == len(astr):
+            return permutes
+        for i in range(len(astr)):
+            modified_str = list(astr)
+            modified_str[i], modified_str[ind] = modified_str[ind], modified_str[i]
+            found_permutes = generate_permutations(
+                ''.join(modified_str), permutes + [''.join(modified_str)], ind + 1)
+            for eachpermute in found_permutes:
+                if not eachpermute in permutes:
+                    permutes.extend([eachpermute])
+        return permutes
+    start = n1
+    end = n1 + (k * n2)
+    end_str = str(end)
+    end_str_len = len(end_str)
+    numbers = []
+    start_digit = end_str[0]
+    if len(digits) == end_str_len:
+        # digits is number of digits in end, only permute digits to find numerical values
+        pass
+    else:
+        # travel down the possible iterations, counting the # of digits, such as if the end is
+        # 300, we go 300, 200, 100. For 5000, we go 5000, 4000, 3000, 2000, 1000, then decrement the # of digits to 3, going
+        # 900, 800, 700, and so on. Checking if the digits are within the number
+        base_number = ''.join([str(x) for x in digits])
+        gathered_perms = []
+        starting_number = base_number
+        while len(digits) <= end_str_len:
+            while len(starting_number) < end_str_len - 1:
+                starting_number += '0'
+            starting_perms = generate_permutations(
+                end_str[0] + starting_number)
+            for eachperm in starting_perms:
+                intified_perm = int(''.join(eachperm))
+                if intified_perm < end and intified_perm > start:
+                    gathered_perms.append(intified_perm)
+            starting_number = base_number
+            end_str_len -= 1
+        base_perms = generate_permutations(base_number)
+        print(gathered_perms)
+
+
+if __name__ == '__main__':
+
+    astr = 'hello'
+    # 1 2 3 | 1 3 2 | 2 1 3 | 2 3 1 | 3 1 2 | 3 2 1
+    print(find_us(30, 400, 18, [2, 3, 7], [6, 2, 5]))
+
+    # n1 = 30
+    # n2 = 400
+    # k = 18
+    # prime_factors = [2, 3, 7]
+    # digits = [6, 2, 5]
+    # find_us(n1, n2, k, prime_factors, digits)
