Append K Integers With Minimal Sum

Append K Integers With Minimal Sum - Problem

You are given an integer array nums and an integer k. Append k unique positive integers that do not appear in nums to nums such that the resulting total sum is minimum.

Return the sum of the k integers appended to nums.

Input & Output

Example 1 — Basic Case

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

› Output: 5

💡 Note: The integers not in nums that do not appear are 2, 3, 5, 6, 7, ... Taking the first k=2 smallest: 2 and 3. Sum = 2 + 3 = 5

Example 2 — Starting from 1

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

› Output: 25

💡 Note: Missing positive integers: 1, 2, 3, 4, 7, 8, ... Taking first k=6: [1,2,3,4,7,8]. Sum = 1+2+3+4+7+8 = 25

Example 3 — No gaps until end

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

› Output: 21

💡 Note: All numbers 1-5 exist. Next k=3 missing are 6, 7, 8. Sum = 6 + 7 + 8 = 21

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 2 × 10⁸

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to find the k smallest missing positive integers to minimize their sum. The optimal approach sorts the array and uses mathematical formulas to calculate sums of consecutive ranges efficiently. Time: O(n log n), Space: O(n)

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n + k) Space: O(n)

Convert nums to a set for O(1) lookup. Iterate through positive integers 1, 2, 3, ... and collect those not in the set until we have k missing numbers. Sum them up.

Mathematical Formula

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

Sort the array and use arithmetic progression formulas to calculate sums of consecutive missing ranges. This avoids iterating through each individual number and instead calculates the sum of ranges directly using the formula sum = n*(first + last)/2.

Sort and Find Gaps

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

Sort the nums array and remove duplicates. Iterate through sorted unique numbers to find gaps between consecutive numbers. Fill gaps with smallest missing positive integers until we have k numbers.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_NUM 100000

static bool exists[MAX_NUM + 1];

int main() {
    char line[10000];
    
    // Read first line (array)
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    // Initialize exists array
    for (int i = 0; i <= MAX_NUM; i++) {
        exists[i] = false;
    }
    
    // Parse array and mark existing numbers
    int i = 0;
    int num = 0;
    bool inNumber = false;
    bool negative = false;
    
    while (line[i] != '\0' && line[i] != '\n') {
        char c = line[i];
        
        if (c >= '0' && c <= '9') {
            if (!inNumber) {
                inNumber = true;
                num = 0;
                negative = false;
            }
            num = num * 10 + (c - '0');
        } else if (c == '-') {
            negative = true;
            inNumber = true;
            num = 0;
        } else {
            if (inNumber) {
                if (negative) {
                    num = -num;
                }
                // Only mark positive numbers
                if (num > 0 && num <= MAX_NUM) {
                    exists[num] = true;
                }
                inNumber = false;
                negative = false;
            }
        }
        i++;
    }
    
    // Handle last number if line ends
    if (inNumber) {
        if (negative) {
            num = -num;
        }
        if (num > 0 && num <= MAX_NUM) {
            exists[num] = true;
        }
    }
    
    // Read k
    int k;
    if (scanf("%d", &k) != 1) {
        return 1;
    }
    
    // Find k smallest positive integers not in array
    long long sum = 0;
    int count = 0;
    int current = 1;
    
    while (count < k) {
        if (current > MAX_NUM || !exists[current]) {
            sum += current;
            count++;
        }
        current++;
    }
    
    printf("%lld\n", sum);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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