Subsequences with a Unique Middle Mode I - Practice Coding Problems

Subsequences with a Unique Middle Mode I - Problem

You're given an integer array nums, and your task is to find the number of subsequences of size 5 where the middle element (3rd position) is the unique mode of that subsequence.

What's a mode? The mode is the element that appears most frequently in a sequence. A unique mode means there's exactly one element that appears more frequently than all others.

What's a unique middle mode? In a 5-element subsequence [a, b, c, d, e], element c (middle) must be the unique mode - it appears more times than any other element in those 5 positions.

Goal: Count all such valid subsequences. Since the answer can be very large, return it modulo 10⁹ + 7.

Example: If nums = [1,2,1,2,1], the subsequence [1,2,1,2,1] has 1 as the middle element, and 1 appears 3 times while 2 appears 2 times, so 1 is the unique mode.

Input & Output

example_1.py — Basic case

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

› Output: 1

💡 Note: The subsequence [1,2,1,2,1] has middle element 1 (at index 2), and 1 appears 3 times while 2 appears 2 times, so 1 is the unique mode.

example_2.py — No valid subsequences

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

› Output: 0

💡 Note: Any subsequence of size 5 will have all elements equal to 1, so the middle element 1 appears 5 times. Since all positions have the same value, there's no 'unique' mode scenario possible.

example_3.py — Multiple valid subsequences

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

› Output: 4

💡 Note: Multiple subsequences exist where the middle element is the unique mode. For example, [1,2,2,3,1] has 2 as middle with frequency 2, while others have frequency 1.

Constraints

5 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
The middle element must have strictly higher frequency than any other element in the subsequence

Visualization

Tap to expand

Understanding the Visualization

Choose the Star

Pick someone to be the 'star' (middle position with highest frequency)

Count Supporters

Count how many times our star appears before and after the middle position

Fill Remaining Spots

Calculate valid ways to fill the remaining 4 positions such that our star stays most popular

Apply Constraints

Ensure no other person appears as frequently as our star in the final committee

Key Takeaway

🎯 Key Insight: Instead of checking all C(n,5) possible subsequences, we fix the middle position and value, then use mathematical formulas to count valid combinations efficiently - reducing time complexity from exponential to polynomial!

Asked in

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

The optimal approach uses combinatorial mathematics to count valid subsequences efficiently. Instead of generating all possible subsequences, we fix each position as the middle and calculate how many ways we can form valid subsequences around it. The key insight is to count prefix and suffix occurrences of each value, then use mathematical formulas to determine valid combinations where the middle element becomes the unique mode.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Combinatorial Approach	O(n² * V)	O(n * V)	Fix middle element and count valid left/right combinations efficiently
Brute Force (Check All Subsequences)	O(C(n,5) * 5)	O(1)	Generate all possible 5-element subsequences and check each one

Optimized Combinatorial Approach — Algorithm Steps

For each position i as potential middle position
For each unique value that could be the middle mode
Count occurrences of this value before and after position i
Calculate valid combinations where middle value dominates
Use mathematical formulas to count without generating subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix Middle Position

Choose position i as the middle (index 2) of subsequence

Count Left/Right

Count how many times each value appears before and after position i

Calculate Combinations

Use math formulas to count valid ways to choose remaining elements

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_VAL 1000

long long comb2(int x) {
    return x >= 2 ? (long long)x * (x - 1) / 2 : 0;
}

int countSubsequences(int* nums, int n) {
    if (n < 5) return 0;
    
    long long total = 0;
    
    // For each middle position
    for (int mid = 2; mid < n - 2; mid++) {
        int midVal = nums[mid];
        
        // Count occurrences (using arrays for simplicity)
        int leftCount[MAX_VAL + 1] = {0};
        int rightCount[MAX_VAL + 1] = {0};
        
        for (int i = 0; i < mid; i++) {
            if (nums[i] >= 0 && nums[i] <= MAX_VAL) {
                leftCount[nums[i]]++;
            }
        }
        
        for (int i = mid + 1; i < n; i++) {
            if (nums[i] >= 0 && nums[i] <= MAX_VAL) {
                rightCount[nums[i]]++;
            }
        }
        
        int midLeft = (midVal >= 0 && midVal <= MAX_VAL) ? leftCount[midVal] : 0;
        int midRight = (midVal >= 0 && midVal <= MAX_VAL) ? rightCount[midVal] : 0;
        
        // Simplified version - only handle case where middle appears once
        if (midLeft >= 2 && midRight >= 2) {
            // Count distinct other values
            int leftOthers = 0, rightOthers = 0;
            
            for (int i = 0; i <= MAX_VAL; i++) {
                if (i != midVal && leftCount[i] > 0) leftOthers++;
                if (i != midVal && rightCount[i] > 0) rightOthers++;
            }
            
            if (leftOthers >= 2 && rightOthers >= 2) {
                long long ways = (comb2(leftOthers) * comb2(rightOthers)) % MOD;
                total = (total + ways) % MOD;
            }
        }
    }
    
    return (int)total;
}

int main() {
    int nums[] = {1, 2, 1, 2, 1, 3, 1}; // Example
    int n = 7;
    printf("%d\n", countSubsequences(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² * V)

For each position and each unique value, we calculate combinations

⚠ Quadratic Growth

Space Complexity

O(n * V)

Store prefix/suffix counts for each value

⚡ Linearithmic Space

28.3K Views

Medium-High Frequency

~35 min Avg. Time

847 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

Optimized Combinatorial Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler