Maximum Sum With Exactly K Elements - Practice Coding Problems

Maximum Sum With Exactly K Elements - Problem

Array Greedy Easy

Imagine you're playing a strategic number game where you can transform elements to maximize your score! You are given a 0-indexed integer array nums and an integer k.

Your goal is to perform exactly k operations to achieve the maximum possible score. In each operation, you:

🎯 Select any element m from the array
🗑️ Remove the selected element m from the array
➕ Add a new element with value m + 1 back to the array
📈 Increase your score by m

The key insight: Since you're adding m + 1 back after removing m, you're essentially growing your chosen element by 1 each time while gaining its current value as points!

Return the maximum score you can achieve after performing exactly k operations.

Input & Output

example_1.py — Basic Case

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

› Output: 30

💡 Note: We always pick the maximum element: 9 (score=9, array becomes [5,2,10,1]), then 10 (score=19, array becomes [5,2,11,1]), then 11 (score=30). Total score = 9+10+11 = 30.

example_2.py — Single Element

$ Input: nums = [1], k = 5

› Output: 15

💡 Note: Only one element available, so we pick it 5 times: 1+2+3+4+5 = 15. This demonstrates the arithmetic sequence: starting from 1, we get sequence 1,2,3,4,5.

example_3.py — Large Maximum

$ Input: nums = [1, 10, 3, 3, 3], k = 3

› Output: 33

💡 Note: Maximum element is 10, so we get sequence 10+11+12 = 33. Even though other elements exist, we always choose the maximum for optimal score.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
1 ≤ k ≤ 100
All elements and k are positive integers

Visualization

Tap to expand

Understanding the Visualization

Find the Tallest Tree

Scan through all trees (array elements) to find the tallest one (maximum value)

Harvest Optimally

Always harvest from the tallest tree - it gives maximum coins and grows to stay the tallest

Calculate Total Harvest

Use arithmetic sequence formula instead of simulating: max + (max+1) + (max+2) + ... + (max+k-1)

Apply Mathematical Formula

Sum = k × (2×max + k - 1) ÷ 2 gives us the answer in O(1) time

Key Takeaway

🎯 Key Insight: Greedy choice of always picking the maximum element creates an arithmetic sequence, allowing us to use mathematical formula instead of simulation for optimal efficiency!

Asked in

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

The optimal approach uses greedy strategy - always pick the maximum element. Instead of simulating array operations, recognize that this creates an arithmetic sequence starting from the maximum value. Use the formula k × (2×max + k - 1) ÷ 2 for O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Optimal Solution	O(n)	O(1)	Always pick the maximum element - no need to simulate the actual array operations
Brute Force (Simulate All Operations)	O(k×n)	O(1)	Simulate k operations by repeatedly finding and removing the maximum element

Greedy Optimal Solution — Algorithm Steps

Find the maximum element in the array
Recognize this creates arithmetic sequence: max, max+1, max+2, ..., max+(k-1)
Use arithmetic sequence formula: sum = k * (first + last) / 2
Calculate: first = max, last = max + k - 1
Return k * (2*max + k - 1) / 2

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Maximum

Single pass to find the largest element

Recognize Pattern

Always picking max creates sequence: max, max+1, max+2, ...

Apply Formula

Use arithmetic sequence sum formula

Calculate Result

Return k * (2*max + k - 1) / 2

Code -

solution.c — C

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

int maximumSum(int* nums, int numsSize, int k) {
    // Find maximum element
    int maxVal = nums[0];
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > maxVal) {
            maxVal = nums[i];
        }
    }
    
    // Calculate arithmetic sequence sum
    // k * (2*max + k - 1) / 2
    return k * (2 * maxVal + k - 1) / 2;
}

int main() {
    int nums[100], numsSize = 0, k;
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    scanf("%d", &k);
    printf("%d\n", maximumSum(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to find maximum element

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

52.0K Views

Medium Frequency

~12 min Avg. Time

1.5K 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

Greedy Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler