11 KiB
title | localeTitle |
---|---|
Chunky Monkey | Mono grueso |
Recuerda usar Read-Search-Ask
si te atascas. Tratar de emparejar el programa y escribe tu propio código
Explicación del problema:
Nuestro objetivo para este algoritmo es dividir arr
(primer argumento) en trozos más pequeños de matrices con la longitud proporcionada por size
(segundo argumento). Hay 4 controles verdes (objetivos) que nuestro código debe aprobar para completar este algoritmo:
(['a', 'b', 'c', 'd'], 2)
se espera que sea[['a', 'b'], ['c', 'd']]
([0, 1, 2, 3, 4, 5], 3)
se espera que sea[[0, 1, 2], [3, 4, 5]]
([0, 1, 2, 3, 4, 5], 2)
se espera que sea[[0, 1], [2, 3], [4, 5]]
([0, 1, 2, 3, 4, 5], 4)
se espera que sea[[0, 1, 2, 3], [4, 5]]
Enlaces relevantes
Sugerencia: 1
Los enlaces anteriores sugieren usar Array.push()
, así que comencemos por crear primero una nueva matriz para almacenar las matrices más pequeñas que pronto tendremos como esto:
var newArray = [];
intenta resolver el problema ahora
Sugerencia: 2
A continuación necesitaremos un for loop
para pasar por arr
.
intenta resolver el problema ahora
Sugerencia: 3
Finalmente, necesitamos un método para hacer la división real y podemos usar Array.slice()
para hacerlo. La clave de este algoritmo es entender cómo un for loop
, size
, Array.slice()
y Array.push()
funcionan juntos.
intenta resolver el problema ahora
¡Alerta de spoiler!
¡Solución por delante!
Solución de código básico:
function chunkArrayInGroups(arr, size) {
var temp = [];
var result = [];
for (var 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;
}
Explicación del código:
- En primer lugar, creamos dos matrices vacías llamadas
temp
yresult
, que eventualmente devolveremos. - Our for loop loops hasta que
a
es igual o mayor que la longitud de la matriz en nuestra prueba. - Dentro de nuestro bucle, presionamos a
temp
usandotemp.push(arr[a]);
si el resto dea / size
no es igual alsize - 1
. - De lo contrario, presionamos a
temp
, presionamostemp
a la variable deresult
y reiniciamostemp
a una matriz vacía. - A continuación, si
temp
no es una matriz vacía, la presionamos para obtener elresult
. - Finalmente, devolvemos el valor del
result
.
Enlaces relevantes
Solución de código intermedio:
function chunkArrayInGroups(arr, size) {
// Break it up.
var arr2 = [];
for (var i = 0; i < arr.length; i+=size) {
arr2.push(arr.slice(i , i+size));
}
return arr2;
}
Explicación del código:
- Primero, creamos una matriz vacía
arr2
donde almacenaremos nuestros 'trozos'. - El bucle for comienza en cero, aumenta de
size
cada vez que pasa por el bucle y se detiene cuando alcanzaarr.length
. - Tenga en cuenta que este bucle for no pasa por
arr
. En su lugar, estamos utilizando el bucle para generar números que podemos usar como índices para dividir la matriz en las ubicaciones correctas. - Dentro de nuestro bucle, creamos cada fragmento utilizando
arr.slice(i, i+size)
, y agregamos este valor aarr2
conarr2.push()
. - Finalmente, devolvemos el valor de
arr2
.
Enlaces relevantes
Solución avanzada de código:
function chunkArrayInGroups(arr, size) {
// Break it up.
var newArr = [];
var i = 0;
while (i < arr.length) {
newArr.push(arr.slice(i, i+size));
i += size;
}
return newArr;
}
chunkArrayInGroups(["a", "b", "c", "d"], 2);
Explicación del código:
-
En primer lugar, creamos dos variables.
newArr
es una matriz vacía a la que enviaremos. También tenemos la variablei
configurada en cero, para usar en nuestro bucle while. -
Nuestro bucle while realiza un bucle hasta que
i
es igual o mayor que la longitud de la matriz en nuestra prueba. -
Dentro de nuestro bucle, empujamos a la
newArr
matriz mediantearr.slice(i, i+size)
. Por primera vez los bucles se verán como:newArr.push (arr.slice (1, 1 + 2))
-
Después de que presionamos a
newArr
, agregamos la variable desize
ai
. -
Finalmente, devolvemos el valor de
newArr
.
Enlaces relevantes
Código avanzado de solución 2:
function chunkArrayInGroups(arr, size) {
var newArr = [];
while (arr.length) {
newArr.push(arr.splice(0,size));
}
return newArr;
}
Explicación del código:
- En primer lugar, creamos una variable.
newArr
es una matriz vacía a la que enviaremos. - Nuestra
while
bucle de un bucle hasta que la longitud de la matriz en nuestra prueba no es 0. - Dentro de nuestro bucle, empujamos a la
newArr
matriz mediantearr.splice(0, size)
. - Para cada iteración de
while
de bucle, se eliminasize
número de elementos de la parte frontal dearr
y empuje como una matriz paranewArr
. - Finalmente, devolvemos el valor de
newArr
.
Enlaces relevantes
Código avanzado de solución 3:
function chunkArrayInGroups(arr, size) {
if (arr.length <= size){
return [arr];
}
else {
return [arr.slice(0,size)].concat(chunkArrayInGroups(arr.slice(size),size));
}
}
Explicación del código:
- La matriz más pequeña que el tamaño se devuelve anidada.
- Para cualquier matriz más grande que el tamaño, se divide en dos. El primer segmento está anidado y concatnado con el segundo segundo segmento que hace una llamada recursiva.
Enlaces relevantes
NOTAS PARA LAS CONTRIBUCIONES:
- NO agregue soluciones que sean similares a las soluciones existentes. Si cree que es similar pero mejor , intente fusionar (o reemplazar) la solución similar existente.
- Agregue una explicación de su solución.
- Categorice la solución en una de las siguientes categorías: Básica , Intermedia y Avanzada .
- Agregue su nombre de usuario solo si ha agregado algún contenido principal relevante . ( NO elimine ningún nombre de usuario existente )
Ver
Wiki Challenge Solution Template
para referencia.