Leetcode — The Two Sneaky Numbers of Digitville

It’s an easy problem with description being:

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.

Example 1:

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

Output: [0,1]

Explanation:

The numbers 0 and 1 each appear twice in the array.

Example 2:

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

Output: [2,3]

Explanation:

The numbers 2 and 3 each appear twice in the array.

Example 3:

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

Output: [4,5]

Explanation:

The numbers 4 and 5 each appear twice in the array.

Constraints:

2 <= n <= 100

nums.length == n 2

0 <= nums[i] < n

The input is generated such that nums contains exactly two repeated elements.

This problem has many ways to get it sorted out, you could use a set, a map, array as map, even use bits, but since it’s an easy problem perhaps we shouldn’t go far deep into the rabbit hole.

For the solution I went with simple approach that would be sorting it out the array and then on an iteration check if the previous number is equal, if yes, add into my result and that’s it:

class Solution {
    public int[] getSneakyNumbers(int[] nums) {

        // build the response and the pivot for the first item of the response array
        int pivot = 0;
        int[] response = new int[2];

        // sort nums array to make it easy to identify duplication
        Arrays.sort(nums);

        // iterate and numbers nearby are the ones considered sneaky, grab them and add into the response
        for(int i=1;i<nums.length;i++) {
            if(nums[i-1]==nums[i]){
                response[pivot] = nums[i];
                pivot++;
            }
        }

        // return response
        return response;
    } 
}

Runtime: 2 ms, faster than 70.75% of Java online submissions.

Memory Usage: 44.49 MB, less than 86.86% of Java online submissions.

If you are sure that there will be no more than two you could do extra check, but besides that this solution fulfills most of it’s needs.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

The above is the detailed content of Leetcode — The Two Sneaky Numbers of Digitville. For more information, please follow other related articles on the PHP Chinese website!