def hotLine(namelist, num):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)
while simqueue.size() > 1:
for i in range(num):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def hotPotato(names, num):
q = Queue()
for ele in names:
q.enqueue(ele)
while q.size() > 1:
for i in range(num):
q.enqueue(q.dequeue())
q.dequeue()
return q.dequeue()
def hotpotato(li, n):
simqueue = Queue()
for i in li:
simqueue.enqueue(i)
while simqueue.size() > 1:
for i in range(n):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def hotline(namelist, num):
s = Queue()
for name in namelist:
s.enqueue(name)
#return s.size()
while s.size() > 1:
for i in range(num):
s.enqueue(s.dequeue())
s.dequeue()
return s.dequeue()
def hot_potato(name, num=None):
# num = random.randint(1,20)
q = Queue()
for n in name:
q.enqueue(n)
while q.size() > 1:
for _ in range(num):
q.enqueue(q.dequeue())
q.dequeue()
return q.dequeue()
def hot_potato(namelist, num):
queue = Queue()
for name in namelist:
queue.enqueue(name)
while queue.size() > 1:
for _ in range(num):
queue.enqueue(queue.dequeue())
queue.dequeue()
return queue.dequeue()
def hot(names,num): simque = Queue() for name in names: simque.enqueue(name) while simque.size() > 1: for i in range(num): simque.enqueue(simque,dequeue()) simque.dequeue() return simque.dequeue()
def hotPotato(namelist, num):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)
while simqueue.size() > 1:
for i in range(num):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def hotPotato(namelist, num):
playQueue = Queue()
for name in namelist:
playQueue.enqueue(name)
while playQueue.size() > 1:
for i in range(num):
player = playQueue.dequeue()
playQueue.enqueue(player)
else:
playQueue.dequeue()
return playQueue.dequeue()
def hotPotato(namelist, num):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)
while simqueue.size() > 1:
for i in range(random.randrange(1,num)):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def hot_potato_simulator(name_list, num):
simple_queue = Queue()
for name in name_list:
simple_queue.enqueue(name)
while simple_queue.size() > 1:
for i in range(num):
simple_queue.enqueue(simple_queue.dequeue())
simple_queue.dequeue()
return simple_queue.dequeue()
def hotPotato(namelist):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)
length = len(namelist)
randomor = random.Random()
while simqueue.size() > 1:
num = randomor.randrange(length, 2 * length + 1)
for i in range(num):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def hotPotato(namelist):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)
while simqueue.size() > 1:
n = random.randint(1, 10)
for i in range(n):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def simulation(numSeconds, tasksPerMinute):
worker1 = Worker(2)
worker2 = Worker(3)
worker3 = Worker(4)
team = Team(worker1, worker2, worker3)
taskQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newTask():
task = Task(currentSecond)
taskQueue.enqueue(task)
if (not team.allBusy()) and (not taskQueue.isEmpty()):
nextTask = taskQueue.dequeue()
team.assignTask(nextText())
waitingtimes.append(nexttask.waitTime(currentSecond))
team.assignTask()
team.tick()
averageWait = sum(waitingtimes) #/len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait, taskQueue.size()))
def bfs(self, adj_node):
adj_node.color = Color.gray
adj_node.parent_node = None
adj_node.parent_distance = 0
node_queue = Queue()
node_queue.enqueue(adj_node)
while node_queue.size() > 0:
adj_node = node_queue.dequeue()
if self.found:
break
for node_tup in adj_node.child_nodes:
vertex = node_tup[0]
assert isinstance(vertex, Node)
if vertex.color is Color.white:
vertex.color = Color.gray
vertex.parent_distance = int(node_tup[1])
vertex.parent_node = adj_node
node_queue.enqueue(vertex)
if vertex.name.strip().lower() == self.destination:
self.found = True
self.__searched_list__.append(vertex)
break
adj_node.color = Color.black
def transpose(self):
for aVertex in self:
aVertex.setColor('white')
for key in self.vertices:
start = self.vertices[key]
break
vertQueue = Queue()
vertQueue.enqueue(start)
while vertQueue.size() > 0:
currentVert = vertQueue.dequeue()
toDel = []
for nbr in currentVert.getConnections():
# here is the key
if currentVert.connectedTo[nbr] != -1:
nbr.connectedTo[currentVert] = -1
toDel.append(nbr)
if nbr.getColor() == 'white':
vertQueue.enqueue(nbr)
for vertex in toDel:
if currentVert.connectedTo[vertex] == 0:
del currentVert.connectedTo[vertex]
currentVert.setColor('black')
def isReachable(self,u,v):
"""
:param u: Key
:param v: Key
:return:
"""
vertList=self.getVertices()
assert(u in vertList and v in vertList)
start=self.getVertex(u)
end=self.getVertex(v)
start.setDistance(0)
start.setPred(None)
vertQueue=Queue()
vertQueue.enqueue(start)
while(vertQueue.size()!=0):
currentVert=vertQueue.dequeue()
if currentVert.getId()==end.getId():
return True
for nbr in currentVert.getConnections():
if nbr.getColor()=="white":
nbr.setColor('gray')
nbr.setPred(currentVert)
nbr.setDistance(currentVert.getDistance()+1)
vertQueue.enqueue(nbr)
currentVert.setColor('black')
return False
def simulateOneServer(file_name):
import pandas as pd
df = pd.read_csv(file_name, index_col=0, names = ['currentSecond', 'task', 'Time'])
df2 = df.reset_index()
server = Server()
requestQueue = Queue()
waitingtimes = []
starttime = df2['currentSecond'][0]
for x in range(len(df2)):
task = Task(df2['Time'][x])
requestQueue.enqueue(task)
for x in range(len(df2)):
endtime = starttime + df2['Time'][x]
starttime = endtime
nexttask = requestQueue.dequeue()
waitingtimes.append(nexttask.waitTime(starttime, df2['currentSecond'][x]))
if (not server.busy()) and (not requestQueue.isEmpty()):
server.startNext(nexttask)
server.tick()
averageWait=sum(waitingtimes)/len(waitingtimes)
print("Average Wait %6.2f secs for a single server."%(averageWait))
def hot_potato(names, count):
"""一圈孩子围在一起，一个孩子手里拿着一个热狗，
从他开始将热狗向旁边人传递，一定次数后踢掉拿着热狗的孩子
:param names: List[str]
:param count: int
:return: str
"""
q = Queue()
for n in names: # 将孩子全部加入队列，队首的孩子拿着热狗
q.enqueue(n)
while q.size() > 1:
for _ in range(count):
child = q.dequeue() # 弹出第一个孩子
q.enqueue(child) # 加入队尾，相当于传递一次热狗
q.dequeue() # 将第一个孩子踢出
last_child = q.dequeue() # 最后一个孩子
return last_child
def hot_potato(name_list, num):
# Create the list of names/participants
simqueue = Queue()
for name in name_list:
simqueue.enqueue(name)
# Run the game until there is only 1 person remaining
while simqueue.size() > 1:
for i in range(num):
simqueue.enqueue(simqueue.dequeue())
print(simqueue.size())
print('hello')
simqueue.dequeue()
print(simqueue.size())
return simqueue.dequeue()
def test(self, wordStart):
if self.isNoChain(wordStart):
return False
start = self.graph.getVertex(wordStart)
start.setDistance(0)
start.setPred(None)
vrtxQueue = Queue()
vrtxQueue.enqueue(start)
#print(wordStart,end='')
d = defaultdict(list)
while vrtxQueue.size() > 0:
ls = []
current = vrtxQueue.dequeue()
#print(current.getId(),end='')
prev = None
for neighbour in current.getConnections():
if neighbour.getColor() == "white":
neighbour.setColor("gray")
neighbour.setDistance(current.getDistance() + 1)
neighbour.setPred(current)
dist = neighbour.getDistance()
word = neighbour.getId()
d[dist].append(word)
#print("->"+neighbour.getId(),end='')
ls.append(neighbour)
##if neighbour.getId() == wordEnd :
# print("\n\n\t",end='');
#vrtxQueue.enqueue(neighbour)
for i in range(len(ls)):
vrtxQueue.enqueue(ls.pop(0))
current.setColor("black")
outfile = open('Chains.txt', 'a')
print("WORD : " + wordStart, file=outfile)
for length in d.keys():
print(
'----------------------- Length : {} -----------------------'.
format(length),
file=outfile)
self.frequency.setdefault(length, 0)
self.frequency[length] += len(d[length])
for word in d[length]:
vert = self.graph.getVertex(word)
print(vert.getId(), end='', file=outfile)
for count in range(length):
print(" -> " + vert.getPred().getId(),
end='',
file=outfile)
#print()
vert = vert.getPred()
print(file=outfile)
print(file=outfile)
def bfs(g,start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while (vertQueue.size() > 0): currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections(): if (nbr.getColor() == 'white'):
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
def simulateManyServers(file_name, servers):
import pandas as pd
df = pd.read_csv(file_name, index_col=0, names = ['currentSecond', 'task', 'Time'])
df2 = df.reset_index()
df2['RoundRobin'] = ''
networks = servers
orig_networks = servers
for x in range(len(df2)):
df2.at[x, 'RoundRobin'] = networks
networks -= 1
if networks == 0:
networks = orig_networks
for x in range(1, orig_networks + 1):
df3 = df2[df2['RoundRobin']==x]
df3.reset_index(inplace=True)
server = Server()
requestQueue = Queue()
waitingtimes = []
starttime = df3['currentSecond'][0]
for x in range(len(df3)):
task = Task(df3['Time'][x])
requestQueue.enqueue(task)
for x in range(len(df3)):
endtime = starttime + df3['Time'][x]
if df3['currentSecond'][x] > endtime:
starttime = df3['currentSecond'][x]
else:
starttime = endtime
nexttask = requestQueue.dequeue()
waitingtimes.append(nexttask.waitTime(starttime, df3['currentSecond'][x]))
if (not server.busy()) and (not requestQueue.isEmpty()):
server.startNext(nexttask)
# all_waitingtimes.append(averagesubWait)
server.tick()
averageWait=sum(waitingtimes)/len(waitingtimes)
print("Average Wait {} secs for {} servers.".format("{:.2f}".format(round(averageWait,2)), servers))
def bfs(g, start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while vertQueue.size() > 0:
currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections():
if nbr.getColor() == "white":
nbr.setColor("gray")
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
currentVert.setColor("black")
def bfs(g, start):
start.setDistance(0) #起点的距离设为0
start.setPred(None) #起点没有父节点
vertQueue = Queue() #建立一个队列
vertQueue.enqueue(start) #将起点加入队列中
while (vertQueue.size() > 0): #当队列存在对象时
currentVert = vertQueue.dequeue() #弹出对象并设置为当前节点
"""该迭代阐明了bfs的特点就是把每个邻居都遍历，先完成一层，再往下完成，“广”"""
for nbr in currentVert.getConnections(): #搜索当前节点的所有邻居
if (nbr.getColor() == 'white'): #如果邻居x是白色的（即待搜索）
nbr.setColor('gray') #设为灰色意为正在处理
nbr.setDistance(currentVert.getDistance() + 1) #该邻居距离为当前节点+1
nbr.setPred(currentVert) #该邻居的父节点是当前节点
vertQueue.enqueue(nbr) #队列加入该邻居
def bfs(g, start): # --起始顶点作为参数
start.setDistance(0) # --起始顶点的距离
start.setPred(None) # --前驱
vertQueue = Queue()
vertQueue.enqueue(start) # --加入到队列里
while (vertQueue.size() > 0): # --只要队列有顶点
currentVert = vertQueue.dequeue() # -- 取队首作为当前顶点
for nbr in currentVert.getConnections(): # --遍历邻接顶点
if (nbr.getColor() == 'white'): # --邻接顶点是白色的
nbr.setColor('gray') # --将邻接顶点改为灰色
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert) # --前驱设为当前顶点
vertQueue.enqueue(nbr) # --入队，排到队尾
currentVert.setColor('black') # --for循环结束，将当前顶点设为黑色
def bfs(g, start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while (vertQueue.size() > 0):
currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections():
if nbr.getColor() == "while":
nbr.setColor("gray")
nbr.setDistance(currentVert.getDistance + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
currentVert.setColor("black")
def pathExists(start,end):
vertexQueue=Queue()
vertexQueue.enqueue(start)
while (vertexQueue.size()>0):
item=vertexQueue.dequeue()
if item.getId()==end.getId():
print ("path exists")
return True
else:
for vertex in item.getConnections():
if vertex.getColor()=="white":
vertex.setColor("gray")
vertexQueue.enqueue(vertex)
return False
def bfs(g,start):
start.setDistance(0)
start.setPred(None)#set predecessor to none in order to make this the root of the tree
vertQueue = Queue() #instantiates a queque
vertQueue.enqueue(start) #adds to queque
while (vertQueue.size() > 0):
currentVert = vertQueue.dequeue() #removes first vertex added to the queque
for nbr in currentVert.getConnections(): #gets the vertex's list of connections and loops through the list
if (nbr.getColor() == 'white'):#if unexplored
nbr.setColor('gray')#set to explored
nbr.setDistance(currentVert.getDistance() + 1) #Gives weight/distance of vertex to root. Can be considered layers of tree
nbr.setPred(currentVert)#set predecessor/parent vertex
vertQueue.enqueue(nbr) #places back in queue to explore if vertex has other connections/children
currentVert.setColor('black') #explored
def simulation(total_seconds, pages_per_minute):
queue, wait_times = Queue(), []
printer = Printer(pages_per_minute)
for second in range(total_seconds):
if new_print_task():
queue.enqueue(Task(second))
if not printer.busy() and not queue.is_empty():
task = queue.dequeue()
wait_times.append(task.wait_time(second))
printer.start_next(task)
printer.tick()
print(f'Average Wait {sum(wait_times) / len(wait_times):6.2f} secs {queue.size():2d} tasks remaining.')
def breadthFirstSearch(start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while vertQueue.size() > 0:
dequeueVert = vertQueue.dequeue()
for neighbor in dequeueVert.getConnections():
if neighbor.getColor() == 'white':
vertQueue.enqueue(neighbor)
neighbor.setColor('gray')
neighbor.setDistance(dequeueVert.getDistance() + 1)
neighbor.setPred(dequeueVert)
dequeueVert.setColor('black')
def bfs(graph, start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue() # 利用队列储存邻接的顶点
vertQueue.enqueue(start)
while vertQueue.size() > 0:
currentVert = vertQueue.dequeue() # 对出列的顶点进行操作
for nbr in currentVert.getConnections():
if nbr.getColor(
) == 'white': # 这是pythonds中写好的初始化属性,为白色,代表了此顶点未被探索过
nbr.setColor('gray') # 一个顶点第一次被发现,则被标记为灰色
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
currentVert.setColor('black') # 一个顶点的所有邻接顶点都被探索后会被标记为黑色
def bfs(self, start):
# start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while vertQueue.size() > 0:
currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections():
# print(nbr)
if nbr.getColor() == 'white':
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
currentVert.setColor('black')
def bfs(self, start):
# start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while vertQueue.size() > 0:
currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections():
# print(nbr)
if nbr.getColor() == 'white':
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
currentVert.setColor('black')
def bfs(g, start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while (vertQueue.size() > 0):
current_vertex = vertQueue.dequeue()
for nbr in current_vertex:
if nbr.getColor() == 'white':
nbr.setColor('gray')
nbr.setDistance(current_vertex.getDistance() + 1)
nbr.setPred(current_vertex)
vertQueue.enqueue(nbr)
current_vertex.setColor('black')
def bfs(g,s):
#s = g.getVertex(vertKey)
s.setDistance(0)
s.setPred(None)
s.setColor('gray')
Q = Queue()
Q.enqueue(s)
while (Q.size() > 0):
w = Q.dequeue()
for v in w.getAdj():
print v.id
if(v.getColor() == 'white'):
v.setColor('gray')
v.setDistance(w.getDistance() + 1)
v.setPred(w)
Q.enqueue(v)
w.setColor('black')
def bfs(g,start,searchKey):
vertexQueue=Queue()
start.setDistance(0)
vertexQueue.enqueue(start)
while (vertexQueue.size()>0):
currentVertex=vertexQueue.dequeue()
print currentVertex.getId()
if(searchKey==currentVertex.getId()):
print "distance is",currentVertex.getDistance()
break
for vertex in currentVertex.getConnections():
if (vertex.getColor()=="white"):
vertex.setColor("gray")
print currentVertex.getDistance()
vertex.setDistance(currentVertex.getDistance()+1)
vertexQueue.enqueue(vertex)
currentVertex.setColor("black")
def bfs(g, start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while vertQueue.size() > 0:
currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections():
if nbr.getColor() == 'white':
# gray means in queue, waiting to be exhausted
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
# black means it's exhausted
currentVert.setColor('black')
def simulation(numSeconds, pagesPerMinute):
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and \
(not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append( \
nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait=sum(waitingtimes)/len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining."\
%(averageWait,printQueue.size()))
def bfs(seed, graph):
""" Finds connected nodes to seeds with given graph
Args:
seed (Vertex): vertex with seed ID
graph (Graph): contains edges from source node to target node
Returns:
list(str(seed ID)): list of connected seeds
"""
seed.setDistance(0)
seed.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(seed)
connected_nodes = []
while (vertQueue.size() > 0):
currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections():
if (nbr.getColor() == 'white'):
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance()+1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
connected_nodes.append(nbr.getId())
currentVert.setColor('black')
return connected_nodes
