No estoy seguro de haber descrito mejor el problema en el título, pero lo explicaré aquí.
Mi objetivo general es mantener las listas sincronizadas, actualmente estoy tratando de obtener un resultado específico para luego poder corregir la simetría de la lista.
Lo he descubierto hasta este punto:
Código:
let list2 = [ {user: 001, log: [1,2,3,4,5,6,7,8,9,10]}, {user: 002, log: [2,3,4,5,6,7,8,9, 44]}, {user: 003, log: [1,2,3,4,6,7,8]}, {user: 004, log: [1,2,3,4,5,6,7,8]} ]; for (let comparator = 0; comparator < list2.length; comparator++) { for (let index = 0; index < list2.length; index++) { if (comparator !== index) { let currentDiff = list2[comparator].log.filter(x => !list2[index].log.includes(x)); console.log("User: " + list2[index].user + " needs " + currentDiff + " from user: " + list2[comparator].user); } } }Producción:
User: 2 needs 1,10 from user: 1 User: 3 needs 5,9,10 from user: 1 User: 4 needs 9,10 from user: 1 User: 1 needs 44 from user: 2 User: 3 needs 5,9,44 from user: 2 User: 4 needs 9,44 from user: 2 User: 1 needs from user: 3 User: 2 needs 1 from user: 3 User: 4 needs from user: 3 User: 1 needs from user: 4 User: 2 needs 1 from user: 4 User: 3 needs 5 from user: 4Esto genera demasiados datos y quiero condensarlos
La salida deseada es que todos los datos estén condensados para que ninguna de las "necesidades" se repita, por lo que si, por ejemplo, el usuario n.° 2 puede obtener 1 y 10 del usuario n.° 1, entonces no hay necesidad de generar que el usuario n.° 2 necesite 1 del usuario n.° 3... ¿Me sigues? Creo que esto podría simplificarse, pero no conozco ninguna acción que pueda hacerlo fácilmente.
Esto es lo que estoy tratando de lograr como modelo de salida (idealmente):
[ {"user": 1, "symmetriseLogs": [ {user: 2, missingLogs: [1, 10]}, {user: 3, missingLogs: [5, 9, 10]}, {user: 4, missingLogs: [9, 10]}, ]}, {"user": 2, "symmetriseLogs": [ {user: 1, missingLogs: [44]}, {user: 3, missingLogs: [44]}, {user: 4, missingLogs: [44]}, ]}, ]La salida debe ser lo que se requiere para simetrizar todos los registros, por lo que en la salida de ejemplo, todo lo que falta con el usuario n. ° 1 y n. ° 2 se puede obtener entre sí, por lo tanto, el usuario n. ° 3 y n. ° 4 no obtienen salida. Además, el usuario n. ° 2 solo requiere generar 44, ya que ese es el único elemento de registro 44 que faltan otros y que no se puede obtener del usuario n. ° 1.
Un poco de una pesadilla de lógica en bucle, agradecería cualquier ayuda para resolver esto. Solo obtuve resultados más confusos tratando de lograr esto.
Un enfoque es que, antes de comenzar la iteración, puede crear una estructura duplicada que asigne a cada usuario los registros que tiene hasta el momento. Dentro del ciclo, busque los registros existentes del usuario para verificar qué números deben agregarse.
No es tan puro como se pretende que sea .map , pero hace el trabajo, y no puedo pensar en un enfoque más atractivo.
const list2 = [ {user: 001, log: [1,2,3,4,5,6,7,8,9,10]}, {user: 002, log: [2,3,4,5,6,7,8,9, 44]}, {user: 003, log: [1,2,3,4,6,7,8]}, {user: 004, log: [1,2,3,4,5,6,7,8]} ]; const haveLogsByUserId = new Map(list2.map(({ user, log }) => [user, new Set(log)])); const result = list2.map((source, i) => ({ user: source.user, symmetriseLogs: list2 .filter((_, j) => i !== j) .map(dest => { const thisUserLogs = haveLogsByUserId.get(dest.user); const missingLogs = source.log.filter(num => !thisUserLogs.has(num)); for (const num of missingLogs) thisUserLogs.add(num); return { user: dest.user, missingLogs }; }) .filter(missingObj => missingObj.missingLogs.length) })); console.log(result);¿Podrías usar algo como el siguiente código?
let list2 = [ {user: 001, log: [1,2,3,4,5,6,7,8,9,10]}, {user: 002, log: [2,3,4,5,6,7,8,9, 44]}, {user: 003, log: [1,2,3,4,6,7,8]}, {user: 004, log: [1,2,3,4,5,6,7,8]} ]; const result = [] for (let comparator = 0; comparator < list2.length; comparator++) { const withAdd = [...list2[comparator].log] result[comparator] = {user:list2[comparator].user,symmetriseLogs:[]} for (let index = 0; index < list2.length; index++) { if (comparator !== index) { const currentDiff = list2[index].log.filter(x => !withAdd.includes(x)); if (currentDiff.length) { console.log("User: " + list2[comparator].user + " needs " + currentDiff + " from user: " + list2[index].user); result[comparator].symmetriseLogs.push({user:list2[index].user, missingLogs:currentDiff}) } withAdd.push(...currentDiff) } } } console.log(result)Con su entrada obtengo el siguiente resultado:
Y:
[ { "user": 1, "symmetriseLogs": [ { "user": 2, "missingLogs": [ 44 ] } ] }, { "user": 2, "symmetriseLogs": [ { "user": 1, "missingLogs": [ 1, 10 ] } ] }, { "user": 3, "symmetriseLogs": [ { "user": 1, "missingLogs": [ 5, 9, 10 ] }, { "user": 2, "missingLogs": [ 44 ] } ] }, { "user": 4, "symmetriseLogs": [ { "user": 1, "missingLogs": [ 9, 10 ] }, { "user": 2, "missingLogs": [ 44 ] } ] } ]