Así que estaba resolviendo este desafío:
Escriba una función que divida una matriz (primer argumento) en grupos de la longitud del tamaño (segundo argumento) y los devuelva como una matriz bidimensional.
1. (['a', 'b', 'c', 'd'], 2) is expected to be [['a', 'b'], ['c', 'd']] 2. ([0, 1, 2, 3, 4, 5], 3) is expected to be [[0, 1, 2], [3, 4, 5]] 3. ([0, 1, 2, 3, 4, 5], 2) is expected to be [[0, 1], [2, 3], [4, 5]] 4. ([0, 1, 2, 3, 4, 5], 4) is expected to be [[0, 1, 2, 3], [4, 5]]Se me ocurrió esa solución:
function chunkArrayInGroups(arr, size) { let result = []; for (let i = 0; i < arr.length; i += size){ result.push(arr.slice(i, i + size)); } return result; }También estaba interesado en alguna otra solución posible y encontré esa:
function chunkArrayInGroups(arr, size) { let temp = []; let result = []; for (let a = 0; a < arr.length; a++) { if (a % size !== size - 1) temp.push(arr[a]); else { temp.push(arr[a]); result.push(temp); temp = []; } } if (temp.length !== 0) result.push(temp); return result; }No entiendo el punto en la condición IF con el resto. Básicamente entiendo cómo funciona el módulo, pero no entiendo cómo funcionaría aquí para ese desafío. ¿Podría por favor alguien explicármelo? ¡Gracias!
Si la longitud de la matriz no es divisible por el tamaño del grupo, agregue el último grupo a la matriz de resultados.
Si la longitud de la matriz es divisible por el tamaño del grupo, entonces no necesita agregar el último grupo a la matriz de resultados.
En lugar de usar su enfoque (definitivamente más eficiente y también más claro) de tomar porciones consecutivas, esto toma la matriz elemento por elemento, almacenando el siguiente grupo que se agregará en una matriz temporal. La prueba básicamente pregunta (con una extraña prueba negativa) "¿Este índice no es el último del grupo?" Si esa condición es verdadera y no estamos en la última para el grupo actual, simplemente agregamos al grupo temporal. Si es falso y estamos en el último, agregamos al grupo temporal, agregamos el grupo temporal a nuestra salida y creamos un nuevo grupo temporal.
Con un poco de refactorización, podemos hacer esto más limpio, tal vez algo como esto:
function chunkArrayInGroups(arr, size) { const result = [] let temp = [] for (let a = 0; a < arr .length; a ++) { temp .push (arr [a]) if (a % size === size - 1) { result .push (temp) temp = [] } } if (temp .length > 0) result .push (temp) return result }Pero esto no tiene ventajas sobre su enfoque y definitivamente es menos eficiente. Así que no lo consideraría.
Aquí hay una alternativa que, en mi opinión, es más limpia, pero también menos eficiente que la tuya:
const chunk = (xs, n) => xs .length <= n ? [[...xs]] : [xs .slice (0, n)] .concat (chunk (xs .slice (n), n)) Este toma el primer grupo cortándolo desde el principio de la matriz y concatena los resultados de llamarse recursivamente a sí mismo con el resto de la matriz. La recursión finaliza cuando quedan como máximo n elementos, y luego devolvemos una matriz que contiene solo una copia de nuestra matriz de entrada ( [[...x]] ). Hacemos la copia porque todos los demás resultados son copias y no referencias, y es mejor ser consistente.
Esto es similar a su enfoque en términos de número de segmentos y pruebas, pero debido a la naturaleza recursiva, fallará para arreglos muy grandes y las llamadas repetidas lo harán algo menos eficiente. A menudo estoy dispuesto a aceptar esa compensación por un código más limpio, yo mismo, pero YMMV.
Y tal vez también esté interesado en otra solución basada en bucles:
const a=[...Array(23)].map((_,i)=>i); function split(a,n){ return[...Array(Math.ceil(a.length/n))].map((_,i)=>a.slice(i*n,(i+1)*n)); } for (let n=2;n<13;n++) // try subdivisions from n=2 to n=13 console.log(split(a,n));