4-valores duplicados en un arreglo-Lo que sucede con frecuencia-Resumen de la función completa-El Conteo de Asistencias

 

Lo que sucede con frecuencia = {1: 1, 2: 2, 3: 3}:

Paso a paso:

1. const resultado = [] - Crea array vacío

2. for (let num in frecuencia) - Itera sobre las claves:

• Iteración 1: num = "1"

  javascript

frecuencia["1"] → 1
1 === 2? → FALSO
// No hace nada, resultado sigue: []

Iteración 2: num = "2"

javascript

frecuencia["2"] → 2
2 === 2? → VERDADERO
resultado.push(Number("2")) → resultado = [2]

Iteración 3: num = "3"

javascript

frecuencia["3"] → 3
3 === 2? → FALSO
// No hace nada, resultado sigue: [2]

3. return resultado - Retorna [2]

¿Para qué sirve este código?

Propósito: Encontrar qué números aparecen exactamente 2 veces en el array original.

Ejemplo completo:

Si el array original era: [1, 2, 2, 3, 3, 3]

Después de contar frecuencias:

javascript

frecuencia = {
    1: 1,  // El 1 aparece 1 vez
    2: 2,  // El 2 aparece 2 veces ← ESTE NOS INTERESA
    3: 3   // El 3 aparece 3 veces
}

Después del filtro:

javascript

resultado = [2]  // Solo el número 2 aparece exactamente 2 veces

¿Qué entregaría al final?

javascript

console.log(encontrarDuplicadosExactos([1, 2, 2, 3, 3, 3]));
// Output: [2]

Otro ejemplo:

Array: [4, 4, 5, 5, 6]

javascript

frecuencia = {4: 2, 5: 2, 6: 1}
resultado = [4, 5]  // Ambos aparecen 2 veces

En resumen: Este código filtra y devuelve un array con los números (no las frecuencias) que aparecen exactamente 2 veces en el array original.

 

 

Resumen de la función completa:

Primer ciclo: Contar frecuencias

javascript

for (let num of arr) {
    frecuencia.set(num, (frecuencia.get(num) || 0) + 1);
}

Propósito: Construir un "diccionario" que nos dice cuántas veces aparece cada número.

Ejemplo con [1, 2, 2, 3]:

text

Después del primer ciclo:
frecuencia = {
    1: 1,
    2: 2, 
    3: 1
}

Segundo ciclo: Filtrar resultados

javascript

for (let num in frecuencia) {
    if (frecuencia[num] === 2) {
        resultado.push(Number(num));
    }
}

Propósito: Revisar el diccionario y extraer solo los números que cumplen la condición (aparecen exactamente 2 veces).

En nuestro ejemplo:

• Revisa 1: 1 → ❌ No cumple (no es 2)

• Revisa 2: 2 → ✅ Cumple (es exactamente 2) → Agrega el número 2 al resultado

• Revisa 3: 1 → ❌ No cumple (no es 2)

Resultado final: [2]

La lógica en dos pasos:

1. ¿Qué números hay y cuántas veces aparecen? (Primer ciclo)

2. De esos números, ¿cuáles aparecen exactamente 2 veces? (Segundo ciclo)

Analogía:

Es como:

1. Contar cuántas veces llegó cada estudiante a clase

2. Filtrar solo los que llegaron exactamente 2 veces

   ghjhg

    

    

 

: El Conteo de Asistencias

Problema: En un salón de clases, queremos saber qué estudiantes vinieron exactamente 2 días esta semana.

---

PASO 1: CONTAR ASISTENCIAS (Primer ciclo)

Pseudocódigo:

text

PARA CADA estudiante en la lista de asistentes:
    SI el estudiante es NUEVO en mi registro:
        Anotar que ha venido 1 vez
    SI NO:
        Sumar 1 a sus asistencias actuales

Ejemplo con estudiantes: [Ana, Luis, Ana, Carlos, Luis]

Proceso:

• Ana → Nueva → Registrar: Ana: 1

• Luis → Nuevo → Registrar: Luis: 1

• Ana → Ya existe → Ana: 1 + 1 = 2

• Carlos → Nuevo → Registrar: Carlos: 1

• Luis → Ya existe → Luis: 1 + 1 = 2

Registro final:

text

Ana: 2 asistencias
Luis: 2 asistencias  
Carlos: 1 asistencia

---

PASO 2: FILTRAR RESULTADOS (Segundo ciclo)

Pseudocódigo:

text

CREAR lista vacía para resultados

PARA CADA estudiante en mi registro:
    SI sus asistencias son EXACTAMENTE 2:
        AGREGAR estudiante a la lista de resultados

DEVOLVER lista de resultados

Proceso:

• Ana: 2 asistencias → ✅ Cumple → Agregar Ana

• Luis: 2 asistencias → ✅ Cumple → Agregar Luis

• Carlos: 1 asistencia → ❌ No cumple → Saltar

Resultado final: [Ana, Luis]

---

RESUMEN DE LA LÓGICA:

1. FASE DE CONTEO: "¿Cuántas veces apareció cada elemento?"

2. FASE DE FILTRO: "De todos los elementos, ¿cuáles aparecieron exactamente 2 veces?"

EN TU EJEMPLO ORIGINAL:

Array: [1, 2, 2]

• Fase 1: Contar → {1: 1 vez, 2: 2 veces}

• Fase 2: Filtrar → Solo el 2 tiene exactamente 2 apariciones

• Resultado: [2]

¡La clave está en separar el CONTEO del FILTRADO!

 

 

************************