def test_something(self):
position_list = PositionList()
position_list.add_last(1)
p = position_list.add_last(3)
position_list.add_last(4)
q = position_list.add_last(7)
position_list.add_last(5)
self.assertEqual(None, has_sum_equals(position_list, 22))
self.assertEqual((p, q), has_sum_equals(position_list, 10))
def test_something(self):
position_list = PositionList()
position_list.add_last(4)
position_list.add_last(2)
position_list.add_last(3)
position_list.add_last(5)
position_list.add_last(1)
self.assertEqual(5, position_list.max())
def test_something(self):
position_list = PositionList()
position_list.add_last(4)
position_list.add_last(2)
position_list.add_last(3)
position_list.add_last(5)
position_list.add_last(1)
self.assertEqual(5, find_max_value(position_list))
def test_something(self):
position_list = PositionList()
position_list.add_last(4)
position_list.add_last(2)
p = position_list.add_last(3)
position_list.add_last(5)
position_list.add_last(1)
self.assertEqual(p, position_list.find(3))
def top(self, k):
if not 1 <= k <= len(self):
raise ValueError("Illegal value for k")
temp = PositionList()
for item in self._data:
temp.add_last(item)
for j in range(k):
high_pos = temp.first()
walk = temp.after(high_pos)
while walk is not None:
if walk.element()._count > high_pos.element()._count:
high_pos = walk
walk = temp.after(walk)
yield high_pos.element()._value
temp.delete(high_pos)
def test_something(self):
position_list = PositionList()
position_list.add_last(1)
position_list.add_last(2)
p = position_list.add_last(3)
r = [e for e in position_list]
self.assertEqual([1, 2, 3], r)
position_list.move_to_front(p)
r = [e for e in position_list]
self.assertEqual([3, 1, 2], r)
def test_something(self):
position_list = PositionList()
position_list.add_last(4)
position_list.add_last(2)
position_list.add_last(3)
r = [e for e in reversed(position_list)]
self.assertEqual([3, 2, 4], r)
class PositionalQueue:
def __init__(self):
self._position_list = PositionList()
def __len__(self):
return len(self._position_list)
def is_empty(self):
return self._position_list.is_empty()
def enqueue(self, e):
return self._position_list.add_last(e)
def dequeue(self):
p = self._position_list.first()
answer = p.element()
self._position_list.delete(p)
return answer
def delete(self, p):
self._position_list.delete(p)
class FavoritesList:
class _Item:
__slots__ = "_value", "_count"
def __init__(self, e):
self._value = e
self._count = 0
def __init__(self):
self._data = PositionList()
def __len__(self):
return len(self._data)
def is_empty(self):
return len(self) == 0
def access(self, e):
p = self._find_position(e)
if p is None:
p = self._data.add_last(self._Item(e))
p.element()._count += 1
self._move_up(p)
def remove(self, e):
p = self._find_position(e)
if p is not None:
self._data.delete(p)
def top(self, k):
if not 1 <= k <= len(self):
raise ValueError("Illegal value for k")
walk = self._data.first()
for j in range(k):
item = walk.element()
yield item._value
walk = self._data.after(walk)
def top_count(self, k):
if not 1 <= k <= len(self):
raise ValueError("Illegal value for k")
walk = self._data.first()
for j in range(k):
item = walk.element()
yield item._count
walk = self._data.after(walk)
def clear(self):
if self.is_empty():
return
current = self._data.first()
while current is not None:
to_be_deleted = current
current = self._data.after(current)
self._data.delete(to_be_deleted)
def reset_counts(self):
if self.is_empty():
return
current = self._data.first()
while current is not None:
current.element()._count = 0
current = self._data.after(current)
def _find_position(self, e):
walk = self._data.first()
while walk is not None and walk.element()._value != e:
walk = self._data.after(walk)
return walk
def _move_up(self, p):
if p != self._data.first():
cnt = p.element()._count
walk = self._data.before(p)
if cnt > walk.element()._count:
while walk != self._data.first() and cnt > self._data.before(
walk).element()._count:
walk = self._data.before(walk)
self._data.add_before(walk, self._data.delete(p))
def __init__(self):
self._data = PositionList()
def __init__(self):
self._position_list = PositionList()
def test_something(self):
L = PositionList()
L.add_last(1)
L.add_last(2)
L.add_last(3)
L.add_last(4)
L.add_last(5)
L.add_last(6)
L.add_last(7)
L.shuffle()
r = [k for k in L]
self.assertEqual([1, 5, 2, 6, 3, 7, 4], r)
def test_something(self):
position_list = PositionList()
position_list.add_last(1)
p = position_list.add_last(2)
position_list.add_last(3)
q = position_list.add_last(4)
position_list.add_last(5)
r = [k for k in position_list]
self.assertEqual([1, 2, 3, 4, 5], r)
position_list.swap(p, q)
r = [k for k in position_list]
self.assertEqual([1, 4, 3, 2, 5], r)