Graph, Stack, Queue, Search

First line: two integers n and m — how many nodes and how many edges.Second line: n node names.Next m lines: two node names, meaning an edge between them.Every edge works in BOTH directions.Constraint: 1 ≤ n ≤ 50Last line: one node name q.

One line: the neighbours of q in alphabetical order, separated by single spaces.If q has no neighbours, print none

def build_graph(names, edges):    # TODO: start every name with an empty list,    #       then add BOTH directions for every edge    passdef neighbours_of(graph, node):    # TODO: return the neighbour list, sorted    passfirst = input().split()n = int(first[0])m = int(first[1])names = input().split()edges = []for _ in range(m):    parts = input().split()    edges.append((parts[0], parts[1]))q = input().strip()graph = build_graph(names, edges)result = neighbours_of(graph, q)if len(result) == 0:    print("none")else:    print(" ".join(result))

First line: one integer k — how many commands.Next k lines: either    do WORD     record one action    undo        remove the most recent actionConstraint: 1 ≤ k ≤ 100

For every undo, print the action that was removed.If the log was already empty, print nothingAfter all commands, print the remaining log on one line, oldest first.If the log is empty at the end, print empty

k = int(input())log = []for _ in range(k):    parts = input().split()    if parts[0] == "do":        # TODO: record parts[1]        pass    else:        # TODO: remove and print the most recent action,        #       or print nothing when the log is empty        pass# TODO: print the remaining log, or empty

First line: one integer k — how many commands.Next k lines: either    join NAME   the person joins the back of the line    serve       the person at the front is servedConstraint: 1 ≤ k ≤ 100

For every serve, print the name of the person served.If the line was empty, print nobodyAfter all commands, print who is still waiting on one line, front first.If nobody is waiting, print empty

k = int(input())line = []for _ in range(k):    parts = input().split()    if parts[0] == "join":        # TODO: parts[1] joins the BACK        pass    else:        # TODO: serve and print the person at the FRONT,        #       or print nobody when the line is empty        pass# TODO: print who is still waiting, or empty

First line: one integer n.Second line: n values separated by spaces.Constraint: 1 ≤ n ≤ 100

Two lines.Line 1: the values taken out using a QUEUE, separated by single spaces.Line 2: the values taken out using a STACK.

def take_all(items, mode):    # TODO: copy every item into a waiting list,    #       then empty it. "queue" takes the front,    #       "stack" takes the back.    passn = int(input())values = input().split()print(" ".join(take_all(values, "queue")))print(" ".join(take_all(values, "stack")))

First line: two integers n and m — how many nodes and how many edges.Second line: n node names.Next m lines: two node names, meaning an edge between them.Every edge works in BOTH directions.Constraint: 1 ≤ n ≤ 50Last line: two node names, the start and the goal.

One line: the number of edges on the shortest route.Print 0 when the start is the goal.Print -1 when there is no route at all.

def build_graph(names, edges):    # TODO: same as problem 1    passdef fewest_steps(graph, start, goal):    frontier = [start]    steps = {start: 0}      # this dict is also the "already seen" record    while len(frontier) > 0:        # TODO: take the OLDEST cell out of frontier        # TODO: if it is the goal, return steps[current]        # TODO: for every unseen neighbour,        #       steps[nxt] = steps[current] + 1, then add it to frontier        pass    return -1first = input().split()n = int(first[0])m = int(first[1])names = input().split()edges = []for _ in range(m):    parts = input().split()    edges.append((parts[0], parts[1]))last = input().split()graph = build_graph(names, edges)print(fewest_steps(graph, last[0], last[1]))

First line: two integers n and m — how many nodes and how many edges.Second line: n node names.Next m lines: two node names, meaning an edge between them.Every edge works in BOTH directions.Constraint: 1 ≤ n ≤ 50Last line: one node name, the start.

Two lines.Line 1: the BFS visit order, separated by single spaces.Line 2: the DFS visit order.Only nodes you can actually reach appear.

def build_graph(names, edges):    # TODO: same as problem 1, but sort every    #       neighbour list before you return    passdef visit_order(graph, start, mode):    frontier = [start]    seen = {start: True}    order = []    while len(frontier) > 0:        # TODO: "bfs" takes the oldest, "dfs" takes the newest        # TODO: add current to order        # TODO: add every unseen neighbour to seen and to frontier        pass    return orderfirst = input().split()n = int(first[0])m = int(first[1])names = input().split()edges = []for _ in range(m):    parts = input().split()    edges.append((parts[0], parts[1]))start = input().strip()graph = build_graph(names, edges)print(" ".join(visit_order(graph, start, "bfs")))print(" ".join(visit_order(graph, start, "dfs")))