Aquí está mi matriz:
const sorted = [ { pwr: 10 }, { pwr: 9 }, { pwr: 9 }, { pwr: 8 }, { pwr: 6 }, { pwr: 6 }, { pwr: 2 }, { pwr: 2 }, { pwr: 1 }, ];Lo que quiero hacer es dividirlo en tres matrices separadas de manera que el valor total de pwr en cada matriz sea el valor más cercano a las otras matrices.
Por ejemplo, esta no es una división justa en absoluto:
arr1: [ { pwr: 10 }, { pwr: 9 }, { pwr: 9 }] arr2: [ { pwr: 8 }, { pwr: 6 }, { pwr: 6 }] arr3: [ { pwr: 2 }, { pwr: 2 }, { pwr: 1 }]Dado que el valor total de arr1 es 10+9+9 = 28 , mientras que arr2 es 20 y arr3 es solo 5 .
La matriz dividida debería ser algo como esto:
arr1: [ { pwr: 10 }, { pwr: 6 }, { pwr: 1 }] arr2: [ { pwr: 9 }, { pwr: 6 }, { pwr: 1 }] arr3: [ { pwr: 9 }, { pwr: 8 }, { pwr: 2 }] arr1 =17 arr2=16 arr3=19 which is somehow fair.Mi sugerencia es elegir de la primera matriz (que está ordenada de forma predeterminada) de esta manera:
En la primera etapa, arr1 obtiene el primer elemento (índice0) y arr2 obtiene los segundos elementos (índice1), y arr3 obtiene 2 elementos (índice 2 e índice3):
arr1[{pwr: 10}] arr2[{pwr: 9}] arr3[{pwr:8},{pwr:6}]Luego, a partir de ahora, cada matriz obtiene solo un elemento hasta que finaliza el elemento ordenado. Quiero decir que volvemos a arr1 y le damos el siguiente elemento (índice4), luego arr2 obtiene (índice5) arr3 (índice6) nuevamente arr1 (índice7) y...
¿Tienen alguna idea para lograr arreglos más justos? ¿Podrían proporcionarme fragmentos?
He echado un vistazo al problema y se me ocurrió la siguiente solución. Creo que se puede hacer mucho mejor, pero creo que funciona. El código de abajo fragmenta la matriz ordenada en fragmentos del tamaño 3 si es posible. Luego encuentra la matriz con la suma más baja y le agrega el objeto con el mayor valor de potencia. Eso va hasta que no haya entradas ordenadas a la izquierda. Las matrices finales están en el objeto de matrices y no son independientes.
let sorted = [ { pwr: 10 }, { pwr: 9 }, { pwr: 9 }, { pwr: 8 }, { pwr: 6 }, { pwr: 6 }, { pwr: 2 }, { pwr: 2 }, { pwr: 1 }, { pwr: 1} // <- this was added to test if it works if no even chunks are possible ]; const getSum = (a) => { return a.reduce((acc, value) => { if (!value) return acc + 0; return acc + value.pwr; }, 0); } const chunk = (array, size = 1) => { let chunks = []; let chunk = []; for (let i = 0; i < array.length; i++) { chunk.push(array[i]); if ((i + 1) % size === 0) { chunks.push(chunk); chunk = []; }; }; if (chunk.length !== 0) { chunks.push(chunk); }; return chunks; }; let arrays = { arr1: [], arr2: [], arr3: [] } sorted = chunk(sorted, 3); sorted.forEach((chunk) => { let a = []; Object.keys(arrays).forEach((arr) => { a.push({ name: arr, value: getSum(arrays[arr]) }); }); a.sort((a, b) => { return a.value - b.value; }); for (let i = 0; i < a.length; i++) { if (chunk[i]) { arrays[a[i].name].push(chunk[i]); } }; }); // this just outputs the result console.log(arrays); Object.keys(arrays).forEach((key) => { console.log(getSum(arrays[key])); }); .as-console-wrapper { min-height: 100%!important; top: 0; }