some stufs

Answers/993112119/Sparse.py

@@ -0,0 +1,73 @@
+class Sparse:
+    data = []
+    origin_Row = 0
+    origin_Col = 0
+
+    def __init__(self, matrix):
+        self.origin_Row = len(matrix)
+        self.origin_Col = len(matrix[0])
+        for i in range(self.origin_Row):
+            for j in range(self.origin_Col):
+                if matrix[i][j] != 0:
+                    self.data.append([i, j, matrix[i][j]])
+
+    def transpose(self):
+        new_data = [0] * len(self.data)
+        if len(self.data) > 0:
+            row_size = [0] * self.origin_Row
+            for i in self.data:
+                row_size[i[1]] += 1
+            startOfRow = [0]
+            for i in range(1, self.origin_Row):
+                startOfRow.append(startOfRow[i - 1] + row_size[i - 1])
+            for i in self.data:
+                x = startOfRow[i[1]]
+                new_data[x] = [i[1], i[0], i[2]]
+                startOfRow[i[1]] += 1
+        self.data = new_data
+
+    def find_element(self, i, j):
+        min_p = 0
+        max_p = len(self.data)
+        p = (min_p + max_p) // 2
+        while min_p != max_p:
+            if self.data[p][0] < i or (self.data[p][0] == i and self.data[p][1] < j):
+                max_p = p - 1
+            elif self.data[p][0] == i and self.data[p][1] == j:
+                return p, 0
+            else:
+                min_p = p + 1
+            p = (min_p + max_p) // 2
+        if self.data[p][0] == i and self.data[p][1] == j:
+            return p, 0
+        else:
+            return -1, p
+
+    def change_element(self, i, j, new_data):
+        index, near = self.find_element(i, j)
+        if new_data == 0:
+            if index != -1:
+                new_data.pop(index)
+        else:
+            if index != -1:
+                self.data[index][2] = new_data
+            else:
+                flag = False
+                for p in range(max(near-1, 0), min(near+2, len(self.data))):
+                    if self.data[p][0] > i or (self.data[p][0] == i and self.data[p][1] > j):
+                        flag = True
+                        break
+                if flag:
+                    self.data.insert(p, [i, j, new_data])
+                else:
+                    self.data.insert(p+1, [i, j, new_data])
+
+
+arr2d = [[1, 0, 0], [0, 0, 1], [1, 0, 0]]
+first_sparse = Sparse(arr2d)
+print(first_sparse.data)
+first_sparse.transpose()
+print(first_sparse.data)
+
+first_sparse.change_element(1, 0, 2)
+print(first_sparse.data)

Answers/993112119/s1.py

@@ -0,0 +1,10 @@
+def find_miss(input_arr):
+    bool_arr = [False] * (len(input_arr) + 1)
+    for i in input_arr:
+        bool_arr[i] = True
+    for i in range(len(bool_arr)):
+        if not bool_arr[i]:
+            return i
+    return -1
+
+print(find_miss([5, 2, 0, 3, 1]))

Answers/993112119/s2.py

@@ -0,0 +1,27 @@
+def rotate_array_1(input_arr, k):
+    for i in range(k):
+        val = input_arr.pop()
+        input_arr.insert(0, val)
+
+
+def rotate_arr_2(input_arr, k):
+    new_arr = input_arr[-k:] + input_arr[0:-k]
+    return new_arr
+
+
+def rotate_arr_3(input_arr, k):
+    new_arr = []
+    for i in range(len(input_arr) - k, len(input_arr)):
+        new_arr.append(input_arr[i])
+    for i in range(len(input_arr) - k):
+        new_arr.append(input_arr[i])
+    return new_arr
+
+
+arr = [1, 2, 3, 4, 5]
+rotate_array_1(arr, 2)
+print(arr)
+
+print(rotate_arr_2([1, 2, 3, 4, 5], 2))
+
+print(rotate_arr_3([1, 2, 3, 4, 5], 2))

Answers/993112119/s3.py

@@ -0,0 +1,13 @@
+def remove_duplicates(input_arr):
+    i = 0
+    while(i < len(input_arr)-1):
+        if input_arr[i] == input_arr[i+1]:
+            input_arr.pop(i)
+        else:
+            i += 1
+    return len(input_arr)
+
+
+arr = [1, 1, 2, 2, 3, 4, 5, 5]
+print(remove_duplicates(arr))
+print(arr)

Answers/993112119/s4.py

@@ -0,0 +1,22 @@
+def merge_sort_second_phase(arr1, arr2):
+    new_arr = []
+    i = 0
+    j = 0
+    while(i < len(arr1) or j < len(arr2)):
+        if i == len(arr1):
+            new_arr.append(arr2[j])
+            j += 1
+        elif j == len(arr2):
+            new_arr.append(arr1[i])
+            i += 1
+        else:
+            if arr1[i] < arr2[j]:
+                new_arr.append(arr1[i])
+                i += 1
+            else:
+                new_arr.append(arr2[j])
+                j += 1
+    return new_arr
+
+
+print(merge_sort_second_phase([1, 2, 3], [2, 5, 6]))

Answers/993112119/s5.py

@@ -0,0 +1,33 @@
+def max_sub_array(arr):
+    # if array is filled by negative numbers
+    maxy = arr[0]
+    is_negative = True
+    max_index = 0
+    for i in range(len(arr)):
+        if arr[i] > 0:
+            is_negative = False
+            break
+        if arr[i] > maxy:
+            maxy = arr[i]
+            max_index = i
+    if is_negative:
+        return maxy, [maxy]
+
+    # and what if not?
+    first = end = first_max = end_max = 0
+    sum_till = max_sum = 0
+    for i in range(1, len(arr)):
+        if sum_till + arr[i] > arr[i]:
+            end = i
+            sum_till += arr[i]
+        else:
+            sum_till = arr[i]
+            first = end = i
+        if max_sum < sum_till:
+            first_max = first
+            end_max = end
+            max_sum = sum_till
+    return max_sum, arr[first_max:end_max + 1]
+
+
+print(max_sub_array([-2, -1, -3, 4, -1, 2, 1, -5, 4]))