1-valores duplicados en un arreglo

 Debes encontrar valores duplicados en un arreglo de números enteros y 
regresar un arreglo con los números que se repitan exactamente 2 veces. Prueba tu algoritmo para los siguientes casos:
[4,3,2,7,8,3,1]=[32]

[1,1,2] = [1]

[1]=[]

¿Qué es un arreglo?

Un arreglo (o array) es una estructura de datos que almacena una colección de elementos en un orden específico. Piensa en él como una lista ordenada donde cada elemento tiene una posición numerada.

Características principales:

• Elementos: Pueden ser números, texto, objetos, etc.

• Índices: Cada elemento tiene una posición (empezando desde 0)

• Orden: Los elementos mantienen el orden en que fueron agregados

Ejemplo visual:

javascript

// Arreglo de números
let numeros = [4, 3, 2, 7, 8, 3, 1];

// Posiciones (índices):
// índice:  0  1  2  3  4  5  6
// valor:   4  3  2  7  8  3  1

Acceso a elementos:

javascript

console.log(numeros[0]); // 4 (primer elemento)
console.log(numeros[1]); // 3 (segundo elemento)
console.log(numeros[5]); // 3 (sexto elemento)

Nuestro arreglo ejemplo:

Vamos a usar este arreglo para explicar el problema:

javascript

let arregloEjemplo = [4, 3, 2, 7, 8, 3, 1];

Análisis del arreglo:

• Elementos únicos: 4, 2, 7, 8, 1 (aparecen 1 vez)

• Elemento duplicado: 3 (aparece 2 veces)

• Total de elementos: 7

¿Qué queremos hacer con este arreglo?

Queremos encontrar qué números aparecen exactamente 2 veces. En este caso:

• El número 3 aparece en las posiciones 1 y 5 → 2 veces

• Todos los demás aparecen 1 vez

Resultado esperado: [3]

Proceso paso a paso:

1. Recorrer el arreglo: [4, 3, 2, 7, 8, 3, 1]

2. Contar apariciones:

   • 4 → 1 vez

   • 3 → 2 veces ✓

   • 2 → 1 vez

   • 7 → 1 vez

   • 8 → 1 vez

   • 1 → 1 vez

3. Seleccionar: Solo el número 3 tiene exactamente 2 apariciones

¿Te queda claro qué es un arreglo y cómo vamos a trabajar con él?

 

Análisis del problema

Necesitamos encontrar números que aparezcan exactamente 2 veces en el arreglo, no más ni menos.

Estrategia de solución

1. Contar frecuencia: Contar cuántas veces aparece cada número

2. Filtrar resultados: Seleccionar solo los números que aparecen exactamente 2 veces

Solución en JavaScript

javascript

function encontrarDuplicadosExactos(arr) {
    // Paso 1: Contar frecuencia de cada número
    const frecuencia = {};
    
    for (let num of arr) {
        frecuencia[num] = (frecuencia[num] || 0) + 1;
    }
    
    // Paso 2: Filtrar números que aparecen exactamente 2 veces
    const resultado = [];
    
    for (let num in frecuencia) {
        if (frecuencia[num] === 2) {
            resultado.push(Number(num));
        }
    }
    
    return resultado;
}

Versión más concisa (usando Map)

javascript

function encontrarDuplicadosExactos(arr) {
    const frecuencia = new Map();
    
    // Contar frecuencia
    for (let num of arr) {
        frecuencia.set(num, (frecuencia.get(num) || 0) + 1);
    }
    
    // Filtrar y retornar
    return Array.from(frecuencia.entries())
        .filter(([num, count]) => count === 2)
        .map(([num]) => num);
}

Prueba de los casos

javascript

// Caso 1
console.log(encontrarDuplicadosExactos([4,3,2,7,8,3,1])); // [3]
console.log(encontrarDuplicadosExactos([1,1,2])); // [1]
console.log(encontrarDuplicadosExactos([1])); // []

// Casos adicionales para probar
console.log(encontrarDuplicadosExactos([1,2,3,4,5])); // []
console.log(encontrarDuplicadosExactos([1,1,2,2,3,3,3])); // [1,2]
console.log(encontrarDuplicadosExactos([1,1,1,2,2])); // [2]

Explicación detallada

1. Contar frecuencia: Usamos un objeto o Map para almacenar cuántas veces aparece cada número

2. Filtrar: Recorremos el objeto de frecuencias y seleccionamos solo los números con valor 2

3. Retornar: Convertimos los resultados a un arreglo

Complejidad

• Tiempo: O(n) - recorremos el arreglo una vez

• Espacio: O(n) - almacenamos las frecuencias en un objeto/Map

   

   

   

   

   

  Desglose de la línea

  javascript

  frecuencia[num] = (frecuencia[num] || 0) + 1;

  Vamos a dividirla en partes:

  1. frecuencia[num]

• Accede al valor almacenado en el objeto frecuencia para la clave num

• Si la clave no existe, devuelve undefined

2. frecuencia[num] || 0

• El operador || (OR lógico) funciona así:

  • Si frecuencia[num] tiene un valor truthy (diferente de 0, null, undefined, false, "", NaN), usa ese valor

  • Si es falsy (especialmente undefined cuando la clave no existe), usa 0

3. (...) + 1

• Toma el resultado del paso anterior y le suma 1

4. Asignación

• Asigna el nuevo valor de vuelta a frecuencia[num]

Ejemplo paso a paso

Arreglo: [1, 1, 2]

Iteración 1 (num = 1):

• frecuencia[1] es undefined (no existe)

• undefined || 0 = 0

• 0 + 1 = 1

• frecuencia[1] = 1

Iteración 2 (num = 1):

• frecuencia[1] es 1

• 1 || 0 = 1

• 1 + 1 = 2

• frecuencia[1] = 2

Iteración 3 (num = 2):

• frecuencia[2] es undefined

• undefined || 0 = 0

• 0 + 1 = 1

• frecuencia[2] = 1

Equivalente más explícito

javascript

// Esta línea:
frecuencia[num] = (frecuencia[num] || 0) + 1;

// Es equivalente a:
if (frecuencia[num] === undefined) {
    frecuencia[num] = 1;  // Primera vez que aparece
} else {
    frecuencia[num] = frecuencia[num] + 1;  // Incrementar contador
}

¿Por qué usar este patrón?

• Conciso: Una línea en lugar de 4-5

• Elegante: Maneja el caso "no existe" de forma compacta

• Común: Patrón muy usado en JavaScript para contadores

Versiones alternativas

Usando operador nullish coalescing (??):

javascript

frecuencia[num] = (frecuencia[num] ?? 0) + 1;

Usando if explícito:

javascript

if (!frecuencia[num]) {
    frecuencia[num] = 1;
} else {
    frecuencia[num]++;
}

¿Queda claro cómo funciona esta línea? 

•