Friends With No Mutual Friends - Practice Coding Problems

Friends With No Mutual Friends - Problem

Database Medium

Friends With No Mutual Friends

You are given a Friends table representing a social network where friendships are bidirectional. Each row contains two user IDs who are friends with each other.

Your task is to find all pairs of users who are direct friends but have zero mutual friends in common. In other words, find friend pairs where no other user is friends with both of them.

Table Schema:
Friends
+-------------+------+
| Column Name | Type |
+-------------+------+
| user_id1 | int |
| user_id2 | int |
+-------------+------+

The combination (user_id1, user_id2) is the primary key. Return the result ordered by user_id1, user_id2 in ascending order.

Input & Output

example_1.sql — Basic Case

$ Input: Friends table: +----------+----------+ | user_id1 | user_id2 | +----------+----------+ | 1 | 2 | | 1 | 3 | | 2 | 3 | | 4 | 5 | +----------+----------+

› Output: +----------+----------+ | user_id1 | user_id2 | +----------+----------+ | 4 | 5 | +----------+----------+

💡 Note: Users 1, 2, and 3 form a triangle where everyone is connected. Users 1-2 have mutual friend 3, 1-3 have mutual friend 2, and 2-3 have mutual friend 1. Users 4 and 5 are only friends with each other and have no mutual friends.

example_2.sql — Linear Chain

$ Input: Friends table: +----------+----------+ | user_id1 | user_id2 | +----------+----------+ | 1 | 2 | | 2 | 3 | | 3 | 4 | +----------+----------+

› Output: +----------+----------+ | user_id1 | user_id2 | +----------+----------+ | 1 | 2 | | 2 | 3 | | 3 | 4 | +----------+----------+

💡 Note: This forms a linear chain: 1-2-3-4. Each adjacent pair has no mutual friends since there are no triangles in the friendship graph.

example_3.sql — Mixed Network

$ Input: Friends table: +----------+----------+ | user_id1 | user_id2 | +----------+----------+ | 1 | 2 | | 1 | 3 | | 2 | 4 | | 3 | 4 | | 5 | 6 | | 6 | 7 | +----------+----------+

› Output: +----------+----------+ | user_id1 | user_id2 | +----------+----------+ | 1 | 2 | | 1 | 3 | | 5 | 6 | | 6 | 7 | +----------+----------+

💡 Note: Users 2 and 4 have mutual friend 3, and users 3 and 4 have mutual friend 2, so (2,4) and (3,4) are excluded. All other pairs have no mutual friends.

Visualization

Tap to expand

Understanding the Visualization

Map the Network

Create a friendship map showing who is connected to whom

Analyze Each Pair

For every friendship, examine their respective social circles

Find Overlaps

Check if their friend groups have any people in common

Identify Isolated Pairs

Pairs with no overlapping friends are your answer

Key Takeaway

🎯 Key Insight: Use adjacency lists and set operations to efficiently detect mutual friends. Build the friendship network once, then leverage set intersection to quickly identify pairs without common connections.

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

Where n is number of friendships and k is average number of friends per user. Building adjacency list is O(n), checking each pair is O(n × k²) for set operations

⚠ Quadratic Growth

Space Complexity

O(n × k)

Storage for adjacency list where each user can have up to k friends

⚡ Linearithmic Space

Constraints

1 ≤ Number of friendship pairs ≤ 10⁴
1 ≤ user_id1, user_id2 ≤ 10⁴
user_id1 ≠ user_id2 (no self-friendships)
Each friendship pair appears only once in the table
Friendships are bidirectional

Asked in

f Meta 45 in LinkedIn 38 G Google 32 ⊞ Microsoft 28

This problem requires finding friendship pairs with no mutual friends. The optimal approach builds an adjacency list to represent the friendship network, then uses set intersection operations to efficiently detect mutual friends. For each friendship pair, we compute the intersection of their friend sets (excluding each other) - if empty, they have no mutual friends. Time complexity is O(n² × k) where k is the average number of friends per user.

Common Approaches

Approach	Time	Space	Notes
✓ Adjacency List with Set Operations (Optimal)	O(n² × k)	O(n × k)	Build friendship graph and use set intersection to find mutual friends efficiently
Brute Force (Triple Nested Query)	O(n³)	O(1)	For each friendship pair, scan all other friendships to find mutual connections

Adjacency List with Set Operations (Optimal) — Algorithm Steps

Build adjacency list from friendship data (bidirectional)
For each friendship pair (A, B), get their friend sets
Remove A from B's friends and B from A's friends (to avoid self-reference)
Compute intersection of the cleaned friend sets
If intersection is empty, add pair to results
Sort and return results

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Adjacency List

Create bidirectional friendship graph from input data

Select Friendship Pair

Choose a friendship pair (A, B) to analyze

Extract Friend Sets

Get A's friends (minus B) and B's friends (minus A)

Set Intersection

Find common friends using efficient set intersection

Check Result

If intersection is empty, add pair to results

Code -

solution.c — C

/* SQL Solution (Optimal with CTE) */
/*
WITH friendship_graph AS (
    SELECT user_id1 as user_a, user_id2 as user_b FROM Friends
    UNION ALL
    SELECT user_id2 as user_a, user_id1 as user_b FROM Friends
),
mutual_friends AS (
    SELECT DISTINCT 
        f1.user_id1,
        f1.user_id2,
        fg1.user_b as friend_of_user1,
        fg2.user_b as friend_of_user2
    FROM Friends f1
    LEFT JOIN friendship_graph fg1 ON f1.user_id1 = fg1.user_a AND fg1.user_b != f1.user_id2
    LEFT JOIN friendship_graph fg2 ON f1.user_id2 = fg2.user_a AND fg2.user_b != f1.user_id1
    WHERE fg1.user_b = fg2.user_b
)
SELECT DISTINCT f.user_id1, f.user_id2
FROM Friends f
WHERE NOT EXISTS (
    SELECT 1 FROM mutual_friends mf 
    WHERE mf.user_id1 = f.user_id1 AND mf.user_id2 = f.user_id2
)
ORDER BY f.user_id1, f.user_id2;
*/

// C implementation using arrays and simple adjacency representation
#include <stdio.h>
#include <stdlib.h>
#define MAX_USERS 1000

int friendsList[MAX_USERS][MAX_USERS];
int friendsCount[MAX_USERS];

int compare(const void *a, const void *b) {
    int *pairA = (int*)a;
    int *pairB = (int*)b;
    if (pairA[0] != pairB[0]) {
        return pairA[0] - pairB[0];
    }
    return pairA[1] - pairB[1];
}

int** friendsNoMutualOptimal(int** friends, int friendsSize, int* returnSize) {
    // Initialize adjacency list
    for (int i = 0; i < MAX_USERS; i++) {
        friendsCount[i] = 0;
    }
    
    // Build adjacency list (bidirectional graph)
    for (int i = 0; i < friendsSize; i++) {
        int user1 = friends[i][0];
        int user2 = friends[i][1];
        
        friendsList[user1][friendsCount[user1]++] = user2;
        friendsList[user2][friendsCount[user2]++] = user1;
    }
    
    int** result = malloc(friendsSize * sizeof(int*));
    *returnSize = 0;
    
    // Check each friendship pair
    for (int i = 0; i < friendsSize; i++) {
        int user1 = friends[i][0];
        int user2 = friends[i][1];
        
        int hasMutual = 0;
        
        // Check for mutual friends
        for (int j = 0; j < friendsCount[user1] && !hasMutual; j++) {
            int friend1 = friendsList[user1][j];
            if (friend1 == user2) continue;
            
            for (int k = 0; k < friendsCount[user2]; k++) {
                int friend2 = friendsList[user2][k];
                if (friend2 == user1) continue;
                
                if (friend1 == friend2) {
                    hasMutual = 1;
                    break;
                }
            }
        }
        
        // If no mutual friends, add to result
        if (!hasMutual) {
            result[*returnSize] = malloc(2 * sizeof(int));
            result[*returnSize][0] = user1;
            result[*returnSize][1] = user2;
            (*returnSize)++;
        }
    }
    
    qsort(result, *returnSize, sizeof(int*), compare);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

Where n is number of friendships and k is average number of friends per user. Building adjacency list is O(n), checking each pair is O(n × k²) for set operations

⚠ Quadratic Growth

Space Complexity

O(n × k)

Storage for adjacency list where each user can have up to k friends

⚡ Linearithmic Space

Constraints

1 ≤ Number of friendship pairs ≤ 10⁴
1 ≤ user_id1, user_id2 ≤ 10⁴
user_id1 ≠ user_id2 (no self-friendships)
Each friendship pair appears only once in the table
Friendships are bidirectional

43.6K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Adjacency List with Set Operations (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler