Establecer discrepancia de un arreglo

                
Establecer discrepancia (Java, Python, PHP, C++, Javascript).

Introducción
¿Estás preparando una entrevista de trabajo en Google? Si es así, es importante que practiques la resolución de ejercicios de programación. En esta entrada de blog, aprenderás a resolver un ejercicio de entrevista común en Google.

En este artículo, cubriremos los siguientes temas:

✅ Una explicación del problema
✅ Una solución eficiente
✅ Implementaciones en Java, Python, PHP, C++ y JavaScript

Este ejercicio se encuentra en la plataforma de LeetCode como "Set Mismatch".

           

Problema
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.


Pasos para realizar el algoritmo:

1.-  Se crea un arreglo vacío llamado cantidad y luego se recorre el arreglo nums.  En cada iteración, se asigna el valor actual que se evalúa del array nums como clave del arreglo cantidad, y se incrementa su valor en 1.

NOTA: Para este ejercicio, en el array cantidad no se cuenta la posición 0 porque el valor mínimo del array nums siempre va a ser 1

2.- Se obtiene el tamaño del arreglo nums y se inician las variables not_found y dup en 0. 
✅ El valor not_found, se refiere al número que no se encuentra en el array.
✅ El valor dup, se refiere al número que se encuentra duplicado en el array.

3.- Se recorre el arreglo cantidad desde la posición 1 hasta el final. En cada iteración, se verifica si la posición actual existe en el arreglo cantidad. Si no existe, significa que es el valor que no se encuentra en el array, entonces, se asigna ese valor a la variable not_found y se sale del recorrido.

4.- Se recorre el arreglo cantidad. En cada iteración, se verifica si el valor en la posición actual es igual a 2, es decir, si se encontró más de una vez en el array. Si es así, se asigna su posición a la variable dup y se sale del recorrido.

5.- Finalmente, se devuelve un array, con las variables dup y not_found, en la posición 0 y 1 respectivamente.
            

Código en Java

class Solution {
 
/**
     * @param Integer[] $nums
     * @return Integer[]
     */
    function findErrorNums($nums) {
        //paso#1
        $cantidad=array();
        foreach ($nums as $clave => $num) $cantidad[$num]++;
 
 
        //paso#2
        $size=count($nums);
        $not_found=0;
        $dup=0;
 
        //paso#3
        for ($i = 1; $i <= $size; $i++) {
            if(!isset($cantidad[$i])) {
                $not_found=$i;
                break;
            }
        }
 
 
        //paso#4
        foreach ($cantidad as $clave => $val){
            if($val==2){
                $dup=$clave;
                break;
            }
        }
 
 
        //paso#5
        $response=array();
        $response[0]=$dup;
        $response[1]=$not_found;
 
        return $response;
 
    }
}

Código en php

class Solution {
 
    /**
     * @param Integer[] $nums
     * @return Integer[]
     */
    function findErrorNums($nums) {
        //paso#1
        $cantidad=array();
        foreach ($nums as $clave => $num) $cantidad[$num]++;
 
        //paso#2
        $size=count($nums);
        $not_found=0;
        $dup=0;
 
        //paso#3
        for ($i = 1; $i <= $size; $i++) {
            if(!isset($cantidad[$i])) {
                $not_found=$i;
                break;
            }
        }
 
        //paso#4
        foreach ($cantidad as $clave => $val){
            if($val==2){
                $dup=$clave;
                break;
            }
        }
 
        //paso#5
        $response=array();
        $response[0]=$dup;
        $response[1]=$not_found;
 
        return $response;
    }
}

Código en Python

class Solution:
    def findErrorNums(self, nums):
        # paso#1
        counts = {}
        for num in nums:
            counts[num] = counts.get(num, 0) + 1
 
        # paso#2
        size = len(nums)
        not_found = 0
        duplicate = 0
 
        # paso#3
        for i in range(1, size + 1):
            if i not in counts:
                not_found = i
                break
 
        # paso#4
        for num, count in counts.items():
            if count == 2:
                duplicate = num
                break
 
        # paso#5
        response = [duplicate, not_found]
        return response

Código en C++

class Solution {
public:
    std::vector<int> findErrorNums(std::vector<int>& nums) {
    // Paso #1
    std::unordered_map<int, int> 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.count(i)) {
        not_found = i;
        break;
      }
    }
 
    // Paso #4
    for (const auto& [num, val] : cantidad) {
      if (val == 2) {
        dup = num;
        break;
      }
    }
 
    // Paso #5
    std::vector<int> response = {dup, not_found};
 
    return response;
};
};

Código en JavaScript

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var findErrorNums = function(nums) {
    // Paso #1
    const cantidad = {};
    for (const num of nums) {
      cantidad[num] = (cantidad[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.hasOwnProperty(i)) {
        not_found = i;
        break;
      }
    }
 
    // Paso #4
    for (const [num, val] of Object.entries(cantidad)) {
      if (val === 2) {
        dup = num;
        break;
      }
    }
 
    // Paso #5
    const response = [dup, not_found];
 
    return response;
};

        
    
Conclusión
Los ejercicios de entrevista de Google son una excelente manera de evaluar las habilidades y el conocimiento de los candidatos. Estos ejercicios son desafiantes, pero también son una oportunidad para los candidatos de mostrar sus habilidades y su capacidad para resolver problemas.