Establecer discrepancia

Lectura

Establecer discrepancia (Java, Python, PHP, C++, JavaScript)

Se tiene un array de números enteros, y este contiene un par de valores duplicados y, además, uno de los valores de la secuencia se ha perdido, entonces el objetivo del ejercicio es encontrar el valor repetido y el valor faltante del conjunto de números.

En el ejemplo se puede apreciar, que el valor repetido es 2, y el valor faltante sería 3, ya que en la secuencia pasa los valores del array de 2 a 4.

Explicación del ejercicio Paso por paso

Código de la solución

Java

class Solution {
    public int[] findErrorNums(int[] nums) {
        // Paso #1: Contar la frecuencia de cada número
        Map cantidad = new HashMap<>();
        for (int num : nums) {
            cantidad.put(num, cantidad.getOrDefault(num, 0) + 1);
        }

        // Paso #2: Inicializar variables para el tamaño, no encontrado y duplicado
        int size = nums.length;
        int not_found = 1;
        int dup = 0;

        // Paso #3: Buscar el número faltante del 1 al tamaño del arreglo
        for (int i = 1; i <= size; i++) {
            if (!cantidad.containsKey(i)) {
                not_found = i;
                break;
            }
        }

        // Paso #4: Buscar el número que se repite (frecuencia igual a 2)
        for (Map.Entry entry : cantidad.entrySet()) {
            if (entry.getValue() == 2) {
                dup = entry.getKey();
                break;
            }
        }

        // Paso #5: Retornar la respuesta con [duplicado, faltante]
        int[] response = new int[2];
        response[0] = dup;
        response[1] = not_found;
        return response;
    }
}

Python

class Solution(object):
    def findErrorNums(self, nums):
        # Paso #1
        cantidad = {}
        for num in nums:
            cantidad[num] = cantidad.get(num, 0) + 1

        # Paso #2
        size = len(nums)
        not_found = 1
        dup = 0

        # Paso #3
        for i in range(1, size + 1):
            if i not in cantidad:
                not_found = i
                break

        # Paso #4
        for key, value in cantidad.items():
            if value == 2:
                dup = key
                break

        # Paso #5
        return [dup, not_found]

PHP

class Solution {

    /**
     * @param Integer[] $nums
     * @return Integer[]
     */
    function findErrorNums($nums) {
        // Paso #1
        $cantidad = [];
        foreach ($nums as $num) {
            $cantidad[$num] = ($cantidad[$num] ?? 0) + 1;
        }

        // Paso #2
        $size = count($nums);
        $not_found = 1;
        $dup = 0;

        // Paso #3
        for ($i = 1; $i <= $size; $i++) {
            if (!array_key_exists($i, $cantidad)) {
                $not_found = $i;
                break;
            }
        }

        // Paso #4
        foreach ($cantidad as $key => $value) {
            if ($value === 2) {
                $dup = $key;
                break;
            }
        }

        // Paso #5
        return [$dup, $not_found];
    }
}

C++

class Solution {
public:
    vector findErrorNums(vector& nums) {
        // Paso #1
        unordered_map cantidad;
        for (int num : nums) {
            cantidad[num]++;
        }

        // Paso #2
        int size = nums.size();
        int not_found = 1;
        int dup = 0;

        // Paso #3
        for (int i = 1; i <= size; i++) {
            if (cantidad.find(i) == cantidad.end()) {
                not_found = i;
                break;
            }
        }

        // Paso #4
        for (auto const& [key, value] : cantidad) {
            if (value == 2) {
                dup = key;
                break;
            }
        }

        // Paso #5
        return {dup, not_found};
    }
};

JavaScript

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var findErrorNums = function(nums) {
    // Paso #1
    const cantidad = new Map();
    for (const num of nums) {
        cantidad.set(num, (cantidad.get(num) || 0) + 1);
    }

    // Paso #2
    const size = nums.length;
    let not_found = 1;
    let dup = 0;

    // Paso #3
    for (let i = 1; i <= size; i++) {
        if (!cantidad.has(i)) {
            not_found = i;
            break;
        }
    }

    // Paso #4
    for (const [key, value] of cantidad.entries()) {
        if (value === 2) {
            dup = key;
            break;
        }
    }

    // Paso #5
    return [dup, not_found];
};