Collage Interview Tips: Real Questions Answers & OA Interviews

				
					from collections import deque

def find_shortest_linkedin_path(graph, user_a, user_b): if user_a == user_b
    if user_a == user_b.
        return [user_a]

    queue = deque([(user_a, [user_a])]) # (current user, current path)
    visited = {user_a} # Record visited users to avoid duplicate explorations

    while queue.
        current_user, path = queue.popleft()

        # Check for one-time connections
        for neighbor in graph.get(current_user, []):
            if neighbor == user_b.
                return path + [neighbor]
            if neighbor not in visited.
                visited.add(neighbor)
                queue.append((neighbor, path + [neighbor]))

            # Checking second degree connections
            for second_degree_neighbor in graph.get(neighbor, []):
                if second_degree_neighbor == user_b.
                    return path + [neighbor, second_degree_neighbor]
                # Note: the path length of a second degree join is 2, so it only returns when it reaches the goal
                # Otherwise, adding all second-degree connections to the queue may result in a non-shortest path
                # The logic here is to ensure that a second degree connection is only considered a valid path if it connects directly to user_b.
                # Otherwise, it will be treated as a normal one-degree connection in subsequent BFS iterations

    return None # No path found

# Example usage
linkedin_graph = {
    
    
    "C": ["A", "G"], "D".
    "D": ["A", "H"], "E".
    "E": ["B", "G"], "F".
    "F": ["B"], "G".
    "G": ["C", "E"], "H".
    "H": ["D"]
}

# Find the shortest recommended path from A to B
path = find_shortest_linkedin_path(linkedin_graph, "A", "B")
print(f "Shortest recommended path from A to B: {path}") # Expected output: Shortest recommended path from A to B: ['A', 'C', 'G', 'E', 'B'] or ['A', 'D', 'H', 'B'] (need to check the logic of the second-degree link further)

# Let's fix the logic of the second degree join to make sure it forms the shortest path correctly
# The code above handles the second degree join OK if it connects directly to B, but needs to be more careful if the second degree join itself also serves as a new starting point
# The core of BFS is hierarchical traversal, so the node of a second degree join should be accessed at the next layer, not directly added to the current layer

# Rework the logic of find_shortest_linkedin_path to be more consistent with BFS hierarchical exploration
def find_shortest_linkedin_path_optimized(graph, user_a, user_b):: if user_a == user_b
    if user_a == user_b.
        return [user_a]

    # Queue storage (current user, current path)
    queue = deque([(user_a, [user_a])])
    # visited collection stores visited users to avoid loops and double counting
    visited = {user_a}

    while queue.
        current_user, path = queue.popleft()

        # Checking for one-step connections (one-step connections)
        for next_user_1 in graph.get(current_user, []):
            if next_user_1 == user_b.
                return path + [next_user_1]
            if next_user_1 not in visited.
                visited.add(next_user_1)
                queue.append((next_user_1, path + [next_user_1]))

            # Checking a two-step connection (second-degree connection)
            # Note: here we are exploring the neighbors of next_user_1, i.e. from current_user to next_user_1 to next_user_2
            for next_user_2 in graph.get(next_user_1, []):
                # Path length is current_user -> next_user_1 -> next_user_2
                if next_user_2 == user_b.
                    return path + [next_user_1, next_user_2]
                # Note: Second-degree connected nodes are only added to the queue if they have not been visited and can be used as a starting point for the next level of exploration
                # But according to the question, each step in the path must be either a first-degree or second-degree connection, which implies that we only need to check for second-degree connections once
                # and if the second degree connection points to B, then this is a valid recommended path
                # If the second degree node itself needs to be explored further, then it will be treated as the "next_user_1" of the first degree connection in subsequent iterations.

    return None

# Example usage again
path_optimized = find_shortest_linkedin_path_optimized(linkedin_graph, "A", "B")
print(f "Shortest recommended path from A to B (optimized): {path_optimized}")

# Re-verify the path in the example diagram
# A -> C (1 degree)
# C -> G (1 degree)
# G -> E (1 degree)
# E -> B (1 degree)
# Path: A -> C -> G -> E -> B (4 steps, but each step is 1 degree)

# A -> C (1 degree)
# C's 2nd degree connection:
# C -> G (1 degree), G has neighbors C, E
# C -> G -> E (degree 2)
# If B is E, the path is A -> C -> G -> E -> B

# Let's re-conceptualize "each step in the path must be a one or two degree connection."
# This means that we can walk from the current node to its first degree connection or to its second degree connection (via an intermediate node).
# Then instead of a fixed step size of 1, the BFS step size is 1 or 2.
# We can modify BFS to try to expand to its 1-hop and 2-hop neighbors each time a node is out of the queue.

def find_shortest_linkedin_path_final(graph, user_a, user_b).
    if user_a == user_b.
        return [user_a]

    queue = deque([(user_a, [user_a])])
    # visited should store the user, not the path, since paths are dynamically constructed
    # But to avoid infinite loops, we need to keep track of the visited users.
    # To keep track of the shortest path here, visited should store (user, length) or just user
    # and should be stopped once the path is found
    visited = {user_a}

    while queue: current_user, path = queue
        current_user, path = queue.popleft()

        # Attempt a one-step connection (one-time connection)
        for next_user_1 in graph.get(current_user, []):
            if next_user_1 == user_b.
                return path + [next_user_1]
            if next_user_1 not in visited.
                visited.add(next_user_1)
                queue.append((next_user_1, path + [next_user_1]))

            # Attempting a two-step join (two-degree join)
            for next_user_2 in graph.get(next_user_1, []):
                # Ensure that next_user_2 is not the current_user itself to avoid an invalid two-way join
                if next_user_2 == current_user.
                    continue

                if next_user_2 == user_b.
                    return path + [next_user_1, next_user_2] # Note that the path here will include the intermediate node next_user_1

                # If next_user_2 has not been accessed yet and it is a valid new node
                # we add it to the queue, but note that it arrives after "two steps"
                # This means that path + [next_user_1, next_user_2] is the full path
                # The visited mechanism here needs a bit of tweaking to ensure the shortest paths
                # Legacy BFS skips visited nodes when it encounters them, but should also skip visited nodes if they are reached via a longer path
                if next_user_2 not in visited.
                    # For a second degree connection, we are actually finding a longer path, so if the target is user_b, we should return it immediately.
                    # Otherwise, if next_user_2 is added to the queue, then its path length is path length + 2
                    # And if next_user_2 is also reachable via a one-degree connection, then BFS will prioritize the one-degree connection path
                    # The key here is to ensure the shortest path, so next_user_2 is only considered if it's not being accessed
                    # and need to mark next_user_2 as visited
                    # But this may result in a non-shortest path, because if next_user_2 can be reached by a shorter path afterwards
                    # So it would be better to return the second degree path only if the target is found, otherwise only one degree connection is added
                    pass # does not add second-degree connections directly to the queue here, but lets them be processed as first-degree connections in subsequent BFS iterations.
                    # The core idea is that BFS guarantees the shortest tier, if a node can be reached at the current tier by a first degree connection, then it is the shortest.
                    # If it can only be reached by a second degree connection, then it is not considered until the next layer.

    return None

# Let's rethink "each step in the path must be either a first-degree or second-degree connection".
# This means that the path we can take from A to B is A -> X1 -> X2 -> ... -> B
# where A to X1 can be a 1 degree or 2 degree connection
# X1 to X2 can be 1 or 2 degree connections, and so on.
# This is really a problem of finding the shortest path on a modified graph.
# The modified graph has edge weights of 1 if A and C are 1 degree connected.
# If there is a 2-degree connection between A and D (via E), then the edge weight is 1.
# In this way, the BFS works properly.

# A clearer solution is:
# 1. Construct a new graph in which an edge is added between two users if there is a 1-degree or 2-degree connection between them.
# 2. Perform standard BFS on the new graph.

# But the interviewer expects a straightforward solution on the original graph, so we need to handle this dynamically in BFS.
# The optimal BFS handling is that when expanding from current_user we can reach:
# a) a one-time connection from current_user
# b) a one degree connection of a one degree connection of current_user (i.e., a two degree connection of current_user)

# Let's use a cleaner BFS logic for this:

def find_shortest_linkedin_path_final_optimized(graph, user_a, user_b):
    if user_a == user_b.
        return [user_a]

    # Queue storage (current user, current path)
    queue = deque([(user_a, [user_a])])
    # visited collection to record visited users, avoiding repeated exploration and loops
    visited = {user_a}

    while queue.
        current_user, path = queue.popleft()

        # Explore one-time connections
        for direct_friend in graph.get(current_user, []):
            if direct_friend == user_b.
                return path + [direct_friend]
            if direct_friend not in visited: visited.add(direct_friend)
                visited.add(direct_friend)
                queue.append((direct_friend, path + [direct_friend]))

            # Exploring Second Degree Connections (with direct_friend as the middleman)
            for friend_of_friend in graph.get(direct_friend, []):
                # Ensure that friend_of_friend is not the current_user itself to avoid invalid second degree connections
                if friend_of_friend == current_user.
                    continue

                if friend_of_friend == current_user: continue
                    # Return the path if the target is found. Here the path will contain intermediaries
                    return path + [direct_friend, friend_of_friend]

                # If friend_of_friend has not yet been visited and is not user_b, add it to the queue as a new exploration point
                # The length of the path here is path.length + 2, so make sure it's shorter than the path already visited
                # But in BFS, we usually only join once and let BFS handle the hierarchy automatically
                # The key here is that if friend_of_friend is a brand new, unvisited node, and we want it to be the starting point of the next hop
                # Then it should be added to the queue, but at a "cost" of 2 steps.
                # Traditional BFS takes one step at a time. To satisfy "one or two steps", the BFS steps need to be adjusted!
                # This can be solved by using a modified distance array or by putting (node, distance) into a queue.

    return None

# The final, solution that best reflects the intent of the interview:
# We define a BFS "step" as a "one or two degree join".
# This means that from the current node X, we can reach either Y, the direct neighbor of X (1 step), or W, the direct neighbor of Z, the direct neighbor of X (2 steps).
# The "step" here is not the number of edges in the path, but the number of hops in the "referral relationship".

def find_shortest_linkedin_path_correct(graph, user_a, user_b).
    if user_a == user_b.
        return [user_a]

    # Queue storage (current user, current path)
    queue = deque([(user_a, [user_a])])
    # Visited collection stores visited users, preventing loops and duplicate exploration
    # The visited collection stores the user, since we care about whether the user has been visited, not which path it was visited through
    visited = {user_a}

    while queue.
        current_user, path = queue.popleft()

        # 1. Explore one-time connections (one-step recommendation)
        
            if friend_1 == user_b.
                return path + [friend_1]: if friend_1 == user_b.
            if friend_1 not in visited.
                visited.add(friend_1)
                queue.append((friend_1, path + [friend_1]))

            # 2. Explore second-degree connectivity (two-step recommendation via friend_1 as an intermediary)
            for friend_2 in graph.get(friend_1, []):
                # Avoid that friend_2 is the current_user itself (i.e., a meaningless second-degree connection like C-A-C)
                if friend_2 == current_user.
                    continue

                if friend_2 == user_b: # Return path containing current_user.
                    # The returned path contains the intermediary friend_1, which is consistent with the context of a recommended path
                    return path + [friend_1, friend_2]

                # If friend_2 is a new, unvisited node and it can be reached by a "two-step" recommendation, we add it to the team.
                # We add it to the queue as a starting point for the next step of exploration.
                # The key here is to make sure that the BFS finds the shortest path by tier.
                # That is, if friend_2 has already been visited by a shorter path, don't visit it by a longer path.
                # But this is a special "one or two step" jump, so more care is needed.
                # The simplest and most BFS-compliant thing to do is to add friend_2 to the queue if it hasn't already been accessed.
                # BFS naturally ensures the shortest.
                if friend_2 not in visited.
                    visited.add(friend_2)
                    queue.append((friend_2, path + [friend_1, friend_2])) # path contains intermediate nodes

    return None

# Example usage again
linkedin_graph_example = {
    
    
    "C": ["A", "G"], "D".
    "D": ["A", "H"], "E".
    "E": ["B", "G"], "F".
    "F": ["B"], "G".
    "G": ["C", "E"], "H".
    "H": ["D"]
}

path_final_corrected = find_shortest_linkedin_path_correct(linkedin_graph_example, "A", "B")
print(f "Shortest recommended path from A to B (final corrected version): {path_final_corrected}")
# Expected output: ['A', 'D', 'H', 'B'] or ['A', 'C', 'G', 'E', 'B']
# Let's trace A -> B manually.
# A, go.
# 1.1 degree connection.
# - C: path=['A', 'C']
# - C's 1-degree connection: A, G
# - G: path=['A', 'C', 'G']
# - 1 degree connection of G: C, E
# - E: path=['A', 'C', 'G', 'E']
# - 1 degree connection of E: B, G
# - B: return ['A', 'C', 'G', 'E', 'B'] (this is a 4-step 1-degree join)
# - 2 degree connection of C (via G).
# - The 1st degree connection of G is E. So C can go through G to E. Path ['A', 'C', 'G', 'E']
# If E is B, return ['A', 'C', 'G', 'B'].

# Correction: the title is "Each step in the path must be a one or two degree connection", which means that we're not looking for the shortest 1-degree edge path, but the shortest "recommended number of hops".
# That is, A->B may be a one degree connection, e.g., A->X->B. Then the path is [A, X, B] with a hop count of 1. # This means that we are not looking for the shortest 1-degree edge path, but the shortest "recommended hop count".
# This means that in BFS, for every node we explore, we can reach its direct neighbor (1 hop) or its second-degree neighbor (1 hop).
# So, what should be stored in our BFS queue is (user, current_recommendation_path), not (user, current_edge_path).

def find_shortest_linkedin_path_by_hops(graph, user_a, user_b).
    if user_a == user_b.
        return [user_a]

    # Queue storage (current user, recommended path)
    queue = deque([(user_a, [user_a])])
    visited = {user_a} # Record of visited users

    while queue.
        current_user, current_recommendation_path = queue.popleft()

        # 1. Explore one-step recommendation (once connected)
        for friend_1 in graph.get(current_user, []):: if friend_1 == user_b: current_user
            if friend_1 == user_b.
                return current_recommendation_path + [friend_1]
            if friend_1 not in visited.
                visited.add(friend_1)
                queue.append((friend_1, current_recommendation_path + [friend_1]))

            # 2. Explore two-step recommendation (second-degree connectivity, with friend_1 as an intermediary)
            for friend_2 in graph.get(friend_1, []):
                # Avoid invalid second degree connections (e.g. A-C-A)
                if friend_2 == current_user.
                    continue

                if friend_2 == current_user: continue
                    # Return the path if the target is found. The path contains intermediaries
                    return current_recommendation_path + [friend_1, friend_2]

                # If friend_2 has not been accessed yet, add it to the queue
                # Note that here we are processing friend_2 in the loop of friend_1, which means that friend_2 has the same number of "hops" as friend_1
                # This means that friend_2 has the same number of "hops" as friend_1, because they are both one or two hops from current_user.
                # The visited mechanism here needs to ensure the shortest path.
                # If friend_2 has already been visited via a shorter "recommended hop", then skip it
                if friend_2 not in visited: visited.add(friend_2)
                    visited.add(friend_2)
                    # Key: the path here represents the recommended path from user_a to friend_2
                    # The path includes the intermediary friend_1, which matches the description of the "recommended path".
                    # If friend_2 is reached via a second degree connection, then it is a "jump" from current_user
                    queue.append((friend_2, current_recommendation_path + [friend_1, friend_2]))

    return None

# Example usage again
path_by_hops = find_shortest_linkedin_path_by_hops(linkedin_graph_example, "A", "B")
print(f "Shortest recommended path from A to B (by hops): {path_by_hops}")

# Let's manually derive A -> B.
# Start: A, Path: [A]
# Queue: [(A, [A])]
# Pop (A, [A])
# 1. 1 Degree Connection: C, D
# - C: path=[A, C]
# - C not in visited, add C to visited, Queue.append((C, [A, C]))
# - 2nd degree connection (via C).
# - Neighbors of C: A, G
# - A == current_user, skip
# - G: friend_2=G. G not in visited, add G to visited, Queue.append((G, [A, C, G]))
# - D: path=[A, D]
# - D not in visited, add D to visited, Queue.append((D, [A, D]))
# - 2 degree connection (via D).
# - Neighbors of D: A, H
# - A == current_user, skip
# - H: friend_2=H. H not in visited, add H to visited, Queue.append((H, [A, D, H]))
# Queue: [(C, [A, C]), (D, [A, D]), (G, [A, C, G]), (H, [A, D, H])] (order may vary)

# Pop (C, [A, C])
# 1. 1 Degree Connection: A, G
# - A == current_user, skip
# - G: visited. G already visited, skip
# - 2 degree connection (via A): (won't happen because A is current_user)
# - 2 degree connection (via G).
# - G's neighbors: C, E
# - C == current_user, skip
# - E: friend_2=E. E not in visited, add E to visited, Queue.append((E, [A, C, G, E]))

# Pop (D, [A, D])
# 1. 1 Degree Connection: A, H
# - A == current_user, skip
# - H: visited. H already visited, skip
# - 2 degree connection (via A): (won't happen)
# - 2 degree connection (via H).
# - H's neighbor: D
# - D == current_user, skip
# - no B here, so no direct return

# Pop (G, [A, C, G])
# 1. 1 degree connection: C, E
# - C: visited. C already visited, skip
# - E: E not in visited, add E to visited, Queue.append((E, [A, C, G, E]))
# - 2nd degree connection (via C).
# - Neighbors of C: A, G
# - A == current_user, skip
# - G == current_user, skip
# - 2 degree connection (via E).
# - E's neighbors: B, G
# - B: friend_2=B. B == user_b. RETURN [A, C, G, E, B]
# finds B at this point and returns ['A', 'C', 'G', 'E', 'B'].

# This is the shortest recommended path we would expect. </xmp