Count Beautiful Splits in an Array - Practice Coding Problems

Count Beautiful Splits in an Array - Problem

You are given an integer array nums. Your task is to find all possible ways to split this array into three non-empty subarrays such that the split is considered "beautiful".

A split is beautiful if:

The array nums is divided into exactly three consecutive subarrays: nums1, nums2, and nums3
At least one of the following conditions is met:
- nums1 is a prefix of nums2, OR
- nums2 is a prefix of nums3

Note: Array A is a prefix of array B if A can be obtained by taking the first few elements of B. For example, [1, 2] is a prefix of [1, 2, 3, 4].

Goal: Return the total number of beautiful splits possible.

Input & Output

example_1.py — Basic Case

$ Input: [1,1,2,1]

› Output: 2

💡 Note: Two beautiful splits exist: (1) Split at positions 1,2 giving [1], [1], [2,1] where nums1 is prefix of nums2. (2) Split at positions 1,3 giving [1], [1,2], [1] where nums1 is prefix of nums2.

example_2.py — No Beautiful Splits

$ Input: [1,2,3,4]

› Output: 0

💡 Note: No matter how we split this array into three parts, neither prefix condition can be satisfied since all elements are distinct and increasing.

example_3.py — Multiple Patterns

$ Input: [1,2,1,2,1,2]

› Output: 8

💡 Note: Multiple beautiful splits are possible due to the repeating pattern [1,2]. Many combinations satisfy either nums1 being a prefix of nums2 or nums2 being a prefix of nums3.

Constraints

3 ≤ nums.length ≤ 5000
1 ≤ nums[i] ≤ 10⁹
Each split must create exactly three non-empty subarrays

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

We need to split array into 3 parts where either first is prefix of second OR second is prefix of third

Apply Z-Algorithm

Precompute all prefix relationships to avoid redundant comparisons

Check All Splits

For each valid split point combination, use precomputed values to check conditions

Count Valid Splits

Sum all combinations that satisfy at least one prefix condition

Key Takeaway

🎯 Key Insight: By preprocessing with Z-Algorithm, we transform expensive O(n) prefix checks into O(1) lookups, making the overall solution efficient enough for the given constraints.

Asked in

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

The optimal approach uses the Z-Algorithm to efficiently compute prefix relationships in O(n) time, then checks all O(n²) possible split combinations. This reduces the overall complexity from O(n³) to O(n²) while maintaining correctness. The key insight is that prefix checking can be optimized using string matching algorithms rather than naive character-by-character comparison.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Approach)	O(n³)	O(1)	Try all possible split points and check prefix conditions naively
Optimized Brute Force with Z-Algorithm	O(n²)	O(n)	Use Z-Algorithm to efficiently find all prefix relationships

Brute Force (Triple Nested Approach) — Algorithm Steps

Try all possible first split points (i from 1 to n-2)
Try all possible second split points (j from i+1 to n-1)
Extract the three subarrays: nums1, nums2, nums3
Check if nums1 is prefix of nums2 by comparing elements
Check if nums2 is prefix of nums3 by comparing elements
Count valid splits where at least one prefix condition is met

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Split Points

Try all combinations of i and j where 1 ≤ i < j < n

Create Subarrays

Split array into nums1[0:i], nums2[i:j], nums3[j:n]

Check Prefixes

Compare elements one by one to check prefix conditions

Count Valid

Increment counter if either prefix condition is satisfied

Code -

solution.c — C

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

int beautifulSplits(int* nums, int n) {
    int count = 0;
    
    // Try all possible split points
    for (int i = 1; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            // Check if nums[0:i] is prefix of nums[i:j]
            int isPrefix12 = 0;
            if (i <= j - i) {
                isPrefix12 = 1;
                for (int k = 0; k < i; k++) {
                    if (nums[k] != nums[i + k]) {
                        isPrefix12 = 0;
                        break;
                    }
                }
            }
            
            // Check if nums[i:j] is prefix of nums[j:n]
            int isPrefix23 = 0;
            int len2 = j - i;
            int len3 = n - j;
            if (len2 <= len3) {
                isPrefix23 = 1;
                for (int k = 0; k < len2; k++) {
                    if (nums[i + k] != nums[j + k]) {
                        isPrefix23 = 0;
                        break;
                    }
                }
            }
            
            if (isPrefix12 || isPrefix23) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // skip '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", beautifulSplits(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for trying all split combinations, O(n) for each prefix check

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force (Triple Nested Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler