questions in progress

amitkmr · amitkmr · commit 8f5e986c8564 · 2018-07-31T17:31:41.000+05:30
diff --git a/Arrays/find_missing_and_repeating_X.py b/Arrays/find_missing_and_repeating_X.py
@@ -0,0 +1,52 @@
+"""
+
+Given an unsorted array of size n. Array elements are in range from 1 to n. One number 'A' from set {1, 2, …n} is missing and one number 'B' occurs twice in array. Find these two numbers.
+Note: If you find multiple answers then print the Smallest number found.
+
+Input:
+
+The first line of input contains an integer T denoting the number of test cases. The description of T test cases follows.
+The first line of each test case contains a single integer N denoting the size of array.
+The second line contains N space-separated integers A1, A2, ..., AN denoting the elements of the array.
+
+
+Output:
+
+Print B, the repeating number followed by A which is missing in a single line.
+
+
+Constraints:
+
+1 ≤ T ≤ 40
+1 ≤ N ≤ 100
+1 ≤ A[i] ≤ N
+
+
+Example:
+
+Input
+2
+2
+2 2
+3 
+1 3 3
+Output
+2 1
+3 2
+
+"""
+
+
+def find_missing_repeating(arr,n):
+    
+
+
+def test():
+
+
+def main():
+
+
+if __name__ == '__main__':
+    main()
+    
diff --git a/Arrays/largest_subarray_of_sizek_X.py b/Arrays/largest_subarray_of_sizek_X.py
@@ -0,0 +1,69 @@
+"""
+https://practice.geeksforgeeks.org/problems/largest-sum-subarray-of-size-at-least-k/0
+
+Given an array and a number k, find the largest sum of the subarray containing at least k numbers. It may be assumed that the size of array is at-least k.
+
+Input:​
+The first line of input contains an integer T denoting the number of test cases. Then T test cases follow. Each test case contains an integer n denoting the size of the array. Then the following line contains n space separated integers. The last line of the input contains the number k.
+
+Output:
+Print the value of the largest sum of the subarray containing at least k numbers.
+
+Constraints:
+1<=T<=10^5
+1<=n<=10^5
+1<=a[i]<=10^5
+1<=k<=n
+
+Example:
+Input:
+2
+4
+-4 -2 1 -3
+2
+6
+1 1 1 1 1 1
+2
+
+Output:
+-1
+6
+
+"""
+
+
+def largest_subarray(arr,n,k):
+    i = 0
+    j = 0
+
+    arr_sum = 0
+    max_sum = min(arr)
+    while(i<n-k+1):
+        if j<n and (j-i < k or arr_sum + arr[j] > max_sum):
+            arr_sum+=arr[j]
+            j+=1
+            continue
+        
+        if max_sum < arr_sum:
+            max_sum = arr_sum
+    
+        arr_sum = arr_sum-arr[i]
+        i+=1
+    
+
+    if arr_sum > max_sum:
+        max_sum =arr_sum
+
+    return max_sum
+
+
+def test():
+    a = [-4, -2, 1, -3]
+    print(largest_subarray(a,4,2))
+    a = [1]*6
+    print(largest_subarray(a,6,2))
+
+if __name__ == '__main__':
+    # main()
+    test()
+    
diff --git a/Arrays/merge_k_sorted_array_X.py b/Arrays/merge_k_sorted_array_X.py
@@ -0,0 +1,31 @@
+def parent(i):
+    return int((i-1)/2)
+def left(i):
+    return 2*i + 1
+def right(i):
+    return 2*i + 2
+
+
+def heapify(arr,n,i):
+    small = i
+
+    if left(i) < n and arr[left(i)] < arr[i]:
+        small = left(i)
+    
+    if right(i) < n and arr[right(i)] < arr[small]:
+        small = right(i)
+
+    # swap two elements
+    if small != i:
+        arr[small],arr[i] = arr[i],arr[small]
+        heapify(arr,n,small)
+
+
+def extract_min(arr):
+    print(arr)
+    n = len(arr)s
+    item = arr[0]
+    arr[0],arr[n-1] = arr[n-1],arr[0]
+    arr.pop()
+    heapify(arr,n-1,0)
+    return item
diff --git a/Arrays/smallest_distinct_window_X.py b/Arrays/smallest_distinct_window_X.py
diff --git a/Arrays/smallest_positive_number_X.py b/Arrays/smallest_positive_number_X.py
@@ -0,0 +1,93 @@
+"""
+https://practice.geeksforgeeks.org/problems/smallest-positive-missing-number/0
+
+You are given an unsorted array with both positive and negative elements. You have to find the smallest positive number missing from the array in O(n) time using constant extra space.
+
+Input:
+First line consists of T test cases. First line of every test case consists of N, denoting the number of elements in array. Second line of every test case consists of elements in array.
+
+Output:
+Single line output, print the smallest positive number missing.
+
+Constraints:
+1<=T<=100
+1<=N<=100
+
+Example:
+Input:
+2
+5
+1 2 3 4 5
+5
+0 -10 1  -20
+Output:
+6
+2
+
+"""
+
+def parent(i):
+    return int((i-1)/2)
+def left(i):
+    return 2*i + 1
+def right(i):
+    return 2*i + 2
+
+
+def heapify(arr,n,i):
+    small = i
+
+    if left(i) < n and arr[left(i)] < arr[i]:
+        small = left(i)
+    
+    if right(i) < n and arr[right(i)] < arr[small]:
+        small = right(i)
+
+    # swap two elements
+    if small != i:
+        arr[small],arr[i] = arr[i],arr[small]
+        heapify(arr,n,small)
+
+
+def extract_min(arr):
+    print(arr)
+    n = len(arr)s
+    item = arr[0]
+    arr[0],arr[n-1] = arr[n-1],arr[0]
+    arr.pop()
+    heapify(arr,n-1,0)
+    return item
+
+def smallest_positive(arr,n):
+    
+    # for i in range(n):
+    #     if arr[i] < 0:
+    #         arr[i] = 100000000
+    
+    for i in range(int(n/2),-1,-1):
+        heapify(arr,n,i)
+    prev = None
+    while(len(arr)>0):
+        item = extract_min(arr)
+        if item < 0:
+            continue
+        if item != 1:
+            return 1
+        if prev == None or prev+1 == item:
+            prev = item
+            continue
+        else:
+            return prev+1
+    return prev + 1
+
+def main():
+    t = int(input())
+    for i in range(t):
+        n = int(input())
+        arr = list(map(int,input().split()))
+        print(smallest_positive(arr,n))
+
+
+if __name__ == '__main__':
+    main()
+    
