mycompetitiveprogramming journey in python

Author: gauraviuiux

__init__.py

@@ -0,0 +1,10 @@
+n=int(input())
+arr=list(map(int,input().split()))
+dp=[0 for i in range(n)]
+length=0
+for i in range(n):
+	for j in range(n):
+		if abs(arr[j])<abs(arr[i])and arr[i]*arr[j]<0:
+			length=max(length,dp[j])
+		dp[i]=length+1
+print(dp[n])

alternatesequencesoppj.py

@@ -0,0 +1,18 @@
+from .delete_nth import *
+from .flatten import *
+from .garage import *
+from .josephus import *
+from .longest_non_repeat import *
+from .max_ones_index import *
+from .merge_intervals import *
+from .missing_ranges import *
+from .move_zeros import *
+from .plus_one import *
+from .rotate import *
+from .summarize_ranges import *
+from .three_sum import *
+from .trimmean import *
+from .top_1 import *
+from .two_sum import *
+from .limit import *
+from .n_sum import *

arrays/__init__.py

@@ -0,0 +1,32 @@
+"""
+Given a list lst and a number N, create a new list
+that contains each number of the list at most N times without reordering.
+
+For example if N = 2, and the input is [1,2,3,1,2,1,2,3], you take [1,2,3,1,2], 
+drop the next [1,2] since this would lead to 1 and 2 being in the result 3 times, and then take 3, 
+which leads to [1,2,3,1,2,3]
+"""
+import collections
+
+
+# Time complexity O(n^2)
+def delete_nth_naive(array, n):
+    ans = []
+    for num in array:
+        if ans.count(num) < n:
+            ans.append(num)
+    return ans
+
+
+# Time Complexity O(n), using hash tables.
+def delete_nth(array, n):
+    result = []
+    counts = collections.defaultdict(int)  # keep track of occurrences
+
+    for i in array:
+
+        if counts[i] < n:
+            result.append(i)
+            counts[i] += 1
+
+    return result

arrays/delete_nth.py

@@ -0,0 +1,31 @@
+"""
+Implement Flatten Arrays.
+Given an array that may contain nested arrays,
+produce a single resultant array.
+"""
+from collections.abc import Iterable
+
+
+# return list
+def flatten(input_arr, output_arr=None):
+    if output_arr is None:
+        output_arr = []
+    for ele in input_arr:
+        if isinstance(ele, Iterable):
+            flatten(ele, output_arr)    #tail-recursion
+        else:
+            output_arr.append(ele)      #produce the result
+    return output_arr
+
+
+# returns iterator
+def flatten_iter(iterable):
+    """
+    Takes as input multi dimensional iterable and
+    returns generator which produces one dimensional output.
+    """
+    for element in iterable:
+        if isinstance(element, Iterable):
+            yield from flatten_iter(element)    
+        else:
+            yield element

arrays/flatten.py

@@ -0,0 +1,68 @@
+"""
+There is a parking lot with only one empty spot. Given the initial state
+of the parking lot and the final state. Each step we are only allowed to
+move a car
+out of its place and move it into the empty spot.
+The goal is to find out the least movement needed to rearrange
+the parking lot from the initial state to the final state.
+
+Say the initial state is an array:
+
+[1, 2, 3, 0, 4],
+where 1, 2, 3, 4 are different cars, and 0 is the empty spot.
+
+And the final state is
+
+[0, 3, 2, 1, 4].
+We can swap 1 with 0 in the initial array to get [0, 2, 3, 1, 4] and so on.
+Each step swap with 0 only.
+
+Edit:
+Now also prints the sequence of changes in states.
+Output of this example :-
+
+initial: [1, 2, 3, 0, 4]
+final:   [0, 3, 2, 1, 4]
+Steps =  4
+Sequence : 
+0 2 3 1 4
+2 0 3 1 4
+2 3 0 1 4
+0 3 2 1 4
+"""
+
+
+def garage(initial, final):
+
+    initial = initial[::]      # prevent changes in original 'initial'
+    seq = []                   # list of each step in sequence
+    steps = 0
+    while initial != final:
+        zero = initial.index(0)
+        if zero != final.index(0):  # if zero isn't where it should be,
+            car_to_move = final[zero]   # what should be where zero is,
+            pos = initial.index(car_to_move)         # and where is it?
+            initial[zero], initial[pos] = initial[pos], initial[zero]
+        else:
+            for i in range(len(initial)):
+                if initial[i] != final[i]:
+                    initial[zero], initial[i] = initial[i], initial[zero]
+                    break
+        seq.append(initial[::])
+        steps += 1
+
+    return steps, seq       
+    # e.g.:  4, [{0, 2, 3, 1, 4}, {2, 0, 3, 1, 4}, 
+    #            {2, 3, 0, 1, 4}, {0, 3, 2, 1, 4}]
+
+"""
+thus:
+1 2 3 0 4 -- zero = 3, true, car_to_move = final[3] = 1,
+             pos = initial.index(1) = 0, switched [0], [3]
+0 2 3 1 4 -- zero = 0, f, initial[1] != final[1], switched 0,1
+2 0 3 1 4 -- zero = 1, t, car_to_move = final[1] = 3,
+             pos = initial.index(3) = 2, switched [1], [2]
+2 3 0 1 4 -- zero = 2, t, car_to_move = final[2] = 2, 
+             pos = initial.index(2) = 0, switched [0], [2]
+0 3 2 1 4 -- initial == final
+"""

arrays/garage.py

@@ -0,0 +1,20 @@
+"""
+There are people sitting in a circular fashion,
+print every third member while removing them,
+the next counter starts immediately after the member is removed.
+Print till all the members are exhausted.
+
+For example:
+Input: consider 123456789 members sitting in a circular fashion,
+Output: 369485271
+"""
+
+
+def josephus(int_list, skip):
+    skip = skip - 1                     # list starts with 0 index
+    idx = 0
+    len_list = (len(int_list))
+    while len_list > 0:
+        idx = (skip + idx) % len_list   # hash index to every 3rd
+        yield int_list.pop(idx)
+        len_list -= 1

arrays/josephus.py

@@ -0,0 +1,20 @@
+"""
+Sometimes you need to limit array result to use. Such as you only need the 
+ value over 10 or, you need value under than 100. By use this algorithms, you
+ can limit your array to specific value
+
+If array, Min, Max value was given, it returns array that contains values of 
+ given array which was larger than Min, and lower than Max. You need to give
+ 'unlimit' to use only Min or Max.
+
+ex) limit([1,2,3,4,5], None, 3) = [1,2,3]
+
+Complexity = O(n)
+"""
+
+# tl:dr -- array slicing by value
+def limit(arr, min_lim=None, max_lim=None):
+    min_check = lambda val: True if min_lim is None else (min_lim <= val)
+    max_check = lambda val: True if max_lim is None else (val <= max_lim)
+    
+    return [val for val in arr if min_check(val) and max_check(val)]

arrays/limit.py

@@ -0,0 +1,91 @@
+"""
+Given a string, find the length of the longest substring
+without repeating characters.
+
+Examples:
+Given "abcabcbb", the answer is "abc", which the length is 3.
+Given "bbbbb", the answer is "b", with the length of 1.
+Given "pwwkew", the answer is "wke", with the length of 3.
+Note that the answer must be a substring,
+"pwke" is a subsequence and not a substring.
+"""
+
+
+def longest_non_repeat_v1(string):
+    """
+    Find the length of the longest substring
+    without repeating characters.
+    """
+    if string is None:
+        return 0
+    dict = {}
+    max_length = 0
+    j = 0
+    for i in range(len(string)):
+        if string[i] in dict:
+            j = max(dict[string[i]], j)
+        dict[string[i]] = i + 1
+        max_length = max(max_length, i - j + 1)
+    return max_length
+
+def longest_non_repeat_v2(string):
+    """
+    Find the length of the longest substring
+    without repeating characters.
+    Uses alternative algorithm.
+    """
+    if string is None:
+        return 0
+    start, max_len = 0, 0
+    used_char = {}
+    for index, char in enumerate(string):
+        if char in used_char and start <= used_char[char]:
+            start = used_char[char] + 1
+        else:
+            max_len = max(max_len, index - start + 1)
+        used_char[char] = index
+    return max_len
+
+# get functions of above, returning the max_len and substring
+def get_longest_non_repeat_v1(string):
+    """
+    Find the length of the longest substring
+    without repeating characters.
+    Return max_len and the substring as a tuple
+    """
+    if string is None:
+        return 0, ''
+    sub_string = ''
+    dict = {}
+    max_length = 0
+    j = 0
+    for i in range(len(string)):
+        if string[i] in dict:
+            j = max(dict[string[i]], j)
+        dict[string[i]] = i + 1
+        if i - j + 1 > max_length:
+            max_length = i - j + 1
+            sub_string = string[j: i + 1]
+    return max_length, sub_string
+
+def get_longest_non_repeat_v2(string):
+    """
+    Find the length of the longest substring
+    without repeating characters.
+    Uses alternative algorithm.
+    Return max_len and the substring as a tuple
+    """
+    if string is None:
+        return 0, ''
+    sub_string = ''
+    start, max_len = 0, 0
+    used_char = {}
+    for index, char in enumerate(string):
+        if char in used_char and start <= used_char[char]:
+            start = used_char[char] + 1
+        else:
+            if index - start + 1 > max_len:
+                max_len = index - start + 1
+                sub_string = string[start: index + 1]
+        used_char[char] = index
+    return max_len, sub_string

arrays/longest_non_repeat.py

@@ -0,0 +1,43 @@
+"""
+Find the index of 0 to be replaced with 1 to get
+longest continuous sequence
+of 1s in a binary array.
+Returns index of 0 to be
+replaced with 1 to get longest
+continuous sequence of 1s.
+If there is no 0 in array, then
+it returns -1.
+
+e.g.
+let input array = [1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1]
+If we replace 0 at index 3 with 1, we get the longest continuous
+sequence of 1s in the array.
+So the function return => 3
+"""
+
+
+def max_ones_index(arr):
+
+    n = len(arr)
+    max_count = 0
+    max_index = 0
+    prev_zero = -1
+    prev_prev_zero = -1
+
+    for curr in range(n):
+
+        # If current element is 0,
+        # then calculate the difference
+        # between curr and prev_prev_zero
+        if arr[curr] == 0:
+            if curr - prev_prev_zero > max_count:
+                max_count = curr - prev_prev_zero
+                max_index = prev_zero
+
+            prev_prev_zero = prev_zero
+            prev_zero = curr
+
+    if n - prev_prev_zero > max_count:
+        max_index = prev_zero
+
+    return max_index