Add files via upload

Author: PankajJ08

excel_id.py

@@ -0,0 +1,17 @@
+"""Given a column number, return its alphabetical column id.
+For example, given 1, return "A". Given 27, return "AA"."""
+
+
+def return_id(num, char_set):
+    "Function that return the column id of a given number."
+    ans = ""
+    while num:
+        a = num % 26
+        num //= 26
+        ans += char_set[a - 1]
+    return ans[::-1]
+
+
+charset = [chr(i) for i in range(65, 91)]
+n = 100000767
+print(return_id(n, charset))

execute_me_last.py

@@ -0,0 +1,74 @@
+"""---- Josephus Problem ----
+
+There are N prisoners standing in a circle, waiting to be executed.
+The executions are carried out starting with the kth person,
+and removing every successive kth person going clockwise until there is no one left.
+
+Given N and k, write an algorithm to determine where a prisoner should stand
+in order to be the last survivor.
+
+For example, if N = 5 and k = 2, the order of executions would be [2, 4, 1, 5, 3],
+so you should return 3.
+
+Bonus: Find an O(log N) solution if k = 2."""
+import math
+
+
+def last_man_standing(n, k):
+    if n == 1:
+        return 1
+
+    return (last_man_standing(n - 1, k) + (k-1)) % n + 1
+
+
+def last_man_standing_iteratively(n, k):
+    p = 1
+    for i in range(2, n + 1):
+        p = (p + k - 1) % i + 1
+
+    return p
+
+
+def josephus_problem(n):
+    """Method to solve a special case when k = 2.
+    The recurrence is given by:
+    f(n) = 2f(n/2) + 1      ---- for n is even.
+    f(n) = 2f(n-1 /2) + 1   ---- for n is odd.
+    It is solvable by f(n) = 2L + 1 where L = n - 2 ^ floor(log n)."""
+
+    # if n == 1:
+    #     return 1
+    #
+    # return 2 * (n - 2 ** math.floor(math.log2(n))) + 1
+
+    p = 1
+    for i in range(2, n + 1):
+        p = 2 * (i - 2 ** math.floor(math.log2(i))) + 1
+
+    return p
+
+
+def most_significant_bit(n):
+    a = 0
+    while n != 1:
+        n >>= 1
+        a += 1
+    return a
+
+
+def bitwise_jp_solution(n):
+    """X = n - 2^a
+    ans = 2X + 1"""
+    a = most_significant_bit(n)
+    x = n ^ (1 << a)
+    ans = (x << 1) | 1
+
+    return ans
+
+
+N = 500
+K = 2
+# print(last_man_standing(N, K))
+print(last_man_standing_iteratively(N, K))
+print(josephus_problem(N))
+print(bitwise_jp_solution(N))

game_strategy.py

@@ -0,0 +1,34 @@
+"""You are asked to play the following game. You and an opponent take turns choosing either
+the first or last coin from the row, removing from the row, and receiving the value of the coin.
+
+Write a program that returns the maximum amount of money you can win with certainty,
+if you move first, assuming your opponent plays optimally."""
+
+
+def optimal_strategy(arr):
+    n = len(arr)
+    table = [["-" for _ in range(n)]
+             for _ in range(n)]
+
+    for spaces in range(n):
+        for j in range(spaces, n):
+            i = j - spaces
+
+            x, y, z = 0, 0, 0
+
+            if i + 2 <= j:
+                x = table[i + 2][j]
+
+            if i + 1 <= j - 1:
+                y = table[i + 1][j - 1]
+
+            if i <= j - 2:
+                z = table[i][j - 2]
+
+            table[i][j] = max(arr[i] + min(x, y), arr[j] + min(y, z))
+
+    return table[0][n - 1]
+
+
+values = [8, 15, 7, 1]
+print(optimal_strategy(values))

longest_con_seq.py

@@ -0,0 +1,32 @@
+"""Given an unsorted array of integers,
+find the length of the longest consecutive elements sequence.
+
+For example, given [100, 4, 200, 1, 3, 2],
+the longest consecutive element sequence is [1, 2, 3, 4]. Return its length: 4.
+
+Your algorithm should run in O(n) complexity.
+"""
+
+
+def lcs(arr):
+    """Function to return the longest consecutive sequence in the given array."""
+    ans = 0
+    s = set()
+
+    for i in arr:
+        s.add(i)
+
+    for i in range(len(seq)):
+        if arr[i] - 1 not in s:
+            j = arr[i]
+
+            while j in s:
+                j += 1
+
+            ans = max(ans, j - arr[i])
+
+    return ans
+
+
+seq = [100, 4, 200, 1, 3, 2]
+print("Longest consecutive sequence = ", lcs(seq))

longest_inc_seq.py

@@ -0,0 +1,44 @@
+"""Given an array of numbers, find the length of the longest increasing subsequence in the array.
+The subsequence does not necessarily have to be contiguous.
+
+For example, given the array [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15],
+the longest increasing subsequence has length 6: it is 0, 2, 6, 9, 11, 15."""
+
+
+def lis_v1(arr, n, max_len=1):
+    """Recursive function to find longest increasing subsequence in the given array."""
+    max_end = 1
+
+    if n == 1:
+        return 1
+
+    for i in range(1, n):
+        res = lis_v1(arr, i, max_len)
+
+        if arr[i - 1] < arr[n - 1] and max_end < res + 1:
+            max_end = res + 1
+
+    max_len = max(max_len, max_end)
+
+    return max_len
+
+
+def lis_v2(arr, n):
+    """Function based on Dynamic Programming to return longest increasing subsequence."""
+    lis = [1] * n
+
+    for i in range(1, n):
+        for j in range(0, i):
+            if arr[i] > arr[j] and lis[i] < lis[j] + 1:
+                lis[i] = lis[j] + 1
+
+    max_len = 0
+
+    for i in range(n):
+        max_len = max(max_len, lis[i])
+
+    return max_len
+
+
+seq = [0, 1, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 10, 11, 15]
+print("Maximum increasing subsequence = ", lis_v2(seq, len(seq)))

make_it_large.py

@@ -0,0 +1,28 @@
+"""Given a list of numbers, create an algorithm that arranges them
+in order to form the largest possible integer.
+For example, given [10, 7, 76, 415], you should return 77641510."""
+from functools import cmp_to_key as cmp_k
+
+
+def compare_it(a, b):
+    new_a = int(str(a) + str(b))
+    new_b = int(str(b) + str(a))
+
+    return new_a - new_b
+
+
+def largest_no(arr):
+    x = [str(i) for i in sorted(arr, key=cmp_k(compare_it), reverse=True)]
+    return "".join(x)
+
+
+def alternate_way(arr):
+    n = len(str(max(arr)))
+    extend_arr = [(str(i)*n, i) for i in arr]
+    extend_arr.sort(reverse=True)
+    return "".join([str(i[1]) for i in extend_arr])
+
+
+inp = [777, 0, 761, 4152]
+print(largest_no(inp))
+print(alternate_way(inp))

max_circular_sum.py

@@ -0,0 +1,36 @@
+"""Given a circular array, compute its maximum subarray sum in O(n) time.
+
+For example, given [8, -1, 3, 4], return 15 as we choose the numbers 3, 4,
+and 8 where the 8 is obtained from wrapping around."""
+
+
+def kadane_sum(arr):
+    n = len(arr)
+    max_sum = arr[0]
+    max_curr = arr[0]
+
+    for i in range(1, n):
+        max_curr = max(arr[i] + max_curr, arr[i])
+        max_sum = max(max_sum, max_curr)
+
+    return max_sum
+
+
+def circular_sum(arr):
+    max_kadane = kadane_sum(arr)
+    max_wrap = 0
+
+    for i in range(len(arr)):
+        max_wrap += arr[i]
+        arr[i] = -arr[i]
+
+    max_wrap += kadane_sum(arr)
+
+    if max_kadane > max_wrap or not max_wrap:
+        return max_kadane
+    else:
+        return max_wrap
+
+
+a = [-8, 2, -1, -5]
+print(circular_sum(a))

minimun_subset_sum.py

@@ -0,0 +1,56 @@
+"""Given an array of positive integers, divide the array into two subsets such that
+the difference between the sum of the subsets is as small as possible.
+And return the difference.
+
+For example, given [5, 10, 15, 20, 25], return the sets {10, 25} and {5, 15, 20},
+which has a difference of 5, which is the smallest possible difference"""
+import sys
+
+
+def find_min_recursive(arr, i, total_sum, first_sum):
+    """Recursive Solution"""
+    if not i:
+        return abs(total_sum - 2*first_sum)
+
+    return min(find_min_recursive(arr, i - 1, total_sum, first_sum + arr[i - 1]),
+               find_min_recursive(arr, i - 1, total_sum, first_sum))
+
+
+def find_min(arr):
+    n = len(arr)
+    first_sum = 0
+
+    total_sum = sum(arr)
+
+    return find_min_recursive(arr, n, total_sum, first_sum)
+
+
+def dp_solution(arr):
+    """Solution using dynamic programming"""
+    n = len(arr)
+    sum_total = sum(arr)
+
+    dp = [[False for _ in range(sum_total//2 + 1)]
+          for _ in range(n + 1)]
+
+    for i in range(n + 1):
+        dp[i][0] = True
+
+    for i in range(1, n + 1):
+        for j in range(1, sum_total//2 + 1):
+            dp[i][j] = dp[i - 1][j]
+            if arr[i - 1] <= j:
+                dp[i][j] |= dp[i - 1][j - arr[i - 1]]
+
+    ans = sys.maxsize
+    for j in range(sum_total // 2, -1, -1):
+        if dp[n][j]:
+            ans = sum_total - 2*j
+            break
+
+    return ans
+
+
+a = [3, 7, 12, 15, 25, 45]
+# print(find_min(a))
+print(dp_solution(a))

no_same_please.py

@@ -0,0 +1,26 @@
+"""Given a string with repeated characters, rearrange the string so that no two
+adjacent characters are the same. If this is not possible, return None.
+
+For example, given "aaabbc", you could return "ababac". Given "aaab", return None."""
+from collections import defaultdict
+
+
+def no_same_char(string):
+    ans = ""
+
+    store = defaultdict(int)
+    for i in string:
+        store[i] += 1
+
+    for j in store:
+        if store[j]:
+            if ans and j == ans[-1]:
+                return None
+            ans += j
+            store[j] -= 1
+
+    return ans
+
+
+a = "aaab"
+print(no_same_char(a))

overlapping_intervals.py

@@ -0,0 +1,33 @@
+"""Given a list of possibly overlapping intervals,
+return a new list of intervals where all overlapping intervals have been merged."""
+
+
+class Intervals:
+    """class of intervals having start and end point."""
+    def __init__(self, s=0, e=0):
+        """Initializer method for Intervals."""
+        self.start = s
+        self.end = e
+
+    def __repr__(self):
+        """Function to return a list with start and end points."""
+        return "[{}, {}]".format(self.start, self.end)
+
+
+class Solution:
+    """class to find a overlapping intervals."""
+    def merge(self, intervals):
+        intervals = sorted(intervals, key=lambda x: x.start)
+        out = []
+
+        for i in intervals:
+            if out and i.start <= out[-1].end:
+                out[-1].end = max(out[-1].end, i.end)
+            else:
+                out.append(i)
+
+        return out
+
+
+interval = [Intervals(1, 2), Intervals(6, 11), Intervals(0, 5), Intervals(7, 9), Intervals(1, 2)]
+print(Solution().merge(interval))