ljedlitschka/SimulationTuplesort
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Python aktualisiert

Browse Source
This commit is contained in:
Luise Jedlitschka
2023-02-06 15:31:34 +01:00
parent 46584930f6
commit 58036d4421
1 changed files with 151 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Roundabouts.py
+148 -74
View File
@@ -1,9 +1,10 @@
import unittest
LEFT = 0
RIGHT = 1
class Roundabout:
def __init__(self, rotation = 0):
def __init__(self, rotation = LEFT):
self.coatHangers = list()
self.rotation = rotation
@@ -12,13 +13,13 @@ class Roundabout:
self.add(item)
def add(self, item):
if self.rotation == 0: #linksdrehend
if self.rotation == LEFT: #linksdrehend
self.coatHangers.insert(0, item)
else:
self.coatHangers.append(item)
def remove(self):
if self.rotation == 0: #linksdrehend
if self.rotation == LEFT: #linksdrehend
return self.coatHangers.pop()
else:
return self.coatHangers.pop(0)
@@ -26,8 +27,15 @@ class Roundabout:
def content(self):
return self.coatHangers
def hasItems(self):
if len(self.coatHangers) == 0:
return False
return True
def itemOnSeparator(self):
if self.rotation == 0: #linksdrehend
if len(self.coatHangers) == 0:
return None
if self.rotation == LEFT: #linksdrehend
return self.coatHangers[-1]
else:
return self.coatHangers[0]
@@ -38,6 +46,8 @@ class Roundabout:
def isEmpty(self):
return len(self.coatHangers) == 0
def clear(self):
self.coatHangers.clear()
class Switch:
def __init__(self, left_roundabout: Roundabout, right_roundabout: Roundabout):
@@ -52,20 +62,20 @@ class Switch:
self.set_to_left()
def set_to_left(self):
self.status = 0
self.status = LEFT
return self.status
def set_to_right(self):
self.status = 1
self.status = RIGHT
return self.status
def is_left(self):
if self.status == 0:
if self.status == LEFT:
return True
return False
def is_right(self):
if self.status == 1:
if self.status == RIGHT:
return True
return False
@@ -81,58 +91,91 @@ class RoundaboutPair:
self.lR = left_roundabout
self.rR = right_roundabout
self.sw = switch
self.sortProcedure = "p" # picksort
def setSortType (self, t):
""" param t: walweise p(icksort) oder t(uplesort)
def sortStepPickSort(self):
"""Picksort Verfahren. Hole immer das kleinste aus dem Roundabout raus
"""
self.sortProcedure = t
def sortStep(self):
if self.sortProcedure == "p": # picksort
if self.lR.getSmallestItem() == self.lR.itemOnSeparator():
item = self.lR.remove()
self.sw.set_to_right()
self.sw.assign(item)
self.sw.set_to_left()
else:
item = self.lR.remove()
self.sw.assign(item)
else: # tuplesort
self.sw.set_to_right()
runSorting = True
while runSorting:
maxOfLastItems = self.passageOfSeparatorItems()
leftItem = self.lR.itemOnSeparator()
rightItem = self.rR.itemOnSeparator()
minOfCurentSeparatorItems = min(leftItem, rightItem)
if maxOfLastItems > minOfCurentSeparatorItems:
self.sw.switch()
if self.lR.isEmpty():
runSorting = False
def passageOfSeparatorItems(self):
if self.lR.itemOnSeparator() < self.rR.itemOnSeparator():
leftItem = self.lR.remove()
self.sw.assign(leftItem)
rightItem = self.rR.remove()
self.sw.assign(rightItem)
if self.lR.getSmallestItem() == self.lR.itemOnSeparator():
item = self.lR.remove()
self.sw.set_to_right() # weiche auf ausschleusen
self.sw.assign(item) # item auf die Weiche setzen
self.sw.set_to_left() # weiche wieder zurück setzen
else:
rightItem = self.rR.remove()
self.sw.assign(rightItem)
leftItem = self.lR.remove()
self.sw.assign(leftItem)
return max(rightItem, leftItem)
item = self.lR.remove()
self.sw.assign(item)
def sortStepTupleSort(self):
doPassage = True
before = 0
while doPassage:
rightItem = self.rR.itemOnSeparator()
leftItem = self.lR.itemOnSeparator()
# wenn beide leer sind macht der Methode keinen Sinn
if rightItem == None and leftItem == None:
return
# wenn der linke Kreisel leer ist, sind wir fertig
if leftItem == None:
break
if rightItem is None:
rightItem = 0
# raus zum nächsten Schritt. Ende dieses Tupels erreicht.
if max(leftItem, rightItem) < before:
break
if leftItem < rightItem:
if leftItem > before:
before = self.doPassageLeftItem()
if rightItem > before:
before = self.doPassageRightItem()
else:
if rightItem > before:
before = self.doPassageRightItem()
if leftItem > before:
before = self.doPassageLeftItem()
# Weiche auf die andere Seite stellen
self.sw.switch()
return
def doPassageLeftItem(self):
"""greift sich das Element vom linken Roundabout und fährt durch die Weiche
"""
leftItem = self.lR.itemOnSeparator()
if leftItem == None:
return
leftItem = self.lR.remove()
self.sw.assign(leftItem)
return leftItem
def runSimulation(self):
number = 0
def doPassageRightItem(self):
"""greift sich das Element vom rechten Roundabout und fährt durch die Weiche
"""
rightItem = self.rR.itemOnSeparator()
if rightItem == None:
return
rightItem = self.rR.remove()
self.sw.assign(rightItem)
return rightItem
def runPickSort(self):
# number = 0
while not self.lR.isEmpty():
self.sortStep()
number += 1
if number > 300:
self.sortStepPickSort()
# number += 1
# if number > 300:
# break
def runTupleSort(self):
number = 0
self.sw.set_to_right()
runSorting = True
while runSorting:
self.sortStepTupleSort()
if self.lR.isEmpty():
break
def show(self):
@@ -140,8 +183,6 @@ class RoundaboutPair:
class TestObjectMethods(unittest.TestCase):
def test_roundabout(self):
k1 = Roundabout()
@@ -150,26 +191,23 @@ class TestObjectMethods(unittest.TestCase):
self.assertEqual(k1.remove(), 1)
self.assertEqual(k1.content(), [3, 2])
k2 = Roundabout() # links drehend
k2 = Roundabout(LEFT) # links drehend - default
k2.add(1)
k2.add(2)
k2.add(3)
k2.add(4)
self.assertEqual(k2.content(), [4, 3, 2, 1])
k3 = Roundabout(1) # rechts drehend
k3 = Roundabout(RIGHT) # rechts drehend
k3.add(5)
k3.add(6)
k3.add(7)
k3.add(8)
self.assertEqual(k3.content(), [5, 6, 7, 8])
self.assertEqual(k2.itemOnSeparator(), 1)
self.assertEqual(k3.itemOnSeparator(), 5)
self.assertEqual(k3.remove(), 5)
self.assertEqual(k2.remove(), 1)
@@ -198,17 +236,17 @@ class TestObjectMethods(unittest.TestCase):
self.assertEqual(lK.content(), [1, 2, 3, 4, 5, 6])
self.assertEqual(p.show(), ([1, 2, 3, 4, 5, 6], []))
p.sortStep()
p.sortStepPickSort()
self.assertEqual(p.show(), ([6, 1, 2, 3, 4, 5], []))
p.sortStep()
p.sortStepPickSort()
self.assertEqual(p.show(), ([5, 6, 1, 2, 3, 4], []))
p.sortStep()
p.sortStepPickSort()
self.assertEqual(p.show(), ([4, 5, 6, 1, 2, 3], []))
p.sortStep()
p.sortStepPickSort()
self.assertEqual(p.show(), ([3, 4, 5, 6, 1, 2], []))
p.sortStep()
p.sortStepPickSort()
self.assertEqual(p.show(), ([2, 3, 4, 5, 6, 1], []))
p.sortStep()
p.sortStepPickSort()
self.assertEqual(p.show(), ([2, 3, 4, 5, 6], [1]))
def test_picksort(self):
@@ -219,26 +257,62 @@ class TestObjectMethods(unittest.TestCase):
p = RoundaboutPair(lK, rK, sw)
self.assertEqual(lK.content(), [1, 2, 3, 4, 5, 6])
p.runSimulation()
p.runPickSort()
self.assertEqual(p.show(), ([], [1, 2, 3, 4, 5, 6]))
def test_tuplesort(self):
def test_tuplesort_equal(self):
lK = Roundabout()
lK.addList([3, 2, 1])
rK = Roundabout(1)
rK.addList([6, 5, 4])
sw = Switch(lK, rK)
p = RoundaboutPair(lK, rK, sw)
sw.set_to_right()
self.assertEqual(p.show(), ([1, 2, 3], [6, 5, 4]))
p.setSortType('t')
p.sortStep()
self.assertEqual(p.show(), ([1, 2], [5, 4, 3, 6]))
p.sortStep()
p.sortStepTupleSort()
self.assertEqual(p.show(), ([1, 2], [5, 4, 3, 6]))
p.sortStepTupleSort()
self.assertEqual(p.show(), ([5, 2, 1], [4, 3, 6]))
p.sortStepTupleSort()
self.assertEqual(p.show(), ([5, 2], [3, 6, 1, 4]))
p.sortStepTupleSort()
self.assertEqual(p.show(), ([6, 5, 3, 2], [1, 4]))
p.sortStepTupleSort()
self.assertEqual(p.show(), ([], [1, 2, 3, 4, 5, 6]))
def test_tuplesort_onlyleft(self):
# Roundabouts befüllen
lK = Roundabout()
lK.addList([1, 2, 3, 4, 5])
rK = Roundabout(1)
rK.addList([])
sw = Switch(lK, rK)
p = RoundaboutPair(lK, rK, sw)
self.assertEqual(p.show(), ([5, 4, 3, 2, 1], [] ))
sw.set_to_right()
# Sortierung starten
p.sortStepTupleSort()
self.assertEqual(p.show(), ([], [1, 2, 3, 4, 5] ))
def test_tuplesort_presorted(self):
lK = Roundabout()
lK.addList([2, 5])
rK = Roundabout(1)
rK.addList([3, 6, 1, 4])
sw = Switch(lK, rK)
p = RoundaboutPair(lK, rK, sw)
self.assertEqual(p.show(), ([5, 2], [3, 6, 1, 4] ))
sw.set_to_left()
p.sortStepTupleSort()
self.assertEqual(p.show(), ([6, 5, 3, 2], [1, 4] )) # r
p.sortStepTupleSort()
self.assertEqual(p.show(), ([], [1, 2, 3, 4, 5, 6] )) # l
if __name__ == '__main__':