Sum of Beauty in the Array

Sum of Beauty in the Array - Problem

Array Medium

You are given a 0-indexed integer array nums. For each index i (where 1 <= i <= nums.length - 2), the beauty of nums[i] equals:

2, if nums[j] < nums[i] < nums[k] for all 0 <= j < i and for all i < k <= nums.length - 1.
1, if nums[i - 1] < nums[i] < nums[i + 1] and the previous condition is not satisfied.
0, if none of the previous conditions holds.

Return the sum of beauty of all nums[i] where 1 <= i <= nums.length - 2.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Only middle element is nums[1] = 2. Check beauty 2: all left [1] < 2 < all right [3] ✓. Beauty = 2. Sum = 2.

Example 2 — Multiple Elements

$ Input: nums = [2,4,6,4]

› Output: 1

💡 Note: Middle elements: nums[1] = 4, nums[2] = 6. nums[1]: 2 < 4 < 6 ✓ (beauty 1). nums[2]: 4 < 6 > 4 ✗ (beauty 0). Sum = 1 + 0 = 1.

Example 3 — Maximum Beauty

$ Input: nums = [3,2,4,2,4]

› Output: 1

💡 Note: nums[1] = 2: all left [3] ≥ 2 ✗, neighbors 3 > 2 < 4 ✗ (beauty 0). nums[2] = 4: all left [3,2] < 4 ✓, all right [2,4] ≤ 4 ✗, neighbors 2 < 4 > 2 ✗ (beauty 0). nums[3] = 2: neighbors 4 > 2 < 4 ✓ (beauty 1). Sum = 0 + 0 + 1 = 1.

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18

The key insight is to pre-compute maximum values to the left and minimum values to the right of each element, allowing O(1) beauty checks. Best approach uses prefix/suffix arrays with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force

⏱️ Time: O(n³) Space: O(1)

For each index i in the valid range, check if nums[i] is greater than all elements to its left and smaller than all elements to its right for beauty 2, or just check immediate neighbors for beauty 1.

Prefix/Suffix Maximum Optimization

⏱️ Time: O(n) Space: O(n)

Instead of checking all elements repeatedly, pre-compute the maximum element to the left of each position and minimum element to the right. This allows O(1) beauty checking for each element.

Brute Force — Algorithm Steps

Iterate through each middle index i
For beauty 2: check all left elements < nums[i] and all right elements > nums[i]
For beauty 1: check if nums[i-1] < nums[i] < nums[i+1]
Add the appropriate beauty value to sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Middle Element

Check nums[i] for beauty conditions

Compare All Left & Right

For beauty 2: all left < nums[i] < all right

Check Neighbors

For beauty 1: nums[i-1] < nums[i] < nums[i+1]

Code -

solution.c — C

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

int solution(int* nums, int n) {
    if (n < 3) return 0;
    
    int totalBeauty = 0;
    
    for (int i = 1; i < n - 1; i++) {
        // Check for beauty 2: all left < nums[i] < all right
        int allLeftSmaller = 1;
        for (int j = 0; j < i; j++) {
            if (nums[j] >= nums[i]) {
                allLeftSmaller = 0;
                break;
            }
        }
        
        if (allLeftSmaller) {
            int allRightGreater = 1;
            for (int k = i + 1; k < n; k++) {
                if (nums[k] <= nums[i]) {
                    allRightGreater = 0;
                    break;
                }
            }
            
            if (allRightGreater) {
                totalBeauty += 2;
                continue;
            }
        }
        
        // Check for beauty 1: nums[i-1] < nums[i] < nums[i+1]
        if (nums[i - 1] < nums[i] && nums[i] < nums[i + 1]) {
            totalBeauty += 1;
        }
    }
    
    return totalBeauty;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing of [1,2,3] format
    int nums[1000];
    int n = 0;
    char* ptr = line + 1; // Skip [
    
    while (*ptr && *ptr != ']') {
        if (*ptr == ',' || *ptr == ' ') {
            ptr++;
            continue;
        }
        nums[n++] = atoi(ptr);
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n elements, we check up to n elements on left and n elements on right

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for iteration and sum

✓ Linear Space

32.0K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler