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

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

✓ Early Termination Optimization

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

Identical algorithm but with better handling of edge cases and early termination when we encounter a pair that doesn't match the target score.

Single Pass Simulation

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

Calculate the sum of first two elements as the target score. Then iterate through remaining elements in pairs, counting how many consecutive pairs from the start have the same sum.

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>
#include <ctype.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;
    int i = 0;
    int len = strlen(line);
    
    while (i < len) {
        if (isdigit(line[i])) {
            int num = 0;
            while (i < len && isdigit(line[i])) {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            nums[numsSize++] = num;
        } else {
            i++;
        }
    }
    
    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

Maximum Number of Operations With the Same Score I - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Early Termination Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler