logging in sorting

Author: Shikha-code36

competitivepython/sorting/bubblesort.py

@@ -1,7 +1,14 @@
+import logging
+
 def bubble_sort(arr):
- length = len(arr)
- for i in range(length):
- for j in range(0, length-i-1):
- if arr[j] > arr[j+1]:
- arr[j], arr[j+1] = arr[j+1], arr[j]
- return arr
+ try:
+ length = len(arr)
+ for i in range(length):
+ for j in range(0, length-i-1):
+ if arr[j] > arr[j+1]:
+ arr[j], arr[j+1] = arr[j+1], arr[j]
+ return arr
+ except Exception as e:
+ logging.exception("An error occurred during bubble sort: %s", e)
+ return []
+

competitivepython/sorting/bucketsort.py

@@ -1,18 +1,24 @@
+import logging
+
 def bucket_sort(arr):
- n = len(arr)
- max_val = max(arr)
- bucket = []
- for i in range(n):
- bucket.append([])
- for i in arr:
- index_b = int(n * i / max_val)
- if index_b != n:
- bucket[index_b].append(i)
- else:
- bucket[n - 1].append(i)
- for i in range(n):
- bucket[i] = sorted(bucket[i])
- result = []
- for i in range(n):
- result = result + bucket[i]
- return result
+ try:
+ n = len(arr)
+ max_val = max(arr)
+ bucket = []
+ for i in range(n):
+ bucket.append([])
+ for i in arr:
+ index_b = int(n * i / max_val)
+ if index_b != n:
+ bucket[index_b].append(i)
+ else:
+ bucket[n - 1].append(i)
+ for i in range(n):
+ bucket[i] = sorted(bucket[i])
+ result = []
+ for i in range(n):
+ result = result + bucket[i]
+ return result
+ except Exception as e:
+ logging.exception("An error occurred during bucket sort: %s", e)
+ return []

competitivepython/sorting/heapsort.py

@@ -1,11 +1,18 @@
+import logging
+
 def heap_sort(arr):
- n = len(arr)
- for i in range(n//2 - 1, -1, -1):
- heapify(arr, n, i)
- for i in range(n-1, 0, -1):
- arr[i], arr[0] = arr[0], arr[i]
- heapify(arr, i, 0)
- return arr
+ try:
+ n = len(arr)
+ for i in range(n//2 - 1, -1, -1):
+ heapify(arr, n, i)
+ for i in range(n-1, 0, -1):
+ arr[i], arr[0] = arr[0], arr[i]
+ heapify(arr, i, 0)
+ return arr
+ except Exception as e:
+ logging.exception("An error occurred during heap sort: %s", e)
+ return []
+
 
 def heapify(arr, n, i):
  largest = i

competitivepython/sorting/insertionsort.py

@@ -1,10 +1,17 @@
+import logging
+
 def insertion_sort(arr):
- n = len(arr)
- for i in range(1, n):
- target = arr[i]
- j = i - 1
- while j >= 0 and target < arr[j]:
- arr[j + 1] = arr[j]
- j -= 1
- arr[j + 1] = target
- return arr
+ try:
+ n = len(arr)
+ for i in range(1, n):
+ target = arr[i]
+ j = i - 1
+ while j >= 0 and target < arr[j]:
+ arr[j + 1] = arr[j]
+ j -= 1
+ arr[j + 1] = target
+ return arr
+ except Exception as e:
+ logging.exception("An error occurred during insertion sort: %s", e)
+ return []
+

competitivepython/sorting/mergesort.py

@@ -1,28 +1,35 @@
+import logging
+
 def merge_sort(arr):
- if len(arr) > 1:
- mid = len(arr) // 2
- L = arr[:mid]
- R = arr[mid:]
- merge_sort(L)
- merge_sort(R)
- i = j = k = 0
- aux = [0] * len(arr)
- while i < len(L) and j < len(R):
- if L[i] < R[j]:
+ try:
+ if len(arr) > 1:
+ mid = len(arr) // 2
+ L = arr[:mid]
+ R = arr[mid:]
+ merge_sort(L)
+ merge_sort(R)
+ i = j = k = 0
+ aux = [0] * len(arr)
+ while i < len(L) and j < len(R):
+ if L[i] < R[j]:
+ aux[k] = L[i]
+ i += 1
+ else:
+ aux[k] = R[j]
+ j += 1
+ k += 1
+ while i < len(L):
  aux[k] = L[i]
  i += 1
- else:
+ k += 1
+ while j < len(R):
  aux[k] = R[j]
  j += 1
- k += 1
- while i < len(L):
- aux[k] = L[i]
- i += 1
- k += 1
- while j < len(R):
- aux[k] = R[j]
- j += 1
- k += 1
- for i in range(len(arr)):
- arr[i] = aux[i]
- return arr
+ k += 1
+ for i in range(len(arr)):
+ arr[i] = aux[i]
+ return arr
+ except Exception as e:
+ logging.exception("An error occurred during merge sort: %s", e)
+ return []
+

competitivepython/sorting/quicksort.py

@@ -1,6 +1,12 @@
+import logging
+
 def quick_sort(arr):
- quick_sort_helper(arr, 0, len(arr)-1)
- return arr
+ try:
+ quick_sort_helper(arr, 0, len(arr)-1)
+ return arr
+ except Exception as e:
+ logging.exception("An error occurred during quick sort: %s", e)
+ return []
 
 def quick_sort_helper(arr, low, high):
  if low < high:

competitivepython/sorting/radixsort.py

@@ -1,9 +1,16 @@
+import logging
+
 def radix_sort(arr):
- max_val = max(arr)
- num_digits = len(str(max_val))
- for k in range(num_digits):
- s = [[] for i in range(10)]
- for i in arr:
- s[i // (10**k) % 10].append(i)
- arr = [j for sub in s for j in sub]
- return arr
+ try:
+ max_val = max(arr)
+ num_digits = len(str(max_val))
+ for k in range(num_digits):
+ s = [[] for i in range(10)]
+ for i in arr:
+ s[i // (10**k) % 10].append(i)
+ arr = [j for sub in s for j in sub]
+ return arr
+ except Exception as e:
+ logging.exception("An error occurred during radix sort: %s", e)
+ return []
+

competitivepython/sorting/selectionsort.py

@@ -1,9 +1,15 @@
+import logging
+
 def selection_sort(arr):
- n = len(arr)
- for i in range(n):
- min_idx = i
- for j in range(i+1, n):
- if arr[j] < arr[min_idx]:
- min_idx = j
- arr[i], arr[min_idx] = arr[min_idx], arr[i]
- return arr
+ try:
+ n = len(arr)
+ for i in range(n):
+ min_idx = i
+ for j in range(i+1, n):
+ if arr[j] < arr[min_idx]:
+ min_idx = j
+ arr[i], arr[min_idx] = arr[min_idx], arr[i]
+ return arr
+ except Exception as e:
+ logging.exception("An error occurred during selection sort: %s", e)
+ return []

competitivepython/sorting/shellsort.py

@@ -1,13 +1,20 @@
+import logging
+
 def shell_sort(arr):
- n = len(arr)
- gap = n // 2
- while gap > 0:
- for i in range(gap, n):
- temp = arr[i]
- j = i
- while j >= gap and arr[j - gap] > temp:
- arr[j] = arr[j - gap]
- j -= gap
- arr[j] = temp
- gap //= 2
- return arr
+ try:
+ n = len(arr)
+ gap = n // 2
+ while gap > 0:
+ for i in range(gap, n):
+ temp = arr[i]
+ j = i
+ while j >= gap and arr[j - gap] > temp:
+ arr[j] = arr[j - gap]
+ j -= gap
+ arr[j] = temp
+ gap //= 2
+ return arr
+ except Exception as e:
+ logging.exception("An error occurred during shell sort: %s", e)
+ return []
+

competitivepython/sorting/timsort.py

@@ -1,3 +1,5 @@
+import logging
+
 def insertion_sort(arr, left=0, right=None):
  if right is None:
  right = len(arr) - 1
@@ -19,19 +21,24 @@ def merge(left, right):
  return [right[0]] + merge(left, right[1:])
 
 def tim_sort(arr):
- n = len(arr)
- min_run = 32
- for i in range(0, n, min_run):
- insertion_sort(arr, i, min((i + min_run - 1), n - 1))
- size = min_run
- while size < n:
- for start in range(0, n, size * 2):
- midpoint = start + size - 1
- end = min((start + size * 2 - 1), (n-1))
- merged_array = merge(
- left=arr[start:midpoint + 1],
- right=arr[midpoint + 1:end + 1]
- )
- arr[start:start + len(merged_array)] = merged_array
- size *= 2
- return arr
+ try:
+ n = len(arr)
+ min_run = 32
+ for i in range(0, n, min_run):
+ insertion_sort(arr, i, min((i + min_run - 1), n - 1))
+ size = min_run
+ while size < n:
+ for start in range(0, n, size * 2):
+ midpoint = start + size - 1
+ end = min((start + size * 2 - 1), (n-1))
+ merged_array = merge(
+ left=arr[start:midpoint + 1],
+ right=arr[midpoint + 1:end + 1]
+ )
+ arr[start:start + len(merged_array)] = merged_array
+ size *= 2
+ return arr
+ except Exception as e:
+ logging.exception("An error occurred during bucket sort: %s", e)
+ return []
+