def mergeSort(alist): if len(alist)>1: mid = len(alist)//2 lefthalf = alist[:mid] righthalf = alist[mid:] mergeSort(lefthalf) mergeSort(righthalf) i=0 j=0 k=0 while i < len(lefthalf) and j < len(righthalf): if lefthalf[i] < righthalf[j]: alist[k]=lefthalf[i] i=i+1 else: alist[k]=righthalf[j] j=j+1 k=k+1 while i < len(lefthalf): alist[k]=lefthalf[i] i=i+1 k=k+1 while j < len(righthalf): alist[k]=righthalf[j] j=j+1 k=k+1
def printResult(set_num, result): # sort lst in order of activity name mergesort.mergeSort(result, 0, len(result) - 1) # print result to console output = " Set {}\n".format(set_num) output += " Number of activities selected = {}\n".format(len(result)) output += " Activities: {}\n".format(" ".join(result)) print output
def Count_Split(arr1,arr2): arr1 = mergeSort(arr1) arr2 = mergeSort(arr2) i = j = n = 0 while i < len(arr1) and j < len(arr2): if arr1[i] > arr2[j]: n += len(arr1) - i j += 1 else: i += 1 return n
def uniformRandom(numOfSessions, numOfAttendees, sessionsPerAttendee, listForFrequency): sessionList = [] #This list will contain all the session occurrences for all attendees #This will be used to count the frequency of sessions to plot a histogram for j in range(numOfAttendees): sessions = random.sample(range(1, numOfSessions), sessionsPerAttendee) #sort the sessions list mergeSort(sessions, len(sessions)) sessionList.append(sessions) listForFrequency.extend(sessions) return sessionList
def FirstPlot(): algo_name = "Merge sort" input_data = [] exec_time = [] Arr = [] for n in range(100, 1100, 100): Arr = range(n, -1, -1) start_time = time.clock() mergesort.mergeSort(Arr, 0, len(Arr) - 1) end_time = time.clock() exec_time.append((end_time - start_time) * 1000) input_data.append(n) CreatePlot(input_data, exec_time, algo_name)
def main(): n = int(input("Enter the number of items you would like to sort: ")) myList = [] for index in range(n): myList.append(random.randint(1, n)) #print( "Unsorted List:",myList) start = time.perf_counter() mergeSort(myList) endSort = time.perf_counter() #print ("Sorted List: ",myList) print("Total merge sort time of", n, "random items", endSort - start)
def skewedRandomOpp(numOfSessions, numOfAttendees, sessionsPerAttendee, listForFrequency): sessionList = [] for j in range(numOfAttendees): sessions = [] for j in range(sessionsPerAttendee): sessions.append( math.floor( abs((random.random() + random.random()) / 2) * (numOfSessions) + 1)) mergeSort(sessions, len(sessions)) sessionList.append(sessions) listForFrequency.extend(sessions) return sessionList
def StartAlgorithm(): global data if algMenu.get() == "Quick sort": quickSort(data, 0, len(data) - 1, drawData, speedScale.get() / 1000) elif algMenu.get() == "Merge sort": mergeSort(data, 0, len(data) - 1, drawData, speedScale.get() / 1000) elif algMenu.get() == "Selection sort": selectSort(data, drawData, speedScale.get() / 1000) elif algMenu.get() == "Radix sort": radixSort(data, drawData, speedScale.get() / 1000) elif algMenu.get() == "Insertion sort": insertSort(data, drawData, speedScale.get() / 1000) elif algMenu.get() == "Bubble sort": bubbleSort(data, drawData, speedScale.get() / 1000) drawData(data, ["limegreen" for _ in range(len(data))])
def startSort(): global arr if algoCombo.get() == 'Bubble Sort': bubbleSort(arr, displayArray, sortSpeed.get(), pauseBool) elif algoCombo.get() == 'Selection Sort': selectionSort(arr, displayArray, sortSpeed.get(), pauseBool) elif algoCombo.get() == 'Merge Sort': mergeSort(arr, displayArray, sortSpeed.get(), pauseBool, 0, len(arr) - 1) elif algoCombo.get() == 'Quick Sort': quickSort(arr, displayArray, sortSpeed.get(), pauseBool, 0, len(arr) - 1)
def twoTieredRandom(numOfSessions, numOfAttendees, sessionsPerAttendee, listForFrequency): sessionList = [] #in this distribution, 50% of the session an attendee will attend #will be from the 10% of the sessions and that too lower numbered. #rest of the 50% of sessions will be from the other 90% of the sessions if (numOfAttendees % 2 == 0): attendeeIndex = int(round(numOfAttendees / 2)) else: attendeeIndex = int(round((numOfAttendees + 1) / 4)) if (numOfSessions < 10): sessionIndex = 2 else: if (numOfSessions % 10 == 0): sessionIndex = int(numOfSessions / 10) + 1 else: sessionIndex = int(numOfSessions % 10) if (sessionsPerAttendee % 2 == 0): halfSessions = int(sessionsPerAttendee / 2) else: halfSessions = int((sessionsPerAttendee + 1) / 2) for i in range(numOfAttendees): # get the 50% of random sessions from first 10% of the sessions # here, sessionindex is at 10% of the total sessions if halfSessions > sessionIndex: sessions = random.sample(range(1, halfSessions + 1), halfSessions) else: sessions = random.sample(range(1, sessionIndex + 1), halfSessions) #now, get rest of the 50% of random sessions from 90% of sessions sessions.extend( random.sample(range(sessionIndex + 1, numOfSessions), sessionsPerAttendee - halfSessions)) mergeSort(sessions, len(sessions)) sessionList.append(sessions) listForFrequency.extend(sessions) return sessionList
def test_sort_on_small_lists_of_integers_with_duplicates(self): items1 = [3, 3] mergeSort(items1) self.assertEqual(items1, [3, 3]) # List should not be changed items2 = [3, 5, 3] mergeSort(items2) self.assertEqual(items2, [3, 3, 5]) # List should be in sorted order items3 = [5, 5, 3, 5, 3] mergeSort(items3) self.assertEqual(items3, [3, 3, 5, 5, 5]) items4 = [7, 5, 3, 7, 5, 7, 5, 3, 7] mergeSort(items4) self.assertEqual(items4, [3, 3, 5, 5, 5, 7, 7, 7, 7])
def sampleMedianSelect(l, k, m): if len(l) <= m: mergesort.mergeSort(l) return (l[k]) else: V = sottoinsieme(l, m) x = sampleMedianSelect(V, int(len(V) / 2), m) A1 = [] A2 = [] A3 = [] for i in range(len(l)): if l[i] < x: A1.append(l[i]) elif l[i] == x: A2.append(l[i]) else: A3.append(l[i]) if k <= len(A1) - 1: return sampleMedianSelect(A1, k, m) elif k > (len(A1) + len(A2)) - 1: return sampleMedianSelect(A3, k - len(A1) - len(A2), m) else: return x
def test_sort_on_lists_of_random_integers(self): # Generate list of 10 random integers from range [1...20] items1 = [] for x in range(0, 10): items1.append(random.randint(1, 20)) sorted_items1 = mergeSort(items1) # Creating a copy of list sorted(items1) # Sorting list items in place self.assertEqual(items1, sorted_items1) # Generate list of 20 random integers from range [1...50] items2 = [] for x in range(0, 20): items2.append(random.randint(1, 50)) sorted_items2 = mergeSort(items2) # Copy sorted(items2) # Mutate self.assertEqual(items2, sorted_items2) # Generate list of 30 random integers from range [1...100] items3 = [] for x in range(0, 30): items3.append(random.randint(1, 100)) sorted_items3 = mergeSort(items3) # Copy sorted(items3) # Mutate self.assertEqual(items3, sorted_items3)
def main(): activityFile = openFile('act.txt') readLine = 0 setNumber = 1 while readLine < len(activityFile): # Get the number of lines in our text file, whether a line is listing the number of # activities in a set or describing a specific activity activitySetSize = int(activityFile[readLine]) # Increment the number of lines we've read from the activity text file readLine += 1 # Initialize an empty list of activities activitySet = [] for activity in range(activitySetSize): # Initialize an empty dictionary so we can map the integers on each line to specific keys activityDict = {} # Convert each line into a list each integer as its own element activity = activityFile[readLine].split() # Convert the data type to integer for each element in the list (readlines() in openFile # gave us strings to start) activity = list(map(int, activity)) # Make sure each value from each line corresponds to the correct info about the activity activityDict['activityNumber'] = activity[0] activityDict['startTime'] = activity[1] activityDict['endTime'] = activity[2] # Add the activity to our complete list of activities to schedule activitySet.append(activityDict) # Increment the number of lines we've read after we've completed parsing the data readLine += 1 # Use merge sort to return a list of dictionaries based on the the start time key in # descending order activitySet = mergeSort(activitySet, 'startTime', False) # Pass the activity list to our optimizeSchedule function to get a list of activities # that don't overlap based on their latest start times optimalSchedule = schedule(activitySet) # Output the formatted results of the optimized schedule to the terminal printSchedule(optimalSchedule, setNumber) # Increment the number of activity sets we've processed during the while loop setNumber += 1
def nearest(): try: lat = request.args['Lat'] long = request.args['Long'] submission_successful = True except: submission_successful = False if submission_successful: check = Check(lat, long) if check.checker(): location = {'lat': float(lat), 'long': float(long)} submission_successful = True stops = datastore.get_records('bus.db', 'get_coord') distance_data = [] for stop in stops: #calculate distance of each bus stop from coordinates distance_data.append({ 'BusstopCode': stop[0], 'Description': stop[1], 'distance': haversine(location['lat'], location['long'], stop[2], stop[3]) }) distance_data = mergeSort( distance_data ) #sort array based on distance from specified coordinates for distance in distance_data: #convert distance values into 2dp distance.update({'distance': round(distance['distance'], 2)}) return render_template('nearest.html', submission_successful=submission_successful, distance_data=distance_data) else: error = "Please check your coordinates again." return render_template('nearest.html', error=error) else: return render_template('nearest.html')
def main(): elements, int_range = parseArgs() lst = [] start, end = None, None for i in range(elements): lst.append(random.randint(1, int_range)) print("Number of elements to sort: {}\tNumber range: {}"\ .format(elements, int_range)) #print("Initial list: {}".format(lst)) print(divider) #Bubble Sort print("Performing bubble sort...") start = time.time() bubble_sort_list = bubbleSort(lst) end = time.time() assert (isSorted(bubble_sort_list)) assert (len(bubble_sort_list) == len(lst)) #print("Bubble sorted list: {}".format(bubble_sort_list)) bubble_sort_time = end - start print("Time: {}".format(round(bubble_sort_time, 3))) #Merge Sort print("\nPerforming merge sort...") start = time.time() merge_sort_list = mergeSort(lst) end = time.time() #print("Merge-Sorted list: {}".format(merge_sort_list)) assert (isSorted(merge_sort_list)) assert (len(merge_sort_list) == len(lst)) merge_sort_time = end - start print("Time: {}".format(round(merge_sort_time, 3))) if merge_sort_time != 0.0: print("Merge sort sorted {} times faster"\ .format(round(bubble_sort_time/merge_sort_time, 1)))
selectionsort.selectionSort(alist) endTime = time.time() resultsFile.write("You chose Selection sort\n") elif userSelection == '2': startTime = time.time() insertionsort.insertionSort(alist) endTime = time.time() resultsFile.write("You chose Insertion sort\n") elif userSelection == '3': startTime = time.time() alist = quicksort.quickSort(alist) endTime = time.time() resultsFile.write("You chose Quick sort\n") elif userSelection == '4': startTime = time.time() mergesort.mergeSort(alist) endTime = time.time() resultsFile.write("You chose Merge sort\n") elif userSelection == '5': startTime = time.time() heapsort.heapSort(alist) endTime = time.time() resultsFile.write("You chose Heap sort\n") elif userSelection == '6': startTime = time.time() countingsort.countingSort(alist) endTime = time.time() print(alist[0:20]) resultsFile.write("You chose Counting sort\n") elif userSelection == '7': startTime = time.time()
Arr1 = [-3,5,8,7,1,-2,4] Arr2 = [5,8,-6,12,3,7,1,9,10] Arr3 = [44,31,-61,12,3,71,1,19,56,-25] print ("Unsorted array :") print (Arr1) print ("Unsorted array :") print (Arr2) insertion.insertionSort(Arr1) print ("Sorted array :") print (Arr1) mergesort.mergeSort(Arr2,0,8) print ("Sorted array :") print (Arr2) ind = linearsearch.linear(Arr3,12) if ind != -1: print ("Index of elemet ",ind) else: print ("Element don't exist ") insertion.insertionSort(Arr3) ind = binarysearch.binary(Arr3,71,0,len(Arr3)-1)
from mergesort import mergeSort def getDivisors(n): s = 0 i = 1 divisors = [] limit = ceil(sqrt(n)) while i <= limit: if n % i == 0: if (int(n/i)) not in divisors: divisors.append(i) i += 1 return divisors total = 0 n = 1 while n < 10000: divisors = getDivisors(n) for divisor in divisors: digits = [int(d) for d in (str(divisor) + str(int(n/divisor)) + str(n))] digits = mergeSort(digits) if digits == list(range(1, 10)): print(n) total += n break n += 1 print(total)
while i < len(lefthalf): alist[k]=lefthalf[i] i=i+1 k=k+1 while j < len(righthalf): alist[k]=righthalf[j] j=j+1 k=k+1 alist = [] for x in range(10): alist.append (random.randint(1,10)) s = time.time() mergeSort(alist) e = time.time() time1 = e-s import time from mergesort import mergeSort from quicksort import quickSort import random difference = [] for i in range (1,1000): alist = []
def test_merge_sort(self): values = [5, 3, 6] sorteddata = [3, 5, 6] mergeSort(values, 0, len(values) - 1) print(values) self.assertListEqual(values, sorteddata)
def test_mergeSort(): mylist = [12, 34, 67, 45, 23, 36, 5, 17, 40, 10] sorted_list = mergeSort(mylist) assert sorted_list == [5, 10, 12, 17, 23, 34, 36, 40, 45, 67]
import time import random from mergesort import mergeSort A=[6,7,8,4,2] print(A) start=time.time() mergeSort(A,0,len(A)-1) end=time.time() print(A) print("execution time",start-end)
from mergesort import mergeSort charsUsed = '' randChars = [] passcode = [] f = open('keylog.txt') line = f.readline() while line != '': charsUsed += line[0] + line[1] + line[2] randChars.append(line) line = f.readline() charsUsed = list(charsUsed) # Generate an array of all digits used in the passcode charsUsed = mergeSort(charsUsed) i = 0 length = len(charsUsed) while i < length - 1: try: while charsUsed[i] == charsUsed[i + 1]: del charsUsed[i + 1] length -= 1 except IndexError: pass i += 1 i = 0 s = [] while i < factorial(len(charsUsed)): # Find the largest index k s.t. charsUsed[k] < charsUsed[k+1]
from mergesort import mergeSort charsUsed = '' randChars = [] passcode = [] f = open('keylog.txt') line = f.readline() while line != '': charsUsed += line[0] + line[1] + line[2] randChars.append(line) line = f.readline() charsUsed = list(charsUsed) # Generate an array of all digits used in the passcode charsUsed = mergeSort(charsUsed) i = 0 length = len(charsUsed) while i < length - 1: try: while charsUsed[i] == charsUsed[i+1]: del charsUsed[i+1] length -= 1 except IndexError: pass i += 1 i = 0 s = [] while i < factorial(len(charsUsed)): # Find the largest index k s.t. charsUsed[k] < charsUsed[k+1]
#!/usr/bin/env python3 # Project Euler problem 52 from mergesort import mergeSort n = 2 while True: print(n) isSolution = True digits = mergeSort([int(d) for d in str(n)]) for factor in range(1, 7): test = mergeSort([int(d) for d in str(n*factor)]) if digits != test: isSolution = False if isSolution: print(n) break n += 1
#!/usr/bin/env python3 # Project Euler problem 52 from mergesort import mergeSort n = 2 while True: print(n) isSolution = True digits = mergeSort([int(d) for d in str(n)]) for factor in range(1, 7): test = mergeSort([int(d) for d in str(n * factor)]) if digits != test: isSolution = False if isSolution: print(n) break n += 1
def test_sort_on_empty_list(self): alist = [] mergeSort(alist) self.assertEqual(alist, []) # List should not be changed
## # This program measures how long it takes to sort a list of a # user-specified size with the merge sort algorithm. # from random import randint from mergesort import mergeSort from time import time # Prompt the user for the list size. n = int(input("Enter list size: ")) # Construct random list. values = [] for i in range(n): values.append(randint(1, 100)) startTime = time() mergeSort(values) endTime = time() print("Elapsed time: %.3f seconds" % (endTime - startTime))
#!/usr/bin/env python3 # Project Euler problem 29 from mergesort import mergeSort terms = [] for a in range(2, 101): for b in range(2, 101): terms.append(a**b) terms = mergeSort(terms) i = 0 while i < len(terms)-1: while terms[i] == terms[i+1]: del terms[i+1] i += 1 print(len(terms))
def ysort(p): mergesort.q = 1 mergesort.mergeSort(p) return p
#!/usr/bin/env python3 # Project Euler problem 22 from mergesort import mergeSort alphabet = list(map(chr, range(65, 91))) names = [] f = open('names.txt') names = f.read().replace('"', '').split(',') names = mergeSort(names) total = 0 i = 0 while i < len(names): score = 0 for letter in names[i]: j = 0 while j < len(alphabet): if alphabet[j] == letter: score += j + 1 j += 1 score = score * (i + 1) total += score i += 1 print(total)
def xsort(p): mergesort.q = 0 mergesort.mergeSort(p) return p
#from merge import merge from mergesort import mergeSort import random #array1 = [1, 3, 5, 7, 9] #array2 = [2, 4, 6, 8, 10] #print(merge(array1, array2)) #array1 = [1, 3, 5, 7, 9] #array2 = [1, 3, 4, 5, 7, 9] #print(merge(array1, array2)) #assert(merge(array1, array2) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) array = [] for i in range(100): array.append(random.randint(0, 100)) print(mergeSort(array) == sorted(array))
from mergesort import mergeSort import random from time import time import matplotlib.pyplot as plt x,y=[],[] for n in range(1000,1000000,100000): randomvalues=list(range(n)) start_time=time() i=mergeSort(randomvalues,0,len(randomvalues)-1) end_time=time() total_time=end_time-start_time x.append(n) y.append(total_time) print(x) print(y) plt.plot(x,y) plt.show()
testArr2 = [] for i in range(999, -1, -1): testArr2.append(i) testArr3 = [] for i in range(9999, -1, -1): testArr3.append(i) Arr1 = range(0, 100) Arr2 = range(0, 1000) Arr3 = range(0, 10000) mergesort.mergeSort(testArr1, 0, len(testArr1) - 1) mergesort.mergeSort(testArr2, 0, len(testArr2) - 1) mergesort.mergeSort(testArr3, 0, len(testArr3) - 1) pass1 = 1 pass2 = 1 pass3 = 1 for i in range(0, 100): if testArr1[i] != Arr1[i]: pass1 = 0 break for i in range(0, 1000): if testArr2[i] != Arr2[i]: pass2 = 0