Klasse Numbers zur Behandlung der Tuples impl.

Roundabouts.py

@@ -3,6 +3,41 @@ import unittest
 LEFT = 0
 RIGHT = 1
 
+class Numbers:
+    def __init__(self, content):
+        self._content = content
+
+    def isEmpty(self):
+        return len(self._content) == 0 
+
+    def getNumTuples(self):
+        if self.isEmpty():
+            return 0
+        lastItem = self._content[-1]
+        numTuples = 1 
+        for e in reversed(self._content):
+            if e < lastItem:
+                numTuples += 1
+                lastItem = e
+        return numTuples       
+
+    def getTuples(self, toGet:int)-> list:
+        res = list()
+        if self.isEmpty():
+            return res
+        lastItem = self._content[0]
+        numTuples = 1 
+        for e in self._content:
+            if e > lastItem:
+                numTuples += 1
+                lastItem = e
+            if numTuples <= toGet:
+                res.append(e)
+            else:
+                break
+        return res
+
+
 class Roundabout:
     def __init__(self, rotation = LEFT):
         self.coatHangers = list()
@@ -49,6 +84,25 @@ class Roundabout:
     def clear(self):
         self.coatHangers.clear()       
 
+    def clear(self):
+        self.coatHangers.clear()       
+
+    def getNumTuples(self) -> int:
+        content = list(self.content())
+        if self.rotation == LEFT: #linksdrehend
+            content.reverse()
+        n = Numbers(content)
+        return n.getNumTuples()
+    
+    def getTuples(self, numToGet:int) -> list:
+        content = list(self.content())
+        if self.rotation == LEFT: #linksdrehend
+            content.reverse()
+        n = Numbers(content)
+        return n.getTuples(numToGet)
+
+
+
 class Switch:
     def __init__(self, left_roundabout: Roundabout, right_roundabout: Roundabout):
         self.lR = left_roundabout
@@ -105,9 +159,8 @@ class RoundaboutPair:
             self.sw.assign(item)
 
     def sortStepTupleSort(self):
-        doPassage = True
         before = 0 
-        while doPassage:
+        while True:
             rightItem = self.rR.itemOnSeparator()
             leftItem = self.lR.itemOnSeparator()
 
@@ -149,7 +202,6 @@ class RoundaboutPair:
         self.sw.assign(leftItem)
         return leftItem
         
-        
     def doPassageRightItem(self):
         """greift sich das Element vom rechten Roundabout und fährt durch die Weiche
         """
@@ -178,12 +230,43 @@ class RoundaboutPair:
             if self.lR.isEmpty():
                 break
 
+    def initTupleSort(self):
+        pass
+
     def show(self):
         return (self.lR.content(), self.rR.content())
 
 
 
 class TestObjectMethods(unittest.TestCase):
+
+    def test_order(self):
+        # tupel werden von rechts nach links bestimmt. 
+        # Alles was kleiner als der Vorgänger ist, ist ein neuer Start eines Tupels
+        n1 = Numbers([1, 2, 3, 4, 5, 6])
+        self.assertEqual(n1.getNumTuples(), 6)
+        self.assertEqual(n1.getTuples(3), [1, 2, 3])
+
+        n2 = Numbers([3, 3, 3])
+        self.assertEqual(n2.getNumTuples(), 1)
+        self.assertEqual(n2.getTuples(1), [3, 3, 3])
+
+        n3 = Numbers([3, 2, 1]) # nur ein Tupel drin
+        self.assertEqual(n3.getNumTuples(), 1)
+        self.assertEqual(n3.getTuples(2), [3, 2, 1])
+
+        # n4 = Numbers([1, 10, 1, 10]) 
+        # self.assertEqual(n4.getNumTuples(), 2)
+        # self.assertEqual(n4.getTuples(1), [1])
+        # self.assertEqual(n4.getTuples(2), [10, 1, 10, 1])
+
+        n5 = Numbers([30, 2, 1, 10, 5, 4, 16]) 
+        self.assertEqual(n5.getNumTuples(), 3)
+        self.assertEqual(n5.getTuples(1), [16])
+        self.assertEqual(n5.getTuples(2), [10, 5, 4, 16])
+        self.assertEqual(n5.getTuples(3), [30, 2, 1, 10, 5, 4, 16])
+
+
     def test_roundabout(self):
         k1 = Roundabout()
         k1.addList([1, 2, 3])
@@ -217,6 +300,14 @@ class TestObjectMethods(unittest.TestCase):
         self.assertEqual(k5.isEmpty(), False)
         self.assertEqual(k5.getSmallestItem(), 1)
 
+        # k6 = Roundabout()
+        # self.assertEqual(k6.isEmpty(), True)
+        # k6.addList([1, 2, 3, 4, 5, 6])
+        # self.assertEqual(k6.content(), [6, 5, 4, 3, 2, 1])
+
+        # self.assertEqual(k6.getNumTuples(), 6)
+        # self.assertEqual(k6.getTuples(3), [1, 2, 3])
+
 
     def test_switch(self):
         k1 = Roundabout()
@@ -282,6 +373,28 @@ class TestObjectMethods(unittest.TestCase):
         self.assertEqual(p.show(), ([], [1, 2, 3, 4, 5, 6]))
 
 
+    def test_tuplesort_stepbystep(self):
+        lK = Roundabout()
+        lK.addList([6, 5, 4, 3, 2, 1])
+        rK = Roundabout(1)
+        rK.addList([])
+        sw = Switch(lK, rK)
+        p = RoundaboutPair(lK, rK, sw)
+        sw.set_to_right()
+        self.assertEqual(p.show(), ([1, 2, 3, 4, 5, 6], []))
+
+        # 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()