Сократить несколько матриц до одной матрицы и выполнить добавление стоимости - PullRequest
Новая
       8

Сократить несколько матриц до одной матрицы и выполнить добавление стоимости

0 голосов
/ 15 сентября 2018

У меня есть список (массив) матриц в структуре данных, например: 

const data = [
  {
    matrix: {
      rows: {
        ROW1: {
          cols: {
            COL1: "4",
            COL2: "2"
          }
        },
        ROW2: {
          cols: {
            COL1: "1",
            COL2: "4"
          }
        },
        ROW3: {
          cols: {
            COL1: "2",
            COL2: "1"
          }
        }
      }
    },
  },
  {
    matrix: {
      rows: {
        ROW1: {
          cols: {
            COL1: "1",
            COL2: "6"
          }
        },
        ROW2: {
          cols: {
            COL1: "2",
            COL2: "3"
          }
        },
        ROW3: {
          cols: {
            COL1: "5",
            COL2: "2"
          }
        }
      }
    }
  }
];

Я хотел бы суммировать значения, определенные в одной и той же паре ROW: COL, и получить одну матрицу, например: 

const newMatrix = {
  rows: {
    ROW1: {
      cols: {
        COL1: "5",
        COL2: "8"
      }
    },
    ROW2: {
      cols: {
        COL1: "3",
        COL2: "7"
      }
    },
    ROW3: {
      cols: {
        COL1: "7",
        COL2: "3"
      }
    }
  }
};

Я не знаю заранее, сколько матриц я могу получить в массиве данных. Я также не знаю заранее, сколько строк и столбцов я получаю.

Я начал с того, что вызвал Reduce () для данных, но застрял, потому что не могу придумать, как найти и затем суммировать данные в ROW: COL пары с одинаковым именем. 

const newMatrix = data.reduce(( accumulator, current ) => {
  let newMatrix;
  // ...???
  // find? forEach? Object.entries? for loops? maps inside maps? 
  // Everything I tried failed
  return newMatrix;
});

Я также возился с forEach (), Object.values ​​(), find () и всевозможными циклами for внутри других циклов, но сам продолжаю попадать в какой-то цикл мозга.

Я понимаю, что этого может быть недостаточно для работы, но я новичок в программировании и не знаю, куда идти дальше.

Я застрял на этой самой проблеме 2,5 дня, поэтому даже если бы не было предложено прямого решения, я был бы признателен за любые советы или указания в правильном направлении.

К сожалению, у меня нет сверстников, к которым я могу обратиться за помощью.

Спасибо.

Ответы [ 3 ]

0 голосов
/ 16 сентября 2018

Поскольку номер строки и столбца не является статическим, будет применена рекурсивная функция для получения суммы без использования имени свойства столбца или строки.

const data = [{
    matrix: {
      rows: {
        ROW1: {
          cols: {
            COL1: "4",
            COL2: "2"
          }
        },
        ROW2: {
          cols: {
            COL1: "1",
            COL2: "4"
          }
        },
        ROW3: {
          cols: {
            COL1: "2",
            COL2: "1"
          }
        }
      }
    },
  },
  {
    matrix: {
      rows: {
        ROW1: {
          cols: {
            COL1: "1",
            COL2: "6"
          }
        },
        ROW2: {
          cols: {
            COL1: "2",
            COL2: "3"
          }
        },
        ROW3: {
          cols: {
            COL1: "5",
            COL2: "2"
          }
        }
      }
    }
  }
];

var result = {};
var sum = function(from, to) {

  var keys = Object.keys(from);

  for (let i = 0; i < keys.length; i++) {
    if (to[keys[i]] === undefined) {
      to[keys[i]] = from[keys[i]];
    } else {
      if (typeof from[keys[i]] === "object") {
        sum(from[keys[i]], to[keys[i]])
      } else {
        to[keys[i]] = parseInt(from[keys[i]]) + parseInt(to[keys[i]]);
      }
    }
  }
};


for (index in data) {
  sum(data[index], result);
}

console.log(result);
0 голосов
/ 16 сентября 2018

Вы можете попробовать пройтись по клавишам вашего объекта и построить окончательный результат, добавляя значения по мере продвижения. 

const data = [
    {
        matrix: {
            rows: {
                ROW1: {
                    cols: {
                        COL1: "4",
                        COL2: "2"
                    }
                },
                ROW2: {
                    cols: {
                        COL1: "1",
                        COL2: "4"
                    }
                },
                ROW3: {
                    cols: {
                        COL1: "2",
                        COL2: "1"
                    }
                }
            }
        },
    },
    {
        matrix: {
            rows: {
                ROW1: {
                    cols: {
                        COL1: "1",
                        COL2: "6"
                    }
                },
                ROW2: {
                    cols: {
                        COL1: "2",
                        COL2: "3"
                    }
                },
                ROW3: {
                    cols: {
                        COL1: "5",
                        COL2: "2"
                    }
                }
            }
        }
    }
];

const sumMatrices = (array) => {

    const summed = { matrix: { rows: {} }};

    array.forEach((item) => {

        Object.keys(item.matrix.rows).forEach((row) => {

           if (!summed.matrix.rows[row]) summed.matrix.rows[row] = { cols: {} };

           Object.keys(item.matrix.rows[row].cols).forEach((col) => {

               if (!summed.matrix.rows[row].cols[col]) summed.matrix.rows[row].cols[col] = 0;

               summed.matrix.rows[row].cols[col] += +item.matrix.rows[row].cols[col];
           });
       });
    });

    return summed;
};  

console.log(sumMatrices(data));
0 голосов
/ 16 сентября 2018

Вы должны сделать это в обратном порядке, то есть цикл для столбцов, затем строк, а затем матриц.Следующий код имеет подробное решение. 

    function sumMatrices(data)
    {
        // if data empty or has missing fileds, return null
        if(
            !data || 
            !data[0].matrix.rows ||
            !data[0].matrix.rows.ROW1.cols ||
            data.length == 0 || 
            Object.keys(data[0].matrix.rows).length == 0 ||
            Object.keys(data[0].matrix.rows.ROW1.cols).length == 0)
        {
            return null; 
        }
    
        // else sum and return the result matrix
        else
        {
            // Get matrix, row, and column counts
            let numOfMatrices =  data.length;
            let numOfRows = Object.keys(data[0].matrix.rows).length;
            let numOfCols = Object.keys(data[0].matrix.rows.ROW1.cols).length;
    
            // Copy matrix structure 
            let result = JSON.parse(JSON.stringify(data[0]));
    
            // Fields base names to be addressed
            let rowWord = 'ROW';
            let colWord = 'COL';
    
            // Loop in reverse: columns -> rows -> matrices 
            for (colNum = 1; colNum < numOfCols+1; colNum++){
                let currentCol = colWord + colNum;

                for (rowNum=1; rowNum<numOfRows+1; rowNum++){
                    let currentRow = rowWord + rowNum;
                    let sum = 0;

                    for (matrixNum = 0; matrixNum < numOfMatrices; matrixNum++) {
                        sum += parseInt(data[matrixNum].matrix.rows[currentRow].cols[currentCol]);
                    }
                    result.matrix.rows[currentRow].cols[currentCol] = "" + sum;
                }
            }
            console.log(result);
            return result;
        }
    }   
    
    
    const data = [
    {
      matrix: {
        rows: {
          ROW1: {
            cols: {
              COL1: "4",
              COL2: "2"
            }
          },
          ROW2: {
            cols: {
              COL1: "1",
              COL2: "4"
            }
          },
          ROW3: {
            cols: {
              COL1: "2",
              COL2: "1"
            }
          }
        }
      },
    },
    {
      matrix: {
        rows: {
          ROW1: {
            cols: {
              COL1: "1",
              COL2: "6"
            }
          },
          ROW2: {
            cols: {
              COL1: "2",
              COL2: "3"
            }
          },
          ROW3: {
            cols: {
              COL1: "5",
              COL2: "2"
            }
          }
        }
      }
    }
  ];

   sumMatrices(data);
...