Add files via upload

python Experiments

Author: melophilecode

heap sort.py

@@ -0,0 +1,40 @@
+import random
+from timeit import default_timer as timer
+import matplotlib.pyplot as plt
+def heapify(arr, n, i):
+    largest = i
+    l = 2 * i + 1
+    r = 2 * i + 2
+    if l < n and arr[i] < arr[l]:
+        largest = l
+    if r < n and arr[largest] < arr[r]:
+        largest = r
+    if largest != i:
+        arr[i], arr[largest] = arr[largest], arr[i]
+        heapify(arr, n, largest)
+def heapSort(arr):
+    n = len(arr)
+    for i in range(n // 2, -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)
+x=[]
+y=[]
+for i in range(3):
+    n=int(input("\nEnter the value of n:"))
+    x.append(n)
+    arr = [random.randint(0, 10) for _ in range(n)]
+    print("Array elements before sorting are",arr)
+    start_time = timer()
+    ind=heapSort(arr)
+    end_time = timer()
+    elapsed_time = end_time - start_time
+    y.append(elapsed_time)
+    print("Array elements after sorting are ",arr)
+    print("Time taken=", elapsed_time)
+plt.plot(x,y)
+plt.title('Time Taken for heap sort')
+plt.xlabel('n')
+plt.ylabel('Time (seconds)')
+plt.show()

insertion sort.py

@@ -0,0 +1,30 @@
+import random
+from timeit import default_timer as timer
+import matplotlib.pyplot as plt
+def insertionSort(array):
+    for step in range(1, len(array)):
+        key = array[step]
+        j = step - 1
+        while j >= 0 and key < array[j]:
+            array[j + 1] = array[j]
+            j = j - 1
+        array[j + 1] = key
+x=[]
+y=[]
+for i in range(5):
+    n=int(input("\nenter the value of n:"))
+    x.append(n)
+    arr = [random.randint(0, 1000) for _ in range(n)]
+    print("\nthe array elements are",arr)
+    start_time = timer()
+    ind=insertionSort(arr)
+    end_time = timer()
+    print("array elements are ", arr)
+    elapsed_time = end_time - start_time
+    y.append(elapsed_time)
+    print("time taken=", elapsed_time)
+plt.plot(x,y)
+plt.title('Time Taken for insertion sort')
+plt.xlabel('n')
+plt.ylabel('Time (seconds)')
+plt.show()

kth smallest number.py

@@ -0,0 +1,33 @@
+import random
+def kthSmallest(arr, l, r, k):
+    if (k > 0 and k <= r - l + 1):
+        pos = randomPartition(arr, l, r)
+        if (pos - l == k - 1):
+            return arr[pos]
+        if (pos - l > k - 1):
+            return kthSmallest(arr, l, pos - 1, k)
+        return kthSmallest(arr, pos + 1, r,k - pos + l - 1)
+    return 999999999999
+def swap(arr, a, b):
+    temp = arr[a]
+    arr[a] = arr[b]
+    arr[b] = temp
+def partition(arr, l, r):
+    x = arr[r]
+    i = l
+    for j in range(l, r):
+        if (arr[j] <= x):
+            swap(arr, i, j)
+            i += 1
+    swap(arr, i, r)
+    return i
+def randomPartition(arr, l, r):
+    n = r - l + 1
+    pivot = int(random.random() * n)
+    swap(arr, l + pivot, r)
+    return partition(arr, l, r)
+if __name__ == '__main__':
+    arr = [12, 3, 5, 7, 4, 19, 26]
+    n = len(arr)
+    k = 3
+    print("K'th smallest element is",kthSmallest(arr, 0, n - 1, k))

nqueen challenge.py

@@ -0,0 +1,40 @@
+global N
+N = 4
+def printSolution(board):
+    for i in range(N):
+        for j in range(N):
+            print (board[i][j],end=' ')
+        print()
+def isSafe(board, row, col):
+    for i in range(col):
+        if board[row][i] == 1:
+            return False
+    for i, j in zip(range(row, -1, -1), range(col, -1, -1)):
+        if board[i][j] == 1:
+            return False
+        for i, j in zip(range(row, N, 1), range(col, -1, -1)):
+            if board[i][j] == 1:
+                return False
+        return True
+def solveNQUtil(board, col):
+    if col >= N:
+        return True
+    for i in range(N):
+        if isSafe(board, i, col):
+            board[i][col] = 1
+        if solveNQUtil(board, col + 1) == True:
+            return True
+        board[i][col] = 0
+    return False
+def solveNQ():
+    board = [[0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]
+ ]
+    if solveNQUtil(board, 0) == False:
+        print ("Solution does not exist")
+        return False
+    printSolution(board)
+    return True
+solveNQ()

quick sort.py

@@ -0,0 +1,36 @@
+import random
+from timeit import default_timer as timer
+import matplotlib.pyplot as plt
+def partition(array, low, high):
+    pivot = array[high]
+    i = low - 1
+    for j in range(low, high):
+        if array[j] <= pivot:
+            i = i + 1
+            (array[i], array[j]) = (array[j], array[i])
+        (array[i + 1], array[high]) = (array[high], array[i + 1])
+    return i + 1
+def quickSort(array, low, high):
+    if low < high:
+        pi = partition(array, low, high)
+        quickSort(array, low, pi - 1)
+        quickSort(array, pi + 1, high)
+x=[]
+y=[]
+for i in range(3):
+    n=int(input("\nenter the value of n:"))
+    x.append(n)
+    arr = [random.randint(0, 1000) for _ in range(n)]
+    print("\nthe array elements are",arr)
+    start_time = timer()
+    ind=quickSort(arr,low=0,high=n-1)
+    end_time = timer()
+    print("array elements are ", arr)
+    elapsed_time = end_time - start_time
+    y.append(elapsed_time)
+    print("time taken=", elapsed_time)
+plt.plot(x,y)
+plt.title('Time Taken for quick sort')
+plt.xlabel('n')
+plt.ylabel('Time (seconds)')
+plt.show()

traveling salesman.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+
+def nearest_neighbor(matrix):
+    n = matrix.shape[0]
+    current_city = np.random.randint(n)
+    visited_cities = [current_city]
+    total_distance = 0
+    while len(visited_cities) < n:
+        nearest_city = np.argmin([matrix[current_city][i] for i in range(n) if i not in visited_cities])
+        visited_cities.append(nearest_city)
+        total_distance += matrix[current_city][nearest_city]
+        current_city = nearest_city
+    total_distance += matrix[visited_cities[-1]][visited_cities[0]]
+    visited_cities.append(visited_cities[0])
+    return visited_cities, total_distance
+
+
+def calculate_distance_matrix(points):
+    n = len(points)
+    dist_matrix = np.zeros((n, n))
+    for i in range(n):
+        for j in range(n):
+            dist_matrix[i][j] = np.sqrt((points[i][0] - points[j][0]) ** 2 + (points[i][1] - points[j][1]) ** 2)
+        return dist_matrix
+points = [(0, 0), (1, 2), (3, 1), (2, 3)]
+matrix = calculate_distance_matrix(points)
+route, approx_distance = nearest_neighbor(matrix)
+from itertools import permutations
+perm = permutations(range(len(points)))
+optimal_distance = float('inf')
+for p in perm:
+    distance = 0
+    for i in range(len(p) - 1):
+        distance += matrix[p[i]][p[i + 1]]
+    distance += matrix[p[-1]][p[0]]
+    if distance < optimal_distance:
+        optimal_distance = distance
+print("Points:", points)
+print("Approximation Route:", route)
+print("Approximation Distance:", approx_distance)
+print("Optimal Distance:", optimal_distance)
+print("Error Approximation:", (approx_distance - optimal_distance) / optimal_distance)