Python aktualisiert

Roundabouts.py

@@ -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]
@@ -37,7 +45,9 @@ 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 sortStepPickSort(self):
-    def setSortType (self, t):
+        """Picksort Verfahren. Hole immer das kleinste aus dem Roundabout raus
-        """ param t: walweise p(icksort) oder t(uplesort) 
         """
-        self.sortProcedure = t
+        if self.lR.getSmallestItem() == self.lR.itemOnSeparator():
-
+            item = self.lR.remove()
-    def sortStep(self):
+            self.sw.set_to_right()  # weiche auf ausschleusen
-        if self.sortProcedure == "p":   # picksort
+            self.sw.assign(item)    # item auf die Weiche setzen
-            if self.lR.getSmallestItem() == self.lR.itemOnSeparator():
+            self.sw.set_to_left()   # weiche wieder zurück setzen
-                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)
         else:
-            rightItem = self.rR.remove()
+            item = self.lR.remove()
-            self.sw.assign(rightItem)
+            self.sw.assign(item)
-            leftItem = self.lR.remove()
-            self.sw.assign(leftItem)
-        return max(rightItem, leftItem)
 
+    def sortStepTupleSort(self):
+        doPassage = True
+        before = 0 
+        while doPassage:
+            rightItem = self.rR.itemOnSeparator()
+            leftItem = self.lR.itemOnSeparator()
 
-    def runSimulation(self):
+            # wenn beide leer sind macht der Methode keinen Sinn
-        number = 0 
+            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 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()
+            self.sortStepPickSort()
-            number += 1
+            # number += 1
-            if number > 300:
+            # 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,25 +191,22 @@ 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()
+        p.sortStepTupleSort()
         self.assertEqual(p.show(), ([1, 2], [5, 4, 3, 6]))
-        p.sortStep()
+        p.sortStepTupleSort()
-        self.assertEqual(p.show(), ([1, 2], [5, 4, 3, 6]))
+        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__':