Maximum Number of Operations With the Same Score I

Maximum Number of Operations With the Same Score I - Problem

Array Simulation Easy

You are given an array of integers nums. Consider the following operation:

Delete the first two elements nums[0] and nums[1] and define the score of the operation as the sum of these two elements.

You can perform this operation until nums contains fewer than two elements. Additionally, the same score must be achieved in all operations.

Return the maximum number of operations you can perform.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: First pair: 3+2=5, second pair: 1+4=5, third pair: 5+2=7≠5, so we stop. Total operations: 2.

Example 2 — Single Operation

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

› Output: 1

💡 Note: First pair: 3+2=5, second pair: 6+1=7≠5, so we stop after 1 operation.

Example 3 — All Same Score

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

› Output: 2

💡 Note: First pair: 1+4=5, second pair: 2+3=5. Both pairs have same score, so 2 operations total.

Constraints

2 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Input

Array of integers [3,2,1,4,5,2]

Process

Take consecutive pairs from front with same sum

Output

Count of operations performed: 2

Key Takeaway

🎯 Key Insight: The first pair determines the target score, and we count consecutive matching pairs from the front

Asked in

M Microsoft 25 a Amazon 20 G Google 15

The key insight is that we must take pairs consecutively from the front of the array, and all pairs must have the same sum as the first pair. Best approach uses a single pass with early termination. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Early Termination Optimization	O(n)	O(1)	Same approach but with optimizations for edge cases and early termination
Single Pass Simulation	O(n)	O(1)	Take first two elements as target score, then keep taking pairs while sum matches

Early Termination Optimization — Algorithm Steps

Step 1: Handle edge case - return 0 if less than 2 elements
Step 2: Set target score from first pair and initialize counter
Step 3: Iterate with early termination when score doesn't match

Visualization

Tap to expand

Step-by-Step Walkthrough

Edge Check

Return 0 immediately if less than 2 elements

Process Pairs

Check pairs sequentially with early exit

Terminate Early

Stop immediately when score doesn't match

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    if (numsSize < 2) {
        return 0;
    }
    
    int targetScore = nums[0] + nums[1];
    int operations = 0;
    int i = 0;
    
    while (i + 1 < numsSize) {
        if (nums[i] + nums[i + 1] == targetScore) {
            operations++;
            i += 2;
        } else {
            break;
        }
    }
    
    return operations;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array from JSON format
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    
    while (token != NULL) {
        int num = atoi(token);
        if (num != 0 || token[0] == '0') {
            nums[numsSize++] = num;
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, potentially early termination

✓ Linear Growth

Space Complexity

O(1)

Only constant extra variables for tracking state

✓ Linear Space

30.3K Views

Medium Frequency

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

Early Termination Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler