Estoy aprendiendo a codificar Javascript. He estado aprendiendo durante 6 meses ahora. Estoy trabajando en problemas de guerra de códigos para ayudarme con mi lógica cuando se trata de algoritmos.
Estaba trabajando en este problema de CodeWars Find All Pairs
Aquí estaba mi lógica y código:
SET a pair count variable SET a sorretd array varible FOR LOOP iterate though the array SET index = 0 WHILE index < array argument Increment index IF the current iteration is equal to the index + 1 ADD to the pair count varible RETURN count variableCÓDIGO:
function duplicates(array) { let pairResult = 0; let sorrtedArray = array.sort(); for (let index = 0; index < sorrtedArray.length; index++) { if (sorrtedArray[index + 1] === sorrtedArray[index]) { pairResult += 1; index++ console.log(index); } } return pairResult; }El resultado de la prueba que obtuve con los dos casos de prueba fue:
console.log(duplicates([1, 2, 5, 6, 5, 2])) ====> 2
console.log(duplicates([1, 2, 2, 20, 6, 20, 2, 6, 2])); ====> 5
Sé que estaba contando 2 s tres veces, al menos eso es lo que parece. De todos modos, tenía que mirar la solución. A continuación se muestra un código que era casi idéntico al mío que funcionó.
function duplicates(array){ //Make the magic happen const newArray = array.sort((a,b) => ab); if (newArray.length <= 1) return 0; let count = 0; for (let i = 0; i < newArray.length ; i++) { if (newArray[i] == newArray[i+1]) { count++; i++; } } return count; } Mi pregunta es ¿por qué estamos incrementando el i++ nuevamente dentro del bucle for cuando ya lo estábamos incrementando cuando declaramos el bucle for?
Está ahí para evitar el conteo excesivo de duplicados. Como dicen los requisitos:
Si hay más pares de cierto número, cuente cada par solo una vez. Por ejemplo: para [0, 0, 0, 0] el valor devuelto es 2 (= 2 pares de 0)
Por ejemplo, dado
[2, 2, 2]querrás contar un conjunto de pares.
Cuando se encuentra un par
for (let i = 0; i < newArray.length ; i++) { if (newArray[i] == newArray[i+1]) { count++; i++; } } ahora ha marcado ambos índices i e i + 1 ; si procedió a comparar los índices i + 1 e i + 2 en la siguiente iteración, estaría contando el elemento en i + 1 uno de más.
Al hacer i++ dentro del bucle, se asegura de pasar al siguiente elemento sin marcar, sin iterar sobre algo que ya ha marcado, para evitar el doble conteo.
Hubo un incremento para cambiar el valor del índice de valor que ya se ha emparejado. (newArray[i] == newArray[i+1]) eso significa que i+1 es igual y no es necesario probarlo.
Sugiérame cualquier cambio aquí.