Leetcodify Friends Recommendations - Practice Coding Problems

Leetcodify Friends Recommendations - Problem

Database Hard

🎵 Leetcodify Friends Recommendations

You're working at Leetcodify, the world's most popular music streaming platform! Your task is to build a smart friend recommendation system that connects users based on their music listening habits.

The system analyzes two key data sources:

Listens Table: Tracks when users listen to songs (user_id, song_id, day)
Friendship Table: Existing friendships between users (user1_id, user2_id)

Your algorithm should recommend user X to user Y if:

🚫 Users X and Y are not already friends
🎶 Users X and Y listened to the same 3+ different songs on the same day

Important Notes:

Recommendations are bidirectional - if X should be recommended to Y, then Y should also be recommended to X
No duplicate recommendations allowed
The Listens table may contain duplicate rows
In Friendship table, user1_id < user2_id always

Return a result table with columns: user_id, recommended_id

Input & Output

Basic Recommendation Example

$ Input: Listens: [[1,10,'2021-03-15'],[1,11,'2021-03-15'],[1,12,'2021-03-15'],[2,10,'2021-03-15'],[2,11,'2021-03-15'],[2,12,'2021-03-15']] Friendship: []

› Output: [[1,2],[2,1]]

💡 Note: Users 1 and 2 listened to songs 10, 11, and 12 on the same day (2021-03-15). Since they have 3 common songs and are not friends, they should be recommended to each other.

Existing Friends Filtered Out

$ Input: Listens: [[1,10,'2021-03-15'],[1,11,'2021-03-15'],[1,12,'2021-03-15'],[2,10,'2021-03-15'],[2,11,'2021-03-15'],[2,12,'2021-03-15'],[3,10,'2021-03-15'],[3,11,'2021-03-15'],[3,12,'2021-03-15']] Friendship: [[1,2]]

› Output: [[1,3],[2,3],[3,1],[3,2]]

💡 Note: Users 1, 2, and 3 all have 3+ common songs. However, users 1 and 2 are already friends, so only 1↔3 and 2↔3 recommendations are made.

Insufficient Common Songs

$ Input: Listens: [[1,10,'2021-03-15'],[1,11,'2021-03-15'],[2,10,'2021-03-15'],[2,12,'2021-03-15']] Friendship: []

› Output: []

💡 Note: Users 1 and 2 only have 1 common song (song 10) on 2021-03-15. Since we need 3+ common songs, no recommendations are made.

Visualization

Tap to expand

Understanding the Visualization

Data Collection

Gather all listening history and existing friendships

Deduplication

Remove duplicate listening records to get clean data

Daily Grouping

Group users by songs they listened to each day

Similarity Scoring

Count common songs between user pairs per day

Filtering

Keep pairs with 3+ common songs who aren't friends

Bidirectional Output

Generate mutual recommendations

Key Takeaway

🎯 Key Insight: Group users by their daily listening patterns first, then efficiently count song overlaps to identify strong musical compatibility signals for friendship recommendations.

Time & Space Complexity

Time Complexity

⏱️

O(L log L + U²)

L log L for sorting/grouping listens, U² for user pair combinations

⚡ Linearithmic

Space Complexity

O(L + F)

L for listening data storage, F for friendship lookups

✓ Linear Space

Constraints

1 ≤ Listens.length ≤ 10⁵
1 ≤ Friendship.length ≤ 10⁴
1 ≤ user_id, song_id ≤ 10⁴
Listens table may contain duplicates
In Friendship table, user1_id < user2_id always
All dates are in valid YYYY-MM-DD format

Asked in

♪ Spotify 45 f Meta 35 a Amazon 28 G Google 22

The optimal approach uses SQL CTEs or hash map grouping to efficiently process the data. Key insights: 1) Remove duplicates first, 2) Group by (day, song) pairs to find user overlaps, 3) Count common songs per user pair per day, 4) Filter out existing friendships, 5) Generate bidirectional recommendations. Time complexity: O(L log L + U²) where L is listens and U is users.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized SQL with CTEs (Optimal)	O(L log L + U²)	O(L + F)	Use CTEs to group data efficiently and find recommendations in one pass
Brute Force (Nested Loops)	O(U² × D × S)	O(U × D × S)	Compare every user pair's listening history day by day

Optimized SQL with CTEs (Optimal) — Algorithm Steps

Create CTE to get distinct user-song-day combinations (remove duplicates)
Self-join listening data on same song and day to find user pairs
Group by user pair and day, count distinct common songs
Filter pairs with 3+ common songs on any day
Use LEFT JOIN to exclude existing friendships
Create bidirectional recommendations with UNION ALL

Visualization

Tap to expand

Step-by-Step Walkthrough

Deduplicate Listens

Remove duplicate listening records using DISTINCT or hash sets

Group by Day-Song

Create efficient lookup structure for (day, song) → [users]

Count User Pairs

For each day-song group, count common songs per user pair

Filter Recommendations

Keep only pairs with 3+ common songs who aren't friends

Generate Results

Create bidirectional recommendations

Code -

solution.c — C

// C Optimized Solution
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_USERS 10000
#define MAX_HASH 100000

typedef struct Node {
    char* key;
    int value;
    struct Node* next;
} Node;

typedef struct {
    Node* buckets[MAX_HASH];
} HashMap;

unsigned int hash(const char* key) {
    unsigned int hash = 5381;
    int c;
    while ((c = *key++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % MAX_HASH;
}

void put(HashMap* map, const char* key, int value) {
    unsigned int index = hash(key);
    Node* node = malloc(sizeof(Node));
    node->key = strdup(key);
    node->value = value;
    node->next = map->buckets[index];
    map->buckets[index] = node;
}

int get(HashMap* map, const char* key) {
    unsigned int index = hash(key);
    Node* node = map->buckets[index];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return 0;
}

typedef struct {
    int user_id;
    int recommended_id;
} Recommendation;

int recommendFriends(int** listens, int listensSize, int** friendships, int friendshipsSize, Recommendation** result) {
    // Build friendship matrix
    int friendMatrix[MAX_USERS][MAX_USERS] = {0};
    for (int i = 0; i < friendshipsSize; i++) {
        friendMatrix[friendships[i][0]][friendships[i][1]] = 1;
        friendMatrix[friendships[i][1]][friendships[i][0]] = 1;
    }
    
    HashMap pairDayCount = {0};
    HashMap processed = {0};
    
    // Process listens and count common songs
    for (int i = 0; i < listensSize; i++) {
        char listenKey[50];
        sprintf(listenKey, "%d-%d-%d", listens[i][0], listens[i][1], listens[i][2]);
        
        if (get(&processed, listenKey)) continue;
        put(&processed, listenKey, 1);
        
        // Compare with other listens on same day/song
        for (int j = i + 1; j < listensSize; j++) {
            if (listens[i][1] == listens[j][1] && listens[i][2] == listens[j][2] && 
                listens[i][0] != listens[j][0]) {
                
                int u1 = listens[i][0] < listens[j][0] ? listens[i][0] : listens[j][0];
                int u2 = listens[i][0] < listens[j][0] ? listens[j][0] : listens[i][0];
                
                char pairDayKey[50];
                sprintf(pairDayKey, "%d-%d-%d", u1, u2, listens[i][2]);
                
                int currentCount = get(&pairDayCount, pairDayKey);
                put(&pairDayCount, pairDayKey, currentCount + 1);
            }
        }
    }
    
    // Find recommendations
    *result = malloc(sizeof(Recommendation) * MAX_USERS * 2);
    int count = 0;
    
    for (int i = 0; i < MAX_HASH; i++) {
        Node* node = pairDayCount.buckets[i];
        while (node) {
            if (node->value >= 3) {
                int u1, u2, day;
                sscanf(node->key, "%d-%d-%d", &u1, &u2, &day);
                
                if (!friendMatrix[u1][u2]) {
                    (*result)[count].user_id = u1;
                    (*result)[count].recommended_id = u2;
                    count++;
                    (*result)[count].user_id = u2;
                    (*result)[count].recommended_id = u1;
                    count++;
                }
            }
            node = node->next;
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(L log L + U²)

L log L for sorting/grouping listens, U² for user pair combinations

⚡ Linearithmic

Space Complexity

O(L + F)

L for listening data storage, F for friendship lookups

✓ Linear Space

Constraints

1 ≤ Listens.length ≤ 10⁵
1 ≤ Friendship.length ≤ 10⁴
1 ≤ user_id, song_id ≤ 10⁴
Listens table may contain duplicates
In Friendship table, user1_id < user2_id always
All dates are in valid YYYY-MM-DD format

21.1K Views

Medium-High Frequency

~25 min Avg. Time

892 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

🎵 Leetcodify Friends Recommendations

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized SQL with CTEs (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler