コード例 #1
0
 def test_singles(self):
     """ Tests the case where both lists have a single element."""
     self.assertEqual(merge([1], [1]), [1, 1])
     self.assertEqual(merge([1], [2]), [1, 2])
     self.assertEqual(merge([2], [1]), [1, 2])
     self.assertEqual(merge([-100], [1]), [-100, 1])
     self.assertEqual(merge([100], [1]), [1, 100])
コード例 #2
0
def timsort(arr):
    runs, sorted_runs = [], []
    length = len(arr)
    if length == 0:
        return arr
    new_run = [arr[0]]

    for i in range(1, length):

        if i == length - 1:
            new_run.append(arr[i])
            runs.append(new_run)
            break
        if arr[i] < arr[i - 1]:
            if new_run is None:
                runs.append(new_run)
                new_run = []
            else:
                runs.append([arr[i]])
                new_run.append(arr[i])

        else:
            new_run.append(arr[i])

    for collection in runs:
        sorted_runs.append(insertion(collection))

    sorted_array = []
    for run in sorted_runs:
        sorted_array = merge(sorted_array, run)

    return sorted_array
コード例 #3
0
    def test_both_multiple(self):
        """ Tests the case where both lists have multiple elements."""
        self.assertEqual(merge([1, 2], [3, 4]), [1, 2, 3, 4])
        self.assertEqual(merge([1, 4], [2, 3]), [1, 2, 3, 4])
        self.assertEqual(merge([-100, 1], [-1, 2]), [-100, -1, 1, 2])

        self.assertEqual(merge([1, 3, 5], [2, 4]), [1, 2, 3, 4, 5])

        self.assertEqual(merge([1, 2, 3], [1, 2, 3]), [1, 1, 2, 2, 3, 3])
        self.assertEqual(merge([1, 2, 3], [4, 5, 6]), [1, 2, 3, 4, 5, 6])
        self.assertEqual(merge([1, 3, 5], [2, 4, 6]), [1, 2, 3, 4, 5, 6])
コード例 #4
0
ファイル: inversions.py プロジェクト: adrianbreaz/classes
def inversions(arr):
    """Count the number of inversions in an array (i.e. the number of permutations
    to get a sorted array).
    Algorithm:
        - split array in two
        - call function for each half
        - call merge function to count the inversions between the two halves
        - the number of inversions in the array is number of inversions from
        each half plus the number of inversions between them
    Returns: (i, L) - number of inversions and sorted list.
    """
    n = len(arr)
    if n == 1:
        return (0, arr)

    ra, A = inversions(arr[: n // 2])
    rb, B = inversions(arr[n // 2 :])
    r, L = mergesort.merge(A, B, count=True)

    return (ra + rb + r, L)
コード例 #5
0
def merger(partials):
    merged = []
    failed = []
    terminated = []
    while partials or terminated:
        terminated += [p for p in partials if p.ready()]
        partials = purge(terminated, partials)

        failed += [p for p in partials if p.failed()]
        if failed:
            raise Exception('%d tasks failed' % (len(failed)))
        partials = purge(failed, partials)

        if len(terminated) >= 1:
            sublist = terminated.pop(0).result
            if not merged:
                merged = sublist
            else:
                merged = merge(merged, sublist)
        gevent.sleep(0)
    return merged
コード例 #6
0
ファイル: tokenizer.py プロジェクト: rchurch4/Projects
def merge_pl(posting_lists):
	sorted_pls = []
	for pl in posting_lists:
		pl = ms.mergesort(pl)
		sorted_pls.append(pl)
	while len(sorted_pls) > 1:
		pl1 = sorted_pls.pop(0)
		pl2 = sorted_pls.pop(0)
		pl_combined = ms.merge(pl1, pl2)
		sorted_pls.append(pl_combined)
	posting_list = []
	last_entry = [None]
	while len(sorted_pls[0]) > 0:
		new_entry = sorted_pls[0].pop(0)
		if last_entry[0] != new_entry[0]:
			if last_entry != [None]:
				posting_list.append(last_entry)
			last_entry = new_entry
		else:
			new_docs = last_entry[1]+new_entry[1]
			last_entry = [last_entry[0], new_docs]
	if last_entry != [None]:
		posting_list.append(last_entry)
	return posting_list
コード例 #7
0
 def test_merge_unbalanced(self):
     self.assertEqual(merge([1, 3, 5], [4]), [1, 3, 4, 5])
コード例 #8
0
 def test_merge_balanced(self):
     self.assertEqual(merge([1, 3, 5], [2, 4, 6]), [1, 2, 3, 4, 5, 6])
コード例 #9
0
 def test_merge_trivial_1(self):
     self.assertEqual(merge([2], [1]), [1, 2])
コード例 #10
0
ファイル: test_mergesort.py プロジェクト: cookjw/misc
 def test_merge(self):
     self.assertEqual(merge([6], [5]), [5,6])
     self.assertEqual(merge([7,8],[2,4]), [2,4,7,8])
     self.assertEqual(merge([1,3,5,6], [2,4,7,8]), [1,2,3,4,5,6,7,8])        
     self.assertEqual(merge([1,2],[3]),[1,2,3])
     self.assertEqual(merge([6,7,8,9], [1,2,3,4,5]), [1,2,3,4,5,6,7,8,9])       
コード例 #11
0
 def test_merge_balanced(self):
     self.assertEqual(merge([1, 3, 5], [2, 4, 6]), [1, 2, 3, 4, 5, 6])
コード例 #12
0
def cmergesort(nums):
    return m.merge(nums)
コード例 #13
0
 def test_both_lists_empty(self):
     """ Tests the case where both lists are empty."""
     self.assertEqual(merge([], []), [])
コード例 #14
0
 def test_one_list_empty(self):
     """ Tests the case where one of the lists is empty."""
     self.assertEqual(merge([], [1]), [1])
     self.assertEqual(merge([2], []), [2])
コード例 #15
0
t0 = time.time()

# Split the sequence in a number of chunks and process those
# independently.
n = 4
l = len(sequence) // n
subseqs = [sequence[i * l:(i + 1) * l] for i in range(n - 1)]
subseqs.append(sequence[(n - 1) * l:])

# Ask the Celery workers to sort each sub-sequence.
# Use a group to run the individual independent tasks as a unit of work.
partials = group(sort.s(seq) for seq in subseqs)().get()

# Merge all the individual sorted sub-lists into our final result.
result = partials[0]
for partial in partials[1:]:
    result = merge(result, partial)

dt = time.time() - t0
print('Distributed mergesort took %.02fs' % (dt))

# Do the same thing locally and compare the times.
t0 = time.time()
truth = sort(sequence)
dt = time.time() - t0
print('Local mergesort took %.02fs' % (dt))

# Final sanity checks.
assert result == truth
assert result == sorted(sequence)
コード例 #16
0
 def test_merge_trivial_1(self):
     self.assertEqual(merge([], []), [])
コード例 #17
0
 def test_merge_unbalanced(self):
     self.assertEqual(merge([1, 3, 5], [4]), [1, 3, 4, 5])
コード例 #18
0
 def test_merge_trivial_1(self):
     self.assertEqual(merge([], []), [])
コード例 #19
0
import mergesort
import BinarySearchIndex

A = mergesort.inp()
A = mergesort.merge(A)  # Sorting the set

find = int(input("Enter the number to be searched :"))
res = BinarySearchIndex.binary_search(A, find, 0)
print("element found at index : ")
print(res)

コード例 #20
0
ファイル: mergesort_test.py プロジェクト: att14/algorithms
    def test_merge(self):
        left = [1, 2, 3, 9]
        right = [4, 5, 6, 7, 8]

        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9],
                         mergesort.merge(left, right))
コード例 #21
0
 def test1_merge(self):
     """test merge"""
     self.assertEqual(mergesort.merge([2], [1]), [1,2]);
     self.assertEqual(mergesort.merge([2,4], [1,2]), [1,2,2,4]);
     self.assertEqual(mergesort.merge([3], [1,2,3,4,5]), [1,2,3,3,4,5]);
     self.assertEqual(mergesort.merge([1,2,3,4,5], [3]), [1,2,3,3,4,5]);
コード例 #22
0
ファイル: Ginnungagap.py プロジェクト: victor-cortez/Heimdall
        if ok is True and toprint:
            print(str(c) + " is " + str(status.split("|")[0]))
        if status == "ready" and conta < len(
                subs
        ):  # checks if the slave is ready for a task and if there is tasks avaliable
            c.send(bytes(",".join([str(i) for i in subs[conta]]),
                         "utf-8"))  # sends the next task
            conta += 1
            ok = True
        elif str(
                status.split("|")[0]
        ) == "done":  # if the slave is done, it means it finished a task and is returning the result data #gathers the data and puts into the ordered dict
            resultsorted = [int(i) for i in status.split("|")[1].split(",")]
            if toprint:
                print("Received a sorted list")
            thelis = mergesort.merge(thelis, resultsorted)
            ok = True
        else:
            c.send(
                bytes("wait", "utf-8")
            )  #if the status is ready but there is no task, it orders the slave to wait and closes the connection, proceeding to process the next slave and so on
            ok = False
    except Exception as e:
        print("An error ocurred")
        print(str(e))
print("----------")
print("The ordering is finished")
if toprintresult:
    print(thelis)
print("---------")
saida = input("Type enter to exit")
コード例 #23
0
ファイル: mergetest.py プロジェクト: swuiojkl/CMPUT204
import time
#from heapq import merge
#from merge import merge
from mergesort import merge
import random


def randomlist(length):
    L = []
    for _ in range(length):
        L.append(random.randrange(1000000))
    return L

lastTime = 0
for i in range(1,10):
    length = 1 << i
    x = randomlist(length)
    y = randomlist(length)
    startTime = time.time()
    z = merge(x,y)
    timeUsed = time.time() - startTime
    print "Length", length, "time", timeUsed
    if lastTime > 0:
        print "Ratio", timeUsed / lastTime
    lastTime = timeUsed

コード例 #24
0
from mergesort import mergesort, merge

left = [1, 3, 5, 7, 9]
right = [2, 4, 6, 7, 8, 9]
print(left, right)
res = merge(left, right)
print(res)

print("=" * 40)

arr = [5, 3, 8, 4, 2, 6, 1, 7, 9]
print(arr)
print(mergesort(arr))
コード例 #25
0
 def test_merge_trivial_1(self):
     self.assertEqual(merge([2], [1]), [1, 2])
コード例 #26
0
import mergesort

A = []

num = int(input("Enter the number of elements in sequence"))

for y in range(0, num):
    A.append(int(input()))

A = mergesort.merge(A)
print(A)


def binary_search(arr, x):
    mid = (0 + len(arr)) // 2

    if arr[mid] == x:
        return True
    elif mid == 0:
        return False
    elif arr[mid] > x:
        return binary_search(arr[:mid], x)
    elif arr[mid] < x:
        return binary_search(arr[mid:], x)


while True:
    try:
        find = int(
            input("Enter number to be searched : (or other key to exit)"))
        print(binary_search(A, find))
コード例 #27
0
ファイル: test_sort.py プロジェクト: rmariano/python_misc
 def test_merge(self):
     res = self.a[:] + self.b[:]
     res.sort()
     self.assertEqual(res, merge(self.a, self.b))