def buildNodeList(self):
result = {}
if self.root:
q = Queue()
visitedNode = []
q.enqueue(self.root)
q.enqueue('EndLevelFlag')
level = 0
while(not q.isEmpty()):
tmp = q.dequeue()
if tmp == 'EndLevelFlag':
# finish building the current level
level += 1
else:
# add node to Linked List
visitedNode.append(tmp)
if level in result.keys():
result[level].append(tmp)
else:
aList = LinkedList()
aList.append(tmp.value)
result[level] = aList
if tmp.left: q.enqueue(tmp.left)
if tmp.right: q.enqueue(tmp.right)
# add dummy item to represent the end of level
q.enqueue('EndLevelFlag')
return result
def bfs(self, src=None, onnode=lambda x: x):
if len(self.vertices) == 0:
return None
if src is None:
src = self.vertices[0]
q = Queue()
for v in self.vertices:
v.distance = sys.maxint
v.parent = None
src.distance = 0
q.enqueue(src)
while not q.empty():
d = q.dequeue()
onnode(d)
for node in d.outputs:
if node.distance == sys.maxint:
node.distance = d.distance + 1
node.parent = d
q.enqueue(node)
def simulation(seconds, ppm):
printer = Printer(ppm)
q = Queue()
waittimes = []
for currentSecond in range(seconds):
if newPrintTask():
task = Task(currentSecond)
q.enqueue(task)
if (not printer.isBusy()) and (not q.isEmpty()):
nextTask = q.dequeue()
waittimes.append(nextTask.getTimeWaited(currentSecond))
printer.startNextTask(nextTask)
printer.countdown()
averageWait = sum(waittimes)/len(waittimes)
print "Average wait of %6.2f seconds; %3d tasks remaining." \
% (averageWait, q.size())
return
def bfs(G, start):
state = {}
parentList = {}
order = []
# print "bfs started -- start :", start.name
for vert in G:
state[vert.name] = "undiscovered"
parentList[vert.name] = None
state[start.name] = "discovered"
Q = Queue()
Q.enqueue(start)
while Q.isEmpty() == False:
u = Q.dequeue()
order.append(u.name)
# print "Dequeued vertex", u.name
# print "vertex adjs "
# for v in u.connectedTo:
# print v.name,
# print ""
for v in u.connectedTo:
if state[v.name] == "undiscovered":
state[v.name] == "discovered"
parentList[v.name] = u.name
vert_v = G.getVertex(v.name)
if Q.contains(vert_v) == False:
Q.enqueue(vert_v)
# print "Enqueued new", v.name
state[u.name] = "processed"
return order
def bfs(cls, G, s):
'''广度优先搜索,注意是从特定点出发的，所以广度优先搜索不一定访问到
图中的所有节点，只能访问到该点可到达的节点
'''
bfs_visit_oder = []
color = {}
d = {}
pi = {}
for node in G.nodes():
color[node] = cls.white
d[node] = float("inf")
pi[node] = None
color[s] = cls.gray
d[s] = 0
Q = Queue( len(G) ) #队列的长度等于图的节点数目，也就是图的长度
Q.enqueue(s)
while not Q.is_empty() :
u = Q.dequeue()
for eachsucc in G.succ(u):
if color[eachsucc] == cls.white:
color[eachsucc] = cls.gray
d[eachsucc] += 1
pi[eachsucc] = u
Q.enqueue(eachsucc)
color[u] = cls.black
bfs_visit_oder.append(u)
return bfs_visit_oder
def bfs(self, start):
"""Perfomes a breadth-first-traversal, starting at Node(start)"""
from queue import Queue
if self.has_node(start) is False:
raise IndexError("{start} not in graph".format(start=start))
return
for node in self._nodes:
# Assign each node in the graph the attribute 'visited'
node.visited = False
# Full traversal path to be returned by the method
path = []
q = Queue()
current = self._get_node(start)
current.visited = True
path.append(current.data)
for node in self._neighbors(current.data):
if node.visited is False:
node.visited = True
path.append(node.data)
q.enqueue(node)
while True:
for node in self._neighbors(current.data):
if node.visited is False:
node.visited = True
path.append(node.data)
q.enqueue(node)
try:
current = q.dequeue()
except ValueError:
break
for node in self._nodes:
node.visited = None
return path
def test_enqueue():
my_queue = Queue()
my_queue.enqueue(1)
my_queue.enqueue(2)
my_queue.enqueue(3)
assert my_queue.container.head.value == 1
assert my_queue.tail.value == 3
def test_Queue_dequeue(self):
q1 = Queue()
q1.enqueue(0)
q1.enqueue(1.2)
q1.enqueue("3.4")
q1.enqueue([5, 6])
q1.enqueue((7, 8))
q1.enqueue({9, 10})
self.assertEqual(q1.size(), 6)
self.assertEqual(q1.dequeue(), 0)
self.assertEqual(q1.size(), 5)
self.assertEqual(q1.dequeue(), 1.2)
self.assertEqual(q1.size(), 4)
self.assertEqual(q1.dequeue(), "3.4")
self.assertEqual(q1.size(), 3)
self.assertEqual(q1.dequeue(), [5, 6])
self.assertEqual(q1.size(), 2)
self.assertEqual(q1.dequeue(), (7, 8))
self.assertEqual(q1.size(), 1)
self.assertEqual(q1.dequeue(), {9, 10})
self.assertEqual(q1.size(), 0)
with self.assertRaises(ValueError):
q1.dequeue()
def test_enqueue(self):
"""test that enqueue works on one node"""
q = Queue()
val = 9
q.enqueue(val)
self.assertEqual(q.first_node.data, val)
self.assertEqual(q.last_node.data, val)
def test_enqueue_dequeue_enqueue():
my_queue = Queue()
my_queue.enqueue(1)
my_queue.dequeue()
my_queue.enqueue(2)
assert my_queue.container.head.value == 2
assert my_queue.tail.value == 2
def test_enqueue_and_peek(li, result):
"""Test enqueue method."""
from queue import Queue
new_list = Queue()
for item in li[::-1]:
new_list.enqueue(item)
assert new_list.peek() == result
def test_size(li, result):
"""Test size method."""
from queue import Queue
new_list = Queue()
for item in li:
new_list.enqueue(item)
assert result == new_list.size()
def buscaAmplitude(self,origin,destination): position = origin checked = [] queue = Queue() if (position == destination): return True checked.append(position) queue.enqueue(position) while(not queue.isEmpty()): position = queue.dequeue() if (position == destination): return True checked.append(position) neighbors = self.neighbors(position) while(len(neighbors) != 0): position = neighbors.pop(0) try: i = checked.index(position) except ValueError: i = -1 if (i == -1): if (position == destination): return True checked.append(position) queue.enqueue(position) return False
def bfs(self):
queue = Queue()
visited = []
queue.enqueue(self.head)
visited.append(self.head)
while not queue.is_empty():
vertex = queue.front().data
queue.dequeue()
print vertex
node = self.adj[vertex].head
while node is not None:
adj_vertex = node.data
if adj_vertex not in visited:
visited.append(adj_vertex)
queue.enqueue(adj_vertex)
node = node.next
def test_enqueue_dequeue_one_item(): queue = Queue() queue.enqueue(5) eq_(queue.is_empty(),False) eq_(queue.dequeue(), 5) eq_(queue.is_empty(),True) eq_(queue.dequeue(), None)
def bfsreduceall(sudokuObject):
source = sudokuObject.solutiondriverNoGuess()
if source == "Bad Response":
return None
elif type(source) is Sudoku:
return source
Q = Queue([sudokuObject])
loop = 1
startminnodes = None
while not Q.isempty():
# print("loop no",loop)
if loop > 2: return dfsreduceall(sudokuObject)
# if startminnodes is not None:
# for node in startminnodes:print(node.allowedset,node.id)
# print("Q.unqueue()",Q)
v = Q.unqueue()
unfnodes = v.getOrderedMinnodesUnfilled() # unfinished nodes
if loop == 1: startminnodes = unfnodes
for minnode in unfnodes:
for permutedvalue in minnode.allowedset:
global numsudokuobjects
numsudokuobjects += 1
newsudokuObject = sudokuObject.__deepcopy__()
newsudokuObject.nodes[minnode.id].setValue(permutedvalue)
postsolveobject = newsudokuObject.solutiondriverNoGuess()
if type(postsolveobject) is Sudoku:
return postsolveobject
elif postsolveobject != "Bad Response":
Q.enqueue(newsudokuObject)
loop += 1
return None
class TestMaxSizeQueue(unittest.TestCase): def setUp(self): self.max_size = 10 self.obj = Queue(max_size=self.max_size) def tearDown(self): self.obj = Queue(max_size=self.max_size) def test_queue_empty(self): self.assertTrue(self.obj.is_empty()) def test_raises_queue_full_error(self): for i in range(self.max_size): self.obj.enqueue(i) self.assertRaises(QueueFullError, lambda: self.obj.enqueue(20)) def test_queue_top_item(self): items = [2, 4, 5, 5] for item in items: self.obj.enqueue(item) self.assertEqual(self.obj.dequeue(), items[0])
class TestQueue(unittest.TestCase): def setUp(self): self.obj = Queue() def tearDown(self): self.obj = Queue() def test_empty_queue(self): self.assertTrue(self.obj.is_empty()) def test_raises_queue_empty_error(self): self.assertRaises(QueueEmptyError, lambda: self.obj.dequeue()) def test_queue_size(self): size = 20 for i in range(size): self.obj.enqueue(i) self.assertEqual(self.obj.size(), size) def test_queue_top_item(self): size = 20 for i in range(size): self.obj.enqueue(i) self.assertEqual(self.obj.dequeue(), 0)
class QueueAllTestCase(unittest.TestCase):
"""Tests of (non-empty) Queue."""
def setUp(self):
"""Set up an empty queue."""
self.queue = Queue()
def tearDown(self):
"""Clean up."""
self.queue = None
def testAll(self):
"""Test enqueueing and dequeueing multiple elements."""
for item in range(20):
self.queue.enqueue(item)
self.assertFalse(self.queue.is_empty(), \
'is_empty() returned True on a non-empty Queue!')
expect = 0
while not self.queue.is_empty():
self.assertEqual(self.queue.dequeue(), expect, \
'Something wrong on top of the Queue! Expected ' \
+ str(expect) + '.')
expect = expect + 1
def breadth_first_search(self, tree, parent, visited=[]):
# create a queue from a list
queue = Queue()
# add the parent node to the queue
queue.enqueue(parent)
# mark node as visited to ensure it's not traversed again
visited = visited + [parent]
# exit when the queue is empty
while queue.is_empty() == False:
# dequeue element
parent = queue.dequeue()
# get the children of the parent
children = tree[parent]
# iterates through all the children
for child in children:
# only traverse nodes not already visited
if child not in visited:
# add child to queue for exporation
queue.enqueue(child)
# visit child node
visited = visited + [child]
# return all visited
return visited
def test_enqueue():
"""Fill an empty contructor argument and assert len, deque)"""
filling_this = Queue(())
for i in xrange(40):
filling_this.enqueue(i)
assert len(filling_this) == 40
assert filling_this.dequeue() == 0
def pop(self):
temp = Queue()
while self.__q.count() > 1:
temp.enqueue(self.__q.dequeue())
result = self.__q.dequeue()
self.__q = temp
return result
def test_enqueue_nonempty():
"""Test enqueue on non-empty list."""
from queue import Queue
my_queue = Queue()
my_queue.enqueue('chicken')
my_queue.enqueue('monkey')
assert my_queue.container.head.val == 'monkey'
def test_first_elemnt_of_queue(self): ''' test that after initial enqueue, the head of the Queue is correct ''' q = Queue() q.enqueue(3) self.assertEqual(q.head, q.tail) self.assertEqual(q.head.value, 3)
def test_dequeue_nonempty():
"""Test dequeue on empty."""
from queue import Queue
my_queue = Queue()
my_queue.enqueue('monkey')
my_queue.enqueue('chicken')
my_queue.dequeue('monkey')
assert my_queue.container.tail.val == 'chicken'
def test_enqueue():
q= Queue()
q.enqueue("Jack")
assert q._lst.head.datum=="Jack"
q.enqueue("Jill")
assert q._lst.head.datum=="Jill"
def hotPotato(list, num):
Q = Queue()
for i in list:
Q.enqueue(i)
while Q.size() !=1:
for j in xrange(num):
Q.enqueue(Q.dequeue())
Q.dequeue()
return Q.dequeue()
def test_dequeue_twice():
my_queue = Queue()
my_queue.enqueue(1)
my_queue.enqueue(2)
my_queue.enqueue(3)
my_queue.dequeue()
my_queue.dequeue()
assert my_queue.container.head.value == 3
assert my_queue.tail.value == 3
def test_three_values(self): queue = Queue() queue.enqueue(1) queue.enqueue(2) queue.enqueue(3) self.assertEqual(1, queue.dequeue()) self.assertEqual(2, queue.dequeue()) self.assertEqual(3, queue.dequeue()) self.assertEqual(None, queue.dequeue())
def test_enqueue_then_dequeue(self): ''' test that after an enqueue a dequeue gives what is expected ''' q = Queue() q.enqueue(3) result = q.dequeue() self.assertEqual(result, 3) self.assertIsNone(q.head)
def test_peek():
p = Queue()
p.enqueue(1)
p.enqueue(2)
assert p.peek() == 1
class QueueTest(unittest.TestCase):
def setUp(self):
self.q = Queue()
def test_initialize_queue_buffer(self):
self.assertTrue(len(self.q.array) == 100)
self.assertTrue(self.q.max_buffer == 100)
self.assertTrue(self.q.get_size() == 0)
def test_initialize_queue_change_buffer_size(self):
q = Queue(10)
self.assertTrue(len(q.array) == 10)
self.assertTrue(q.max_buffer == 10)
self.assertTrue(q.get_size() == 0)
def test_is_full(self):
for i in range(100):
self.q.enqueue(i)
self.assertTrue(self.q.get_size() == 100)
self.assertTrue(len(self.q.array) == 100)
self.assertFalse(self.q.enqueue("test"))
self.assertTrue(self.q.get_size() == 100)
def test_is_full_case2(self):
q3 = Queue(3)
for i in range(3):
q3.enqueue(i)
self.assertTrue(q3.get_size() == 3)
self.assertFalse(q3.enqueue("test"))
self.assertTrue(q3.dequeue() == 0)
self.assertTrue(q3.get_size() == 2)
def test_is_empty(self):
self.assertFalse(self.q.dequeue())
def test_enqueue(self):
self.q.enqueue("test1")
self.q.enqueue("test2")
self.q.enqueue("test3")
queue_list = self.q.get_queue_all_list()
self.assertTrue(queue_list[0] == "test1")
self.assertTrue(queue_list[1] == "test2")
self.assertTrue(queue_list[2] == "test3")
self.assertTrue(len(queue_list) == 3)
self.assertTrue(self.q.tail == 3)
def test_dequeue(self):
self.q.enqueue("test1")
self.q.enqueue("test2")
self.q.enqueue("test3")
self.assertTrue(self.q.dequeue() == "test1")
print(self.q.get_queue_all_list())
self.assertTrue(len(self.q.get_queue_all_list()) == 2)
self.assertTrue(self.q.head == 1)
self.assertTrue(self.q.tail == 3)
def test_en_and_dequeu(self):
self.q.enqueue("test1")
self.q.enqueue("test2")
self.assertTrue(self.q.dequeue() == "test1")
self.q.enqueue("test3")
self.assertTrue(self.q.get_size() == 2)
self.assertTrue(self.q.head == 1)
self.assertTrue(self.q.tail == 3)
self.assertTrue(self.q.dequeue() == "test2")
self.q.enqueue("test4")
self.assertTrue(self.q.get_size() == 2)
self.assertTrue(self.q.head == 2)
self.assertTrue(self.q.tail == 4)
def test_get_stack_all_list(self):
self.q.enqueue("test1")
self.q.enqueue("test2")
self.q.enqueue("test3")
check_list = ["test1", "test2", "test3"]
self.assertTrue(len(self.q.get_queue_all_list()) == 3)
self.assertTrue(self.q.get_queue_all_list() == check_list)
self.assertTrue(self.q.dequeue() == check_list.pop(0))
self.assertTrue(len(self.q.get_queue_all_list()) == 2)
self.assertTrue(self.q.get_queue_all_list() == check_list)
class Game:
def __init__(self, file):
with open(file, 'r') as f:
self.cash, self.height, self.width = [int(x) for x in f.readline().split(' ')]
self.waves = LinkedList()
self.waves_num = 0 #This is the amount of waves left, not current wave number
for line in iter(f.readline, ''):
self.waves.add(Wave(*[int(x) for x in line.split(' ')]))
self.waves_num += 1
self.board=Queue() #Incomplete, supposed to create Queue of width and height of read-in file
addme={}
for row in range(self.height):
for column in range(self.width):
addme.update({(row,column):None})
self.board.enqueue(addme)
self.gameover=False
self.turn=0
self.nonplants_amt=0
self.deck=Stack() #Completish, please bugtest, supposed to initialize powerup card deck
for i in range(100):
self.deck.push(random.randint(0,5))
def draw(self):
print("Cash: $", self.cash, "\nWaves: ", self.waves_num, sep = '')
s = ' '.join([str(i) for i in range(self.width - 1)])
print(' ', s)
for row in range(self.height):
s = []
for col in range(self.width):
if self.is_plant(row, col):
char = 'P'
elif self.is_nonplant(row, col):
size = self.board[row][col].size()
char = str(size) if size < 10 else "#"
else:
char = '.'
s.append(char)
print(row, ' ', ' '.join(s), '\n', sep='')
def is_nonplant(self,row, col):
dict1=self.board[0]
if isinstance(dict1[(row, col)], Non_Plant):
return True
else:
return False
def is_plant(self, row, col):
dict1=self.board[0]
if isinstance(dict1[(row, col)], Plant):
return True
else:
return False
def remove(self, row, col): #May need fixing
if self.is_nonplant(row, col):
self.cash+=20
dict1=self.board[0]
del dict1[(row, col)]
self.board[0]=dict1
else:
dict1=self.board[0]
del dict1[(row, col)]
self.board[0]=dict1
def place_nonplant(self, row): #### FIX ME!!!
new_nonplant=Non_Plant()
dict1=self.board[0]
dict1[(row, )]
def place_plant(self, row, col):
dict1=self.board[0]
new_plant=Plant(35, 10)
assert self.cash>=0
self.cash-=new_plant.cost
assert dict1[(row, col)]==None
#Add functionality here to ensure that plants cannot be placed in rightmost column
def place_wave(self):
assert self.turn==self.waves_num*-1
self.waves.head.c.row
def plant_turn(self):
for row in range(self.height):
for column in range(self.width):
class Snake(object):
def __init__(self, stdscr, l=3, d=3, x=MAX_WIDTH / 2, y=MAX_HEIGHT / 2):
self.stdscr = stdscr #Need this for collision detection, I guess?
self.l = l
self.next_direction = d
self.cur_direction = self.next_direction
self.x = x
self.y = y
self.score = 0
self.Q = Queue()
self.Q.enqueue((x, y))
def setDirection(self, direction):
"""
N = 0
E = 1
S = 2
W = 3
"""
if direction > DIR_WEST or direction < DIR_NORTH:
raise Exception("Invalid Direction: " + str(direction))
if (self.cur_direction + direction) % 2 != 0: # This should work...
self.next_direction = direction
def getNextDirection(self):
return self.next_direction
def getCurrentDirection(self):
return self.cur_direction
def getScore(self):
return self.score
def addToScore(self, amount):
self.score += amount
def getLength(self):
return self.l
def lengthen(self):
self.l *= 1.5
def __iter__(self):
return self.Q.__iter__()
def collision(self, x, y):
c = self.stdscr.inch(y, x)
if c != BLANK_SQUARE:
if c == BONUS:
# Get longer!
raise BonusException
else:
raise CollisionException
return False
def move(self):
if self.getNextDirection() == DIR_NORTH:
self.cur_direction = DIR_NORTH
self.y -= 1
self.Q.enqueue((self.x, self.y))
if self.Q.size() > self.getLength():
self.Q.dequeue()
elif self.getNextDirection() == DIR_EAST:
self.cur_direction = DIR_EAST
self.x += 1
self.Q.enqueue((self.x, self.y))
if self.Q.size() > self.getLength():
self.Q.dequeue()
elif self.getNextDirection() == DIR_SOUTH:
self.cur_direction = DIR_SOUTH
self.y += 1
self.Q.enqueue((self.x, self.y))
if self.Q.size() > self.getLength():
self.Q.dequeue()
elif self.getNextDirection() == DIR_WEST:
self.cur_direction = DIR_WEST
self.x -= 1
self.Q.enqueue((self.x, self.y))
if self.Q.size() > self.getLength():
self.Q.dequeue()
self.collision(self.x, self.y)
return (self.x, self.y)
def test_enqueue():
q = Queue()
q.enqueue("apple")
actual = q.is_empty()
expected = False
assert actual == expected
import time
from arr_queue import ArrQueue
from queue import Queue
n = 100000
llq = Queue()
arrq = ArrQueue()
start_time = time.time()
for i in range(n):
llq.enqueue(i)
end_time = time.time()
print(f"LLQueue enqueue time: {end_time - start_time} seconds")
start_time = time.time()
for i in range(n):
arrq.enqueue(i)
end_time = time.time()
print(f"ArrQueue enqueue time: {end_time - start_time} seconds")
start_time = time.time()
for i in range(n):
llq.dequeue()
def test_peek_is_not_none_when_queue_is_not_empty(self): q = Queue() q.enqueue(3) self.assertEquals(q.peek(), 3)
def test_enqueue(): q = Queue(1) assert(q.empty()) assert(q.enqueue(2)) assert(not q.enqueue(2)) assert(q.full())
class QueueTests(unittest.TestCase):
def setUp(self):
self.q = Queue()
def test_len_returns_0_for_empty_queue(self):
self.assertEqual(self.q.len(), 0)
def test_len_returns_correct_length_after_enqueue(self):
self.assertEqual(self.q.len(), 0)
self.q.enqueue(2)
self.assertEqual(self.q.len(), 1)
self.q.enqueue(4)
self.assertEqual(self.q.len(), 2)
self.q.enqueue(6)
self.q.enqueue(8)
self.q.enqueue(10)
self.q.enqueue(12)
self.q.enqueue(14)
self.q.enqueue(16)
self.q.enqueue(18)
self.assertEqual(self.q.len(), 9)
def test_empty_dequeue(self):
self.assertIsNone(self.q.dequeue())
self.assertEqual(self.q.len(), 0)
def test_dequeue_respects_order(self):
self.q.enqueue(80)
self.q.enqueue(101)
self.q.enqueue(105)
self.assertEqual(self.q.dequeue(), 80)
self.assertEqual(self.q.len(), 2)
self.assertEqual(self.q.dequeue(), 101)
self.assertEqual(self.q.len(), 1)
self.assertEqual(self.q.dequeue(), 105)
self.assertEqual(self.q.len(), 0)
self.assertIsNone(self.q.dequeue())
self.assertEqual(self.q.len(), 0)
def test_dequeue(): q = Queue(1) assert(q.dequeue() == None) assert(q.enqueue(2)) assert(q.dequeue() == 2)
def test_enqueue():
q = Queue()
q.enqueue("apple")
actual = q.peek()
expected = "apple"
assert actual == expected
from stack import Stack
from queue import Queue
N = 6
my_stack = Stack(N)
my_stack.push("Australia")
my_stack.push("India")
my_stack.push("Costa Rica")
my_stack.push("Peru")
my_stack.push("Ghana")
my_stack.push("Indonesia")
my_queue = Queue(N)
my_queue.enqueue("Australia")
my_queue.enqueue("India")
my_queue.enqueue("Costa Rica")
my_queue.enqueue("Peru")
my_queue.enqueue("Ghana")
my_queue.enqueue("Indonesia")
#Print the first values in the stack and queue
print("The top value in my stack is: {0}".format(my_stack.peek()))
print("The front value of my queue is: {0}".format(my_queue.peek()))
#Get First Value added to Queue
first_value_added_to_queue = my_queue.peek() #Checkpoint 2
print("\nThe first value enqueued to the queue was {0}".format(
first_value_added_to_queue))
queue_runtime = "1" #Checkpoint 3
print("The runtime of getting the front of the queue is O({0})".format(
def test_queue_is_not_empty(self): q = Queue() q.enqueue(1) self.assertFalse(q.isEmpty())
def test_size_is_greather_than_zero_when_queue_is_not_empty(self): q = Queue() q.enqueue(1) q.enqueue(3) q.enqueue(5) self.assertEquals(q.size(), 3)
def test_dequeue_is_not_none_when_queue_is_not_empty(self): q = Queue() q.enqueue(1) self.assertEquals(q.dequeue(), 1)
#!/usr/bin/env python3
from queue import Queue
n = 10
q = Queue()
q.enqueue("1")
while n > 0:
n -= 1
val = q.dequeue()
val1 = val + "0"
q.enqueue(val1)
val2 = val + "1"
q.enqueue(val2)
print(f'n: {10 - n}, val: {val}, queue: {q.items}')
class WordLadder:
"""A class providing functionality to create word ladders"""
def __init__(self, w1, w2, wordlist):
self.startword = w1
self.endword = w2
self.mydictionary = wordlist
self.myqueue = Queue()
self.mystack = Stack()
self.word_exist_set = set()
def make_ladder(self):
ALPHE_LIST = [
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
]
self.mystack.push(self.startword)
self.myqueue.enqueue(self.mystack)
self.word_exist_set.add(self.startword)
while not self.myqueue.isEmpty():
current_stack = self.myqueue.dequeue()
current_word = current_stack.peek()
# change one digit
for i in range(len(current_word)):
for letter in ALPHE_LIST:
new_word = current_word[:i] + letter + current_word[i + 1:]
if (new_word in self.mydictionary[len(new_word)]
and new_word not in self.word_exist_set):
self.word_exist_set.add(new_word)
new_stack = current_stack.copy()
new_stack.push(new_word)
if new_word == self.endword:
return new_stack
else:
self.myqueue.enqueue(new_stack)
# add one digit
for i in range(len(current_word) + 1):
for letter in ALPHE_LIST:
new_word = current_word[:i] + letter + current_word[i:]
if len(new_word) in self.mydictionary.keys():
if (new_word in self.mydictionary[len(new_word)]
and new_word not in self.word_exist_set):
self.word_exist_set.add(new_word)
new_stack = current_stack.copy()
new_stack.push(new_word)
if new_word == self.endword:
return new_stack
else:
self.myqueue.enqueue(new_stack)
# delete one digit
for i in range(len(current_word)):
new_word = current_word.replace(current_word[i], "", 1)
if len(new_word) in self.mydictionary.keys():
if (new_word in self.mydictionary[len(new_word)]
and new_word not in self.word_exist_set):
self.word_exist_set.add(new_word)
new_stack = current_stack.copy()
new_stack.push(new_word)
if new_word == self.endword:
return new_stack
else:
self.myqueue.enqueue(new_stack)
return None
class TestQueue(unittest.TestCase):
def setUp(self):
self.queue = Queue()
def test_enqueue(self):
self.assertEqual(0, self.queue.get_size())
self.queue.enqueue(5)
self.assertEqual(1, self.queue.get_size())
self.assertEqual(5, self.queue.peek())
self.queue.enqueue(6)
self.assertEqual(2, self.queue.get_size())
self.assertEqual(5, self.queue.peek())
self.queue.enqueue("hello")
self.assertEqual(3, self.queue.get_size())
self.assertEqual(5, self.queue.peek())
def test_dequeue(self):
self.queue.enqueue(12)
self.queue.enqueue(14)
self.queue.enqueue(16)
self.assertEqual(3, self.queue.get_size())
self.assertEqual(12, self.queue.dequeue())
self.assertEqual(2, self.queue.get_size())
self.assertEqual(14, self.queue.dequeue())
self.assertEqual(1, self.queue.get_size())
self.assertEqual(16, self.queue.dequeue())
self.assertEqual(0, self.queue.get_size())
def test_peek(self):
self.assertEqual(None, self.queue.peek())
self.queue.enqueue("test")
self.assertEqual("test", self.queue.peek())
self.queue.enqueue("word")
self.assertEqual("test", self.queue.peek())
self.queue.dequeue()
self.assertEqual("word", self.queue.peek())
self.queue.dequeue()
self.assertEqual(None, self.queue.peek())
class Handler:
""" Handler class """
_OPTIONS = {
"1": "add_to_queue",
"2": "remove_from_queue",
"3": "get_first_item",
"4": "get_queue_size",
"5": "is_queue_empty",
"q": "quit"
}
def __init__(self):
""" Initialize class """
self.queue = Queue()
self.start()
def _get_method(self, method_name):
"""
Uses function getattr() to dynamically get value of an attribute.
"""
return getattr(self, self._OPTIONS[method_name])
def _print_menu(self):
"""
Use docstring from methods to print options for the program.
"""
menu = ""
for key in sorted(self._OPTIONS):
method = self._get_method(key)
docstring = inspect.getdoc(method)
menu += "{choice}: {explanation}\n".format(
choice=key,
explanation=docstring
)
print(chr(27) + "[2J" + chr(27) + "[;H")
print(menu)
def add_to_queue(self):
""" Adds a node to the queue. """
value = input("\nAdd a value: \n>>> ")
self.queue.enqueue(value)
print(f"{value} has been added.")
def remove_from_queue(self):
""" Removes the first node from the queue. """
try:
print(f"{self.queue.dequeue()} has been removed.")
except EmptyQueueException as e:
print(f"Error: {e}")
def get_first_item(self):
""" Prints the value of the first queue node. """
try:
print(self.queue.peek())
except EmptyQueueException as e:
print(f"Error: {e}")
def get_queue_size(self):
""" Shows the queue length. """
print(self.queue.size())
def is_queue_empty(self):
""" Shows if the queue is empty or not. """
print(self.queue.is_empty())
@staticmethod
def quit():
""" Quit the program """
sys.exit()
def start(self):
""" Start method """
while True:
self._print_menu()
choice = input("Enter menu selection:\n-> ")
try:
self._get_method(choice.lower())()
except KeyError:
print("Invalid choice!")
input("\nPress any key to continue ...")
def test_size():
q = Queue()
for n in que:
q.enqueue(n)
assert q.size() == n
from queue import Queue
q = Queue()
print(q.isEmpty())
#True
q = Queue()
q.enqueue("Kekse")
q.enqueue("Kuchen")
print(q.head())
print(q.dequeue())
print(q.head())
print(q.dequeue())
print(q.head())
#Kekse
def test_dequeue():
q = Queue()
for n in que:
q.enqueue(n)
assert q.dequeue() == 1
assert q.size() == 4
def test_enque():
q = Queue()
for n in que:
q.enqueue(n)
q.enqueue(6)
assert q.size() == 6
def test_that_element_added_to_array(self):
queue_list = []
queue = Queue(queue_list)
queue.enqueue('banana')
self.assertEqual(queue.queue_list, ['banana'])
def main():
queue = Queue()
queue.enqueue('hello')
queue.enqueue('dog')
queue.enqueue(3)
print(queue.display())
queue.dequeue()
print(queue.display())
queue.dequeue()
print(queue.display())
queue.dequeue()
print(queue.display())
queue.dequeue()
queue.enqueue('world')
queue.enqueue('cat')
queue.enqueue(1)
print(queue.size())
print(queue.display())
queue.clear()
print(queue.display())
def test_queue():
p = Queue()
p.enqueue(1)
p.enqueue(2)
assert p.dequeue() == 1
assert p.dequeue() == 2
def test_enqueue_add_item_and_return_true(self):
queue = Queue(5)
self.assertTrue(queue.enqueue(5))
self.assertTrue(queue.enqueue("Hello"))
self.assertTrue(queue.enqueue(False))
self.assertTrue(queue.enqueue(1.5))
def test_enqueueAndDequeue(self):
queue = Queue()
queue.enqueue(5)
queue.enqueue(11)
queue.enqueue(15)
queue.enqueue(0)
queue.enqueue(88)
el = queue.dequeue()
self.assertEqual(queue.size(), 4)
self.assertEqual(el, 5)
queue.enqueue(99)
self.assertEqual(queue.size(), 5)
el = queue.dequeue()
self.assertEqual(queue.size(), 4)
self.assertEqual(el, 11)
el = queue.dequeue()
self.assertEqual(queue.size(), 3)
self.assertEqual(el, 15)
el = queue.dequeue()
self.assertEqual(queue.size(), 2)
self.assertEqual(el, 0)
el = queue.dequeue()
self.assertEqual(queue.size(), 1)
self.assertEqual(el, 88)
el = queue.dequeue()
self.assertEqual(queue.size(), 0)
self.assertEqual(el, 99)
el = queue.dequeue()
self.assertEqual(el, None)
queue.enqueue(100)
self.assertEqual(queue.size(), 1)
el = queue.dequeue()
self.assertEqual(queue.size(), 0)
self.assertEqual(el, 100)
def test_peek_returns_first_added_value_without_removing_it(self):
queue = Queue(3)
queue.enqueue(5)
queue.enqueue(4)
self.assertEqual(5, queue.peek())
self.assertEqual(2, queue.size)
def construct_queue(l):
q = Queue()
for elem in l:
q.enqueue(elem)
return q
