Append K Integers With Minimal Sum - Practice Coding Problems

Append K Integers With Minimal Sum - Problem

You're given an integer array nums and an integer k. Your task is to append exactly k unique positive integers to the array that don't already exist in nums.

The challenge? You must choose these k integers such that their total sum is minimized. In other words, you want to add the k smallest possible positive integers that aren't already present in the array.

Goal: Return the sum of the k integers you append to nums.

Example: If nums = [1, 4, 25, 10, 25] and k = 2, the smallest missing positive integers are 2 and 3, so you'd return 2 + 3 = 5.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,4,25,10,25], k = 2

› Output: 5

💡 Note: The smallest missing positive integers are 2 and 3. Since 2 + 3 = 5, we return 5.

example_2.py — Sequential Start

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

› Output: 25

💡 Note: The missing numbers are [1,2,3,4,7,8]. We need k=6 numbers, so we take all of them: 1+2+3+4+7+8 = 25.

example_3.py — Edge Case

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

› Output: 11

💡 Note: Numbers 1,2,3,4 are already present. The next smallest missing numbers are 5 and 6, so 5 + 6 = 11.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 2 × 10⁸
Note: k can be very large, so efficient calculation is crucial

Visualization

Tap to expand

Understanding the Visualization

Survey Taken Spots

Identify all occupied positions (existing numbers in nums)

Find Empty Ranges

Look for consecutive empty spots between occupied positions

Calculate Range Costs

Use math formulas to quickly calculate the total cost of each empty range

Fill Cheapest First

Take numbers from the cheapest ranges first until we have k numbers

Key Takeaway

🎯 Key Insight: Instead of checking each number individually, we can mathematically calculate the sum of entire ranges of missing numbers using arithmetic progression formulas, making the solution efficient even for very large k values!

Asked in

G Google 42 a Amazon 35 Apple 28 f Meta 22

The optimal approach uses sorting and mathematical formulas to efficiently calculate the sum. We sort the unique positive numbers, identify gaps between them, and use the arithmetic sequence formula n*(2*start + n-1)/2 to calculate range sums without iterating through each number individually. This achieves O(n log n) time complexity and handles large k values elegantly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Number)	O(n + k)	O(n)	Check every positive integer starting from 1 until we find k missing numbers
Optimal (Math + Sorting)	O(n log n)	O(n)	Sort the array and use mathematical formulas to calculate sums of missing ranges

Brute Force (Check Each Number) — Algorithm Steps

Convert nums to a set for O(1) lookup
Start checking from num = 1
For each number, if it's not in the set, add it to sum and increment count
Continue until count reaches k
Return the accumulated sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Set

Convert nums array to set for fast lookup

Check Numbers

Start from 1 and check each number sequentially

Add Missing

When we find a missing number, add it to our sum

Count Progress

Continue until we've found k missing numbers

Code -

solution.c — C

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

#define MAX_VAL 100001

long long minimumSum(int* nums, int numsSize, int k) {
    // Use boolean array for lookup
    bool exists[MAX_VAL] = {false};
    
    // Mark existing numbers
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < MAX_VAL) {
            exists[nums[i]] = true;
        }
    }
    
    int current = 1;
    int count = 0;
    long long totalSum = 0;
    
    // Find k missing positive integers
    while (count < k) {
        if (current >= MAX_VAL || !exists[current]) {
            totalSum += current;
            count++;
        }
        current++;
    }
    
    return totalSum;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n + k)

O(n) to build the set, then O(k) to find k missing numbers

✓ Linear Growth

Space Complexity

O(n)

O(n) space to store the set of existing numbers

⚡ Linearithmic Space

52.3K Views

Medium-High Frequency

~22 min Avg. Time

1.8K 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 (Check Each Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler