Number of People Aware of a Secret - Practice Coding Problems

Number of People Aware of a Secret - Problem

Imagine a viral secret spreading through a community with specific rules! 🤫

On day 1, exactly one person discovers a secret. Here's how the secret spreads:

📅 Each person starts sharing the secret after delay days from when they first learned it
🧠 Each person forgets the secret exactly forget days after discovering it
📢 People share the secret with one new person every day (from delay day until they forget)
🚫 A person cannot share on the same day they forget or afterwards

Goal: Given integers n, delay, and forget, find how many people know the secret at the end of day n.

Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: n = 6, delay = 2, forget = 4

› Output: 5

💡 Note: Day 1: 1 person knows. Day 3: person starts sharing, 1 new person. Day 4: 1 person still sharing, 1 new person. Day 5: original person forgets, but 2 people from days 3,4 know, and day 3 person starts sharing, creating 1 new person. Day 6: people from days 3,4,5 still know, day 4 person starts sharing, creating 1 new person. Total: 5 people know the secret.

example_2.py — No Sharing Case

$ Input: n = 4, delay = 1, forget = 3

› Output: 6

💡 Note: Day 1: 1 person. Day 2: original person shares (delay=1), +1 new = 2 total. Day 3: both share, +2 new = 4 total. Day 4: original forgets (forget=3), but 3 people from days 2,3 still know and 2 of them share, +2 new. Total knowing: people from days 2,3,4,4 = 6.

example_3.py — Minimal Case

$ Input: n = 1, delay = 1, forget = 2

› Output: 1

💡 Note: Only day 1, so only 1 person knows the secret (the original discoverer). No time for sharing or forgetting.

Visualization

Tap to expand

Understanding the Visualization

Discovery Phase

Person learns the secret, spends 'delay' days practicing/learning

Sharing Phase

Person actively shares with 1 new person every day

Forgetting Phase

After 'forget' days total, person moves on and stops caring

DP Optimization

Instead of tracking individuals, track counts per discovery day

Key Takeaway

🎯 Key Insight: Track discovery counts per day instead of individual people to achieve optimal O(n) complexity while maintaining accurate state transitions.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through days 1 to n, with constant work per day

✓ Linear Growth

Space Complexity

O(n)

DP array of size n to store discovery counts per day

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
1 ≤ delay < forget ≤ n
Answer should be returned modulo 10⁹ + 7

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses Dynamic Programming to track discovery counts per day rather than individual people. Instead of simulating each person's lifecycle (which leads to exponential complexity), we maintain dp[i] representing how many people discovered the secret on day i. For each day, we calculate how many people are currently sharing (those who discovered between day-forget+1 and day-delay days ago) and add them as new discoveries. The final answer sums up people who discovered in the last forget days. This reduces complexity from O(k^n) to O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(n)	Track counts of people in different states rather than individuals

Dynamic Programming (Optimal) — Algorithm Steps

Create DP array where dp[i] = number of people who discovered secret on day i
Initialize dp[1] = 1 (one person discovers on day 1)
For each day from 2 to n:
Calculate total people who can share (discovered between day-forget+1 and day-delay)
Add these sharing people as new discoveries for current day
Sum up all people who still remember (discovered after day-forget)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[1] = 1, all others = 0

Day 2-3

No sharing yet (delay not reached)

Day 4

Person from day 1 can share, dp[4] = dp[1] = 1

Day 5

Still only day 1 person sharing, dp[5] = 1

Day 7

Person from day 1 forgets, only newer people sharing

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

#define MOD 1000000007
#define MAX_N 1000

int max(int a, int b) {
    return a > b ? a : b;
}

int numPeopleAwareOfSecret(int n, int delay, int forget) {
    // dp[i] = number of people who discovered the secret on day i
    long long dp[MAX_N + 1] = {0};
    dp[1] = 1; // One person discovers on day 1
    
    for (int day = 2; day <= n; day++) {
        long long sharingPeople = 0;
        int start = max(1, day - forget + 1);
        int end = day - delay;
        
        for (int discoverDay = start; discoverDay <= end; discoverDay++) {
            sharingPeople = (sharingPeople + dp[discoverDay]) % MOD;
        }
        dp[day] = sharingPeople;
    }
    
    // Count people who still remember at day n
    long long result = 0;
    int start = max(1, n - forget + 1);
    
    for (int discoverDay = start; discoverDay <= n; discoverDay++) {
        result = (result + dp[discoverDay]) % MOD;
    }
    
    return (int) result;
}

int main() {
    int n, delay, forget;
    scanf("%d %d %d", &n, &delay, &forget);
    printf("%d\n", numPeopleAwareOfSecret(n, delay, forget));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through days 1 to n, with constant work per day

✓ Linear Growth

Space Complexity

O(n)

DP array of size n to store discovery counts per day

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
1 ≤ delay < forget ≤ n
Answer should be returned modulo 10⁹ + 7

28.4K Views

Medium Frequency

~25 min Avg. Time

840 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler