Find Score of an Array After Marking All Elements

Find Score of an Array After Marking All Elements - Problem

You are given an array nums consisting of positive integers.

Starting with score = 0, apply the following algorithm:

Choose the smallest integer of the array that is not marked. If there is a tie, choose the one with the smallest index.
Add the value of the chosen integer to score.
Mark the chosen element and its two adjacent elements if they exist.
Repeat until all the array elements are marked.

Return the score you get after applying the above algorithm.

Input & Output

Example 1 — Basic Case

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

› Output: 7

💡 Note: Choose 1 (smallest), mark indices 0,1,2 → score=1. Choose 2 (at index 5), mark indices 4,5 → score=3. Choose 4 (at index 3), mark index 3 → score=7. All elements marked.

Example 2 — All Same Values

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

› Output: 4

💡 Note: Choose first 2 (index 0), mark indices 0,1 → score=2. Choose 2 (index 2), mark indices 1,2,3 → score=4. All marked.

Example 3 — Single Element

$ Input: nums = [5]

› Output: 5

💡 Note: Only one element, choose it → score=5.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to always choose the globally smallest unmarked element, not just locally optimal choices. The best approach is sorting first with O(n log n) time and O(n) space, which cleanly separates the sorting logic from the marking simulation.

Common Approaches

✓ Brute Force Simulation

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

For each iteration, scan the entire array to find the smallest unmarked element with the smallest index. Mark the element and its neighbors, then add to score.

Priority Queue with Index Tracking

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

Store all elements with their indices in a min-heap. Pop elements until we find one that's not marked, then mark it and neighbors. This avoids scanning the entire array each time.

Sort with Index Tracking

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

Create pairs of (value, index), sort by value, then process in sorted order. Check if each element is unmarked before adding to score and marking neighbors.

Brute Force Simulation — Algorithm Steps

Step 1: Create marked array to track processed elements
Step 2: Repeatedly find smallest unmarked element with smallest index
Step 3: Add to score, mark element and neighbors
Step 4: Continue until all elements are marked

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Min

Scan array to find smallest unmarked element

Mark

Mark chosen element and neighbors

Repeat

Continue until all elements marked

Code -

solution.c — C

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

int solution(int* nums, int n) {
    bool* marked = (bool*)calloc(n, sizeof(bool));
    int score = 0;
    
    while (true) {
        // Find smallest unmarked element with smallest index
        int minVal = INT_MAX;
        int minIdx = -1;
        
        for (int i = 0; i < n; i++) {
            if (!marked[i] && nums[i] < minVal) {
                minVal = nums[i];
                minIdx = i;
            }
        }
        
        // If no unmarked element found, we're done
        if (minIdx == -1) break;
        
        // Add to score
        score += minVal;
        
        // Mark the element and its neighbors
        int start = (minIdx - 1 < 0) ? 0 : minIdx - 1;
        int end = (minIdx + 2 > n) ? n : minIdx + 2;
        for (int j = start; j < end; j++) {
            marked[j] = true;
        }
    }
    
    free(marked);
    return score;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n iterations, we scan the entire array to find the minimum

⚡ Linearithmic

Space Complexity

O(n)

Extra boolean array to track marked elements

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

450 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler