Sum of Beauty in the Array - Practice Coding Problems

Sum of Beauty in the Array - Problem

Array Medium

You're tasked with calculating the "beauty score" of elements in an array based on how well they fit into their surroundings!

Given a 0-indexed integer array nums, you need to determine the beauty value for each element at index i where 1 ≤ i ≤ nums.length - 2 (excluding the first and last elements).

The beauty rules are:

Beauty = 2: If nums[i] is globally beautiful - meaning all elements to its left are smaller AND all elements to its right are larger
Beauty = 1: If nums[i] is locally beautiful - meaning only its immediate neighbors satisfy nums[i-1] < nums[i] < nums[i+1]
Beauty = 0: If neither condition is met

Your goal is to return the sum of all beauty values for the valid indices.

Example: For [1,5,3,6,1], element 5 at index 1 has beauty 1 (locally beautiful), element 3 at index 2 has beauty 0, and element 6 at index 3 has beauty 0. Total sum = 1.

Input & Output

example_1.py — Basic Array

$ Input: [1,5,3,6,1]

› Output: 0

💡 Note: For index 1 (value 5): Not globally beautiful since 5 > 3. Not locally beautiful since 5 > 3. Beauty = 0. For index 2 (value 3): Not globally beautiful since 5 > 3. Not locally beautiful since 5 > 3. Beauty = 0. For index 3 (value 6): Not globally beautiful since 6 > 1. Not locally beautiful since 6 > 1. Beauty = 0. Total = 0.

example_2.py — Mixed Beauty Values

$ Input: [1,4,6,7,1]

› Output: 4

💡 Note: For index 1 (value 4): leftMax[1]=1 < 4 and 4 < rightMin[1]=1? No. Local: 1 < 4 < 6? Yes. Beauty = 1. For index 2 (value 6): leftMax[2]=4 < 6 and 6 < rightMin[2]=1? No. Local: 4 < 6 < 7? Yes. Beauty = 1. For index 3 (value 7): leftMax[3]=6 < 7 and 7 < rightMin[3]=1? No. Local: 6 < 7 < 1? No. Beauty = 0. Total = 2.

example_3.py — Global Beauty Case

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

› Output: 6

💡 Note: This is a strictly increasing array. Index 1 (value 2): leftMax[1]=1 < 2 < rightMin[1]=3. Beauty = 2. Index 2 (value 3): leftMax[2]=2 < 3 < rightMin[2]=4. Beauty = 2. Index 3 (value 4): leftMax[3]=3 < 4 < rightMin[3]=5. Beauty = 2. Total = 2 + 2 + 2 = 6.

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
Only middle elements are considered (indices 1 to n-2)

Visualization

Tap to expand

Understanding the Visualization

Survey Left Boundary

Record the highest peak seen when approaching from the left

Survey Right Boundary

Record the lowest peak seen when approaching from the right

Assess Global Beauty

Peak gets score 2 if it's higher than all left peaks and lower than all right peaks

Check Local Beauty

If not globally beautiful, check if peak is higher than immediate neighbors (score 1)

Sum Total Beauty

Add up all beauty scores across the mountain range

Key Takeaway

🎯 Key Insight: Pre-calculating left maximums and right minimums transforms an O(n²) nested loop problem into an elegant O(n) solution with just three linear passes through the data.

Asked in

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

The optimal approach uses two-pass preprocessing to compute left maximums and right minimums in O(n) time and O(n) space. This eliminates the need for nested loops and reduces time complexity from O(n²) to O(n). The key insight is that precomputing boundary conditions allows instant beauty evaluation for each element.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check all elements to the left and right for each position
Two-Pass Preprocessing	O(n)	O(n)	Precompute left maximums and right minimums for efficient beauty calculation

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each valid index i (1 to n-2)
For each i, check all elements j < i to see if nums[j] < nums[i]
Check all elements k > i to see if nums[i] < nums[k]
If both conditions are true, add 2 to result
Otherwise, check if nums[i-1] < nums[i] < nums[i+1] and add 1
Return the total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Element

Choose element at index i to evaluate

Check Left Elements

Iterate through all elements j < i to verify nums[j] < nums[i]

Check Right Elements

Iterate through all elements k > i to verify nums[i] < nums[k]

Assign Beauty

Give beauty score based on conditions met

Code -

solution.c — C

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

int sumOfBeauties(int* nums, int numsSize) {
    int totalBeauty = 0;
    
    for (int i = 1; i < numsSize - 1; i++) {
        // Check if globally beautiful (beauty = 2)
        bool leftValid = true;
        for (int j = 0; j < i; j++) {
            if (nums[j] >= nums[i]) {
                leftValid = false;
                break;
            }
        }
        
        bool rightValid = true;
        if (leftValid) {
            for (int k = i + 1; k < numsSize; k++) {
                if (nums[i] >= nums[k]) {
                    rightValid = false;
                    break;
                }
            }
        }
        
        if (leftValid && rightValid) {
            totalBeauty += 2;
        } else if (nums[i - 1] < nums[i] && nums[i] < nums[i + 1]) {
            totalBeauty += 1;
        }
    }
    
    return totalBeauty;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int size = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", sumOfBeauties(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n-2 elements, we potentially check all other elements in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track sum and loop indices

✓ Linear Space

28.4K Views

Medium Frequency

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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler