Set Mismatch

Set Mismatch - Problem

You have a set of integers s, which originally contains all the numbers from 1 to n. Unfortunately, due to some error, one of the numbers in s got duplicated to another number in the set, which results in repetition of one number and loss of another number.

You are given an integer array nums representing the data status of this set after the error. Find the number that occurs twice and the number that is missing and return them in the form of an array.

The returned array should contain [duplicate, missing] where duplicate is the number that appears twice and missing is the number that should be present but isn't.

Input & Output

Example 1 — Basic Case

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

› Output: [2,3]

💡 Note: Number 2 appears twice (duplicate), number 3 is missing from the sequence 1,2,3,4

Example 2 — Different Position

$ Input: nums = [1,1]

› Output: [1,2]

💡 Note: Number 1 appears twice (duplicate), number 2 is missing from the sequence 1,2

Example 3 — Larger Array

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

› Output: [3,1]

💡 Note: Number 3 appears twice (duplicate), number 1 is missing from the sequence 1,2,3,4,5,6

Constraints

2 ≤ nums.length ≤ 10⁴
1 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

a Amazon 35 G Google 28 M Microsoft 22 🍎 Apple 18

The key insight is that in a perfect sequence 1 to n, exactly one number appears twice and one is missing. Best approach is Hash Map Frequency Count for clarity or Mathematical Sum Difference for optimal space. Time: O(n), Space: O(n) for hash map or O(1) for math approach.

Common Approaches

✓ Brute Force

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

For each number from 1 to n, count how many times it appears in the array. The number appearing twice is the duplicate, and the number appearing zero times is missing.

Hash Map Frequency Count

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

Count the frequency of each number using a hash map. Then iterate through numbers 1 to n to find which has frequency 2 (duplicate) and which is missing from the map (missing).

Mathematical Sum Difference

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

Calculate the expected sum (1+2+...+n) and actual sum of the array. The difference reveals information about duplicate and missing numbers. Use sum of squares for additional equation to solve both unknowns.

Brute Force — Algorithm Steps

Step 1: For each number i from 1 to n
Step 2: Count occurrences of i in the array
Step 3: If count is 2, it's duplicate; if count is 0, it's missing

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Each Number

For each i from 1 to n, count occurrences in array

Count Occurrences

Scan entire array to count how many times i appears

Identify Pattern

Count=2 means duplicate, count=0 means missing

Code -

solution.c — C

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

void solution(int* nums, int n, int* result) {
    int duplicate = -1;
    int missing = -1;
    
    for (int i = 1; i <= n; i++) {
        int count = 0;
        for (int j = 0; j < n; j++) {
            if (nums[j] == i) {
                count++;
            }
        }
        
        if (count == 2) {
            duplicate = i;
        } else if (count == 0) {
            missing = i;
        }
    }
    
    result[0] = duplicate;
    result[1] = missing;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int n = 0;
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result[2];
    solution(nums, n, result);
    printf("[%d,%d]\n", result[0], result[1]);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n numbers, we scan the entire array of n elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and result

⚡ Linearithmic Space

185.0K Views

Medium Frequency

~15 min Avg. Time

2.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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler