Friend Requests I: Overall Acceptance Rate

Friend Requests I: Overall Acceptance Rate - Problem

Database Unknown

🤝 Friend Request Acceptance Rate Calculator

Imagine you're building a social media platform's analytics dashboard! You need to calculate the overall acceptance rate of friend requests across your platform.

You have two database tables:

📤 FriendRequest Table:

+----------------+---------+
| Column Name    | Type    |
+----------------+---------+
| sender_id      | int     |
| send_to_id     | int     |
| request_date   | date    |
+----------------+---------+

Contains all friend requests sent on the platform.

✅ RequestAccepted Table:

+----------------+---------+
| Column Name    | Type    |
+----------------+---------+
| requester_id   | int     |
| accepter_id    | int     |
| accept_date    | date    |
+----------------+---------+

Contains all accepted friend requests.

Your Mission: Calculate the acceptance rate as: (Total Unique Acceptances) / (Total Unique Requests)

⚠️ Important Notes:

Duplicate requests between same users count as one request
Multiple acceptances between same users count as one acceptance
Acceptances might exist without corresponding requests in FriendRequest table
If no requests exist, return 0.00
Round result to 2 decimal places

Input & Output

example_1.sql — Basic Case

$ Input: FriendRequest: | sender_id | send_to_id | request_date | |-----------|------------|--------------| | 1 | 2 | 2016-06-01 | | 1 | 3 | 2016-06-01 | | 1 | 4 | 2016-06-01 | | 2 | 3 | 2016-06-02 | | 3 | 4 | 2016-06-09 | RequestAccepted: | requester_id | accepter_id | accept_date | |--------------|-------------|--------------| | 1 | 2 | 2016-06-03 | | 1 | 3 | 2016-06-08 | | 2 | 3 | 2016-06-08 | | 3 | 4 | 2016-06-09 |

› Output: | accept_rate | |-------------| | 0.80 |

💡 Note: There are 5 unique requests: (1,2), (1,3), (1,4), (2,3), (3,4). There are 4 unique acceptances: (1,2), (1,3), (2,3), (3,4). Acceptance rate = 4/5 = 0.80

example_2.sql — With Duplicates

$ Input: FriendRequest: | sender_id | send_to_id | request_date | |-----------|------------|--------------| | 1 | 2 | 2016-06-01 | | 1 | 2 | 2016-06-02 | | 2 | 1 | 2016-06-03 | RequestAccepted: | requester_id | accepter_id | accept_date | |--------------|-------------|--------------| | 1 | 2 | 2016-06-03 | | 1 | 2 | 2016-06-04 |

› Output: | accept_rate | |-------------| | 0.50 |

💡 Note: Unique requests: (1,2) and (2,1) = 2 requests. Unique acceptances: only (1,2) = 1 acceptance. Rate = 1/2 = 0.50. Note: (1,2) appearing twice in requests counts as 1, and (1,2) appearing twice in acceptances counts as 1.

example_3.sql — No Requests Edge Case

$ Input: FriendRequest: | sender_id | send_to_id | request_date | |-----------|------------|--------------| (empty table) RequestAccepted: | requester_id | accepter_id | accept_date | |--------------|-------------|--------------| | 1 | 2 | 2016-06-01 |

› Output: | accept_rate | |-------------| | 0.00 |

💡 Note: No requests exist, so acceptance rate is 0.00 by definition, even though there are acceptances (which might be from deleted requests or other sources).

Visualization

Tap to expand

Understanding the Visualization

Collect Unique Invitations

Scan all friend requests and identify unique sender-receiver pairs, ignoring duplicate invites

Collect Unique Acceptances

Scan all acceptances and identify unique requester-accepter pairs, ignoring duplicate accepts

Calculate Success Rate

Divide unique acceptances by unique requests, handling the edge case of zero requests

Key Takeaway

🎯 Key Insight: Use SQL DISTINCT to automatically handle duplicates and CASE statements for robust edge case handling in a single efficient query.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n and m are the number of rows in each table, with database optimizations for DISTINCT operations

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique pairs, used by database for DISTINCT processing

✓ Linear Space

Constraints

1 ≤ sender_id, send_to_id, requester_id, accepter_id ≤ 1000
Tables may contain duplicate records (no primary key)
Tables may be empty
Dates are in valid format YYYY-MM-DD
Result must be rounded to 2 decimal places

Asked in

f Facebook 25 in LinkedIn 18 📷 Instagram 12 🐦 Twitter 8

The optimal solution uses SQL DISTINCT to count unique request and acceptance pairs, eliminating duplicates automatically. Key insights: use CASE statement for division by zero handling and ROUND function for 2 decimal places. Time complexity is O(n + m) where n and m are table sizes.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Count All Records)	O(n + m)	O(1)	Count all records without handling duplicates properly
SQL with DISTINCT (Optimal)	O(n + m)	O(k)	Use SQL DISTINCT to count unique pairs and handle division edge cases

Brute Force (Count All Records) — Algorithm Steps

Count total rows in FriendRequest table
Count total rows in RequestAccepted table
Divide acceptances by requests
This gives wrong results due to duplicates

Visualization

Tap to expand

Step-by-Step Walkthrough

Count All Requests

Counts duplicate requests between same users multiple times

Count All Acceptances

Counts duplicate acceptances between same users multiple times

Wrong Division

Gets incorrect rate due to counting duplicates

Code -

solution.c — C

// Brute force approach (INCORRECT - for educational purposes)
// This would count duplicates incorrectly

#include <stdio.h>

double calculateAcceptanceRateWrong() {
    // This is what NOT to do
    char* totalRequests = "SELECT COUNT(*) FROM FriendRequest";
    char* totalAccepted = "SELECT COUNT(*) FROM RequestAccepted";
    
    // This would give wrong results due to duplicates
    // rate = acceptedCount / requestCount
    return 0.0;
}

// The issue: This doesn't handle duplicate requests between same users
// or multiple acceptances between same pairs

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n is rows in FriendRequest and m is rows in RequestAccepted - simple table scans

✓ Linear Growth

Space Complexity

O(1)

Only storing count variables

✓ Linear Space

Constraints

1 ≤ sender_id, send_to_id, requester_id, accepter_id ≤ 1000
Tables may contain duplicate records (no primary key)
Tables may be empty
Dates are in valid format YYYY-MM-DD
Result must be rounded to 2 decimal places

78.0K Views

Medium Frequency

~15 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

🤝 Friend Request Acceptance Rate Calculator

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Count All Records) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler