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
