The Two Sneaky Numbers of Digitville - Problem

In the town of Digitville, there was a list of numbers called nums containing integers from 0 to n - 1. Each number was supposed to appear exactly once in the list, however, two mischievous numbers sneaked in an additional time, making the list longer than usual.

As the town detective, your task is to find these two sneaky numbers. Return an array of size two containing the two numbers (in any order), so peace can return to Digitville.

Input & Output

Example 1 — Basic Case

$ Input: nums = [0,1,1,0]

› Output: [0,1]

💡 Note: The numbers 0 and 1 each appear twice in the array. Both are duplicates that sneaked in.

Example 2 — Different Numbers

$ Input: nums = [0,1,2,3,2,1]

› Output: [1,2]

💡 Note: Numbers 1 and 2 each appear twice. They are the sneaky duplicates we need to find.

Example 3 — Edge Case

$ Input: nums = [7,1,2,3,4,5,6,0,8,9,7,8]

› Output: [7,8]

💡 Note: In this larger array, numbers 7 and 8 appear twice each, making them the duplicates.

Constraints

2 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ nums.length - 3

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 18

The key insight is to track which numbers we've already seen as we iterate through the array. The best approach uses a hash set to detect duplicates in a single pass with O(n) time and O(n) space complexity.

Common Approaches

✓ Brute Force

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

For each number in the array, check all other positions to see if it appears again. When we find a number that appears more than once, add it to our result.

Hash Map Frequency Count

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

Use a hash map to count how many times each number appears. Then find the numbers that appear more than once.

Single Pass Hash Set

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

As we iterate through the array, add numbers to a hash set. If we try to add a number that's already in the set, we've found a duplicate.

Brute Force — Algorithm Steps

Step 1: For each element, scan the rest of the array
Step 2: If found again, add to duplicates list
Step 3: Return the two duplicates found

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Pairs

Check each element against all others

Find Matches

When nums[i] == nums[j], we found a duplicate

Collect Results

Gather the two duplicate numbers

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    int* result = malloc(2 * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] == nums[j]) {
                // Check if already in result
                int found = 0;
                for (int k = 0; k < count; k++) {
                    if (result[k] == nums[i]) {
                        found = 1;
                        break;
                    }
                }
                if (!found) {
                    result[count++] = nums[i];
                    if (count == 2) {
                        *returnSize = 2;
                        return result;
                    }
                }
            }
        }
    }
    
    *returnSize = count;
    return result;
}

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 JSON array manually
    int nums[1000];
    int numsSize = 0;
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops - for each of n elements, we check n elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

⚡ Linearithmic Space

33.0K Views

Medium Frequency

~15 min Avg. Time

892 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

The Two Sneaky Numbers of Digitville - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler