Count the Number of Ideal Arrays - Practice Coding Problems

Count the Number of Ideal Arrays - Problem

Count the Number of Ideal Arrays

You are given two integers n and maxValue, and your task is to find the number of ideal arrays of length n.

An ideal array is a 0-indexed integer array arr of length n that satisfies these conditions:
• Every element arr[i] is between 1 and maxValue (inclusive)
• Each element is divisible by the previous element: arr[i] % arr[i-1] == 0 for all i > 0

In other words, the array must be non-decreasing and each element must be a multiple of the previous element.

Example: If n=3, maxValue=5, then [1,2,4] is ideal because 2%1==0 and 4%2==0.

Return the count modulo 10⁹ + 7 since the answer can be very large.

Input & Output

example_1.py — Basic Case

$ Input: n = 2, maxValue = 5

› Output: 10

💡 Note: The ideal arrays are: [1,1], [1,2], [1,3], [1,4], [1,5], [2,2], [2,4], [3,3], [4,4], [5,5]. Each array satisfies the divisibility condition.

example_2.py — Length 3

$ Input: n = 3, maxValue = 4

› Output: 11

💡 Note: Valid arrays include [1,1,1], [1,1,2], [1,1,3], [1,1,4], [1,2,2], [1,2,4], [2,2,2], [2,2,4], [2,4,4], [3,3,3], [4,4,4].

example_3.py — Edge Case

$ Input: n = 1, maxValue = 3

› Output: 3

💡 Note: With length 1, any single value from 1 to maxValue is valid: [1], [2], [3].

Visualization

Tap to expand

Understanding the Visualization

Start with Base

Place any block from 1 to maxValue as the foundation

Add Valid Multiples

On each level, only place blocks that are multiples of the one below

Count Possibilities

Use DP to count all possible towers of height n

Sum Results

Add up counts for all possible ending values

Key Takeaway

🎯 Key Insight: An ideal array is essentially a sequence where each element is a multiple of the previous one. We can solve this efficiently using dynamic programming by counting the number of ways to build arrays of each length ending with each possible value.

Time & Space Complexity

Time Complexity

⏱️

O(maxValue * log(maxValue) + n * P)

Where P is the number of primes up to maxValue. Sieve takes O(maxValue * log(log(maxValue))), DP takes O(n * number of distinct prime factor patterns)

⚡ Linearithmic

Space Complexity

O(maxValue + n * P)

Store prime factorization for each number plus DP table

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 10⁴
1 ≤ maxValue ≤ 10⁴
Return the result modulo 10⁹ + 7
Each arr[i] must be divisible by arr[i-1]

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses dynamic programming where dp[i][j] represents the number of ideal arrays of length i ending with value j. The key insight is that we can extend any array ending with value k by appending any multiple of k that doesn't exceed maxValue. Time complexity is O(n × maxValue × d) where d is the average number of divisors.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursion	O(maxValue^n)	O(n)	Try all possible combinations recursively
Optimal DP with Prime Factorization	O(maxValue * log(maxValue) + n * P)	O(maxValue + n * P)	Use combinatorics with prime factorization patterns for optimal solution
Dynamic Programming with Memoization	O(n * maxValue * d)	O(n * maxValue)	Build solution using DP table storing (position, last_value) states

Brute Force Recursion — Algorithm Steps

Start with each possible first element (1 to maxValue)
For each position, try all multiples of the current element
Recursively build the rest of the array
Count valid complete arrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin with all possible values 1 to maxValue at position 0

Expand Multiples

For each value, try all its multiples that fit within maxValue

Continue Recursively

Repeat the process for remaining positions

Count Solutions

Count all paths that reach the end with valid arrays

Code -

solution.c — C

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

const int MOD = 1000000007;

int dfs(int pos, int last, int n, int maxValue) {
    if (pos == n) {
        return 1;
    }
    
    long long count = 0;
    // Try all multiples of 'last' that don't exceed maxValue
    for (int multiple = last; multiple <= maxValue; multiple += last) {
        count = (count + dfs(pos + 1, multiple, n, maxValue)) % MOD;
    }
    
    return count;
}

int idealArrays(int n, int maxValue) {
    return dfs(0, 1, n, maxValue);
}

int main() {
    int n, maxValue;
    scanf("%d %d", &n, &maxValue);
    printf("%d\n", idealArrays(n, maxValue));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(maxValue^n)

At each position, we might try up to maxValue different values, and we have n positions

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is at most n

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 10⁴
1 ≤ maxValue ≤ 10⁴
Return the result modulo 10⁹ + 7
Each arr[i] must be divisible by arr[i-1]

28.4K Views

Medium Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler