Codestin Search App

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
✓ 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)	O(n + k)	O(n)	Check every positive integer starting from 1 until we find k missing numbers

Optimal (Math + Sorting) — Algorithm Steps

Remove duplicates and sort the positive numbers from nums
Start from number 1 and process gaps between sorted numbers
For each gap, calculate how many numbers we need and their sum using arithmetic formulas
If we need more numbers after processing all gaps, add consecutive numbers from the end
Return the total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort & Dedupe

Remove duplicates and sort positive numbers: [1, 4, 10, 25]

Find Gaps

Identify gaps: [2,3] between 1-4, [5,6,7,8,9] between 4-10

Calculate Sums

Use formula: n*(2*start + n-1)/2 for each range

Accumulate

Add up sums until we've taken k numbers

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

long long minimumSum(int* nums, int numsSize, int k) {
    // Filter and sort positive numbers, removing duplicates
    int positive[numsSize];
    int positiveSize = 0;
    
    // Add positive numbers
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > 0) {
            positive[positiveSize++] = nums[i];
        }
    }
    
    // Sort and remove duplicates
    qsort(positive, positiveSize, sizeof(int), compare);
    int uniqueSize = 0;
    for (int i = 0; i < positiveSize; i++) {
        if (i == 0 || positive[i] != positive[i-1]) {
            positive[uniqueSize++] = positive[i];
        }
    }
    
    long long totalSum = 0;
    long long current = 1;
    long long remaining = k;
    
    // Process each number in the sorted array
    for (int i = 0; i < uniqueSize && remaining > 0; i++) {
        int num = positive[i];
        
        // If there's a gap between current and num
        if (current < num) {
            // Calculate how many numbers we can take from this gap
            long long gapSize = num - current;
            long long take = (remaining < gapSize) ? remaining : gapSize;
            
            // Sum of arithmetic sequence
            long long rangeSum = take * (2 * current + take - 1) / 2;
            totalSum += rangeSum;
            remaining -= take;
        }
        
        // Move current to the next position after num
        current = num + 1;
    }
    
    // If we still need more numbers
    if (remaining > 0) {
        long long rangeSum = remaining * (2 * current + remaining - 1) / 2;
        totalSum += rangeSum;
    }
    
    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 log n)

O(n log n) for sorting, then O(n) for processing gaps

⚡ Linearithmic

Space Complexity

O(n)

O(n) space for storing sorted unique positive 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

Optimal (Math + Sorting) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler