Count Distinct Numbers on Board - Practice Coding Problems

Count Distinct Numbers on Board - Problem

Imagine you're running a number transformation game on a digital board! 🎮

You start with a positive integer n placed on your board. Every day for exactly 10⁹ days, you perform a magical transformation:

For each number x currently on the board, find all numbers i (where 1 ≤ i ≤ n) such that x % i == 1
Add all these discovered numbers i to your board

Important: Once a number appears on the board, it stays there forever! Numbers don't disappear.

Your goal: After 10⁹ days of this process, count how many distinct integers are present on your board.

Example: If n = 5 and you start with [5] on the board, you need to find all i where 5 % i == 1. This gives you i = 2, 4, so your board becomes [5, 2, 4]. The process continues...

Input & Output

example_1.py — Basic Case

$ Input: n = 5

› Output: 4

💡 Note: Start with [5]. Day 1: 5%2=1 and 5%4=1, so add [2,4] → board=[5,2,4]. Day 2: 4%3=1, so add [3] → board=[5,2,4,3]. No more numbers can be added, so answer is 4.

example_2.py — Edge Case

$ Input: n = 1

› Output: 1

💡 Note: Start with [1]. Since 1 is the smallest number and 1%i can never equal 1 for any valid i, no new numbers are added. The board remains [1], so answer is 1.

example_3.py — Small Case

$ Input: n = 3

› Output: 2

💡 Note: Start with [3]. Day 1: 3%2=1, so add [2] → board=[3,2]. Day 2: No new numbers (2%1=0, 3%1=0, 3%2=1 but 2 already exists). Final board=[3,2], so answer is 2.

Constraints

1 ≤ n ≤ 1000
The process runs for exactly 10⁹ days
Numbers remain on the board once added

Visualization

Tap to expand

Understanding the Visualization

Plant Initial Seed

Start with number n as the first plant in our garden

Daily Growth

Each day, every plant x produces seeds i where x % i == 1

Rapid Expansion

New plants immediately start producing their own seeds

Natural Equilibrium

Garden reaches stability when no new plants can grow

Key Takeaway

🎯 Key Insight: The garden always stabilizes with exactly n-1 distinct plants (for n > 1), since number 1 can never be generated through the modulo operation x % i = 1.

Asked in

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

The optimal solution uses mathematical insight: for n > 1, the answer is always n-1. This is because all numbers from 2 to n eventually appear on the board, but 1 never appears (since x % 1 = 0 for any x). The solution runs in O(1) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Until Convergence	O(n² × k)	O(n)	Simulate the daily process until no new numbers are added to the board
Mathematical Optimization (Optimal)	O(1)	O(1)	Use mathematical insight: if n > 1, the answer is always n-1

Simulation Until Convergence — Algorithm Steps

Initialize a set with the starting number n
For each iteration, create a new set to store newly found numbers
For each number x on the board, find all i (1 ≤ i ≤ n) where x % i == 1
Add all such i values to the new set
Merge the new numbers with the existing board
Stop when no new numbers are found in an iteration
Return the size of the final set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Board starts with only number n

First Iteration

Find all i where n % i == 1, add them to board

Subsequent Iterations

For each number on board, find new numbers to add

Convergence

Stop when no new numbers are found

Code -

solution.c — C

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

int distinctIntegers(int n) {
    bool* board = (bool*)calloc(n + 1, sizeof(bool));
    bool* newBoard = (bool*)calloc(n + 1, sizeof(bool));
    
    board[n] = true; // Start with n on the board
    
    while (true) {
        // Reset new board
        for (int i = 0; i <= n; i++) {
            newBoard[i] = false;
        }
        
        // For each number x on the board
        for (int x = 1; x <= n; x++) {
            if (board[x]) {
                // Find all i where x % i == 1
                for (int i = 1; i <= n; i++) {
                    if (x % i == 1) {
                        newBoard[i] = true;
                    }
                }
            }
        }
        
        // Check if we have any truly new numbers
        bool hasNew = false;
        for (int i = 1; i <= n; i++) {
            if (newBoard[i] && !board[i]) {
                hasNew = true;
                break;
            }
        }
        
        if (!hasNew) break;
        
        // Add new numbers to board
        for (int i = 1; i <= n; i++) {
            if (newBoard[i]) {
                board[i] = true;
            }
        }
    }
    
    // Count distinct numbers
    int count = 0;
    for (int i = 1; i <= n; i++) {
        if (board[i]) count++;
    }
    
    free(board);
    free(newBoard);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

Where k is the number of iterations until convergence (typically small). For each iteration, we check each number against all possible divisors from 1 to n.

⚠ Quadratic Growth

Space Complexity

O(n)

We store at most n distinct numbers on the board, plus temporary storage for new numbers in each iteration.

⚡ Linearithmic Space

24.0K Views

Medium Frequency

~12 min Avg. Time

850 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

Constraints

Visualization

Related Problems

Common Approaches

Simulation Until Convergence — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler