JavaScript принимает сумму диагоналей вложенного массива с различной длиной
У меня есть вложенный массив, в котором каждый массив на единицу меньше по длине, чем предыдущий массив. Я хочу взять сумму элементов по диагонали и не могу понять, как это сделать.
Вот табличное представление того, что я пытаюсь сделать:
В JavaScript вложенный массив выглядит следующим образом:
let outArr = [];
const intArr= [0,2,4,6,8,10];
for (let i = intArr.length; i >0; i--) {
outArr.push(intArr.slice(0,i));
}
Я хочу, чтобы мой массив результатов был [0,2,6,12,20,30]. Использую ли я тройной вложенный цикл? Один для выходного массива, а затем два цикла для внутреннего/внешнего массива?
![Безумие обратных вызовов в javascript [JS]](https://i.imgur.com/WsjO6zJb.png)
Ответы 6
const array1 = [ 0, 2, 4, 6, 8, 10 ];
const array2 = [ 0, 2, 4, 6, 8 ];
const array3 = [ 0, 2, 4, 6 ];
const array4 = [ 0, 2, 4 ];
const array5 = [ 0, 2 ];
const array6 = [ 0 ];
const sum0 = array1[0];
const sum1 = array1[1] + array2[0];
const sum2 = array1[2] + array2[1] + array3[0];
const sum3 = array1[3] + array2[2] + array3[1] + array4[0];
const sum4 = array1[4] + array2[3] + array3[2] + array4[1] + array5[0];
const sum5 = array1[5] + array2[4] + array3[3] + array4[2] + array5[1] + array6[0];
const result = [
sum0,
sum1,
sum2,
sum3,
sum4,
sum5 ];
console.info(result);- Получить последние элементы массива, в первый индекс вставить первый в массив результатов, а из следующего индекса добавить последнее вставленное значение из результата и текущего значения.
function getDiagonalSum(arr) {
const lastArrays = [];
const result = [];
arr.forEach(currentArray => {
lastArrays.push(currentArray[currentArray.length - 1]);
});
for (let i = 0; i < lastArrays.length; i++) {
if (i === 0) {
result.push(lastArrays[i])
} else {
let total = lastArrays[i] + result[i - 1];
result.push(total);
}
}
return result;
}
const arr = [
[1, 2, 3],
[1, 2],
[1]
];
const result = getDiagonalSum(arr);
console.info(result);
console.info("Your array input...")
const userArray = [
[0, 0, 0, 0, 0, 0],
[2, 2, 2, 2, 2],
[4, 4, 4, 4],
[6, 6, 6],
[8, 8],
[10]
];
const userResult = getDiagonalSum(userArray);
console.info(userResult);Вы можете выполнить итерацию по массиву один раз, отслеживая текущую совокупную сумму и добавляя ее в массив на каждой итерации. (Обратите внимание, что диагональные суммы здесь — это просто суммы префиксов массива.)
let outArr = [];
const intArr= [0,2,4,6,8,10];
let curr = 0;
for (const x of intArr) outArr.push(curr += x);
console.info(outArr);Для более общего случая диагональных сумм вы можете использовать вложенный цикл следующим образом:
let arr = [[0, 1, 2, 3],[0, 0, 2],[1, 2],[0]];
let res = [];
for (let i = arr.length - 1; i >= 0; i--) {
let sum = 0;
for (let j = 0; j < arr.length - i; j++) sum += arr[j][arr[j].length - 1 - i];
res.push(sum);
}
console.info(res);Будет ли это также работать, если вложенные массивы не имеют одинаковых значений, но имеют один и тот же шаблон длины? Например [[0,1,2,3],[0,0,2],[1,2],[0]]? Извините, я должен уточнить это в своем вопросе. Спасибо за это элегантное решение.
@Yolo_chicken Я обновил свой ответ для общего случая.
В основном вам нужно получить индексы, которые дают вам диагональные значения. Держите два счетчика и увеличивайте один и уменьшайте один и делайте это в пределах границ для каждой итерации.
Согласно вашему коду, если intArr является вложенным массивом со всеми строками, то это вернет вам диагональные суммы.
let finalArr = [];
for (let i = 0; i <intArr.length; i++) {
let temp = 0, k=i;
for(let j=0;j<=i;j++){
temp += outArr[j][k--];
}
finalArr.push(temp);
}
Существует также более простой способ сделать это, если вы не хотите работать с вложенным массивом, поскольку это, по сути, кумулятивная сумма, поэтому вам не нужен вложенный массив.
let intArr= [0,2,4,6,8,10];
let cumulative = 0, finalArr = [];;
for (let x of intArr) {
finalArr.push(cumulative += x);
}
let inputArr=[]; let sumEntry =[]
inputArray.reverse().forEach((subArr)=>{
sumEntry.push((subArr.reduce((l,r)=>l+r,0));
});
inputArray.reverse().push(sumEntry);
Вы можете сопоставить каждый элемент с суммой самого себя со всеми элементами с меньшим индексом, чем он сам.
- Используйте Array#map для выполнения сопоставления
- Используйте Array#reduce для выполнения сложения
const
intArr = [0,2,4,6,8,10],
outArr = intArr.map(
(v,i,a) => a.slice(0,i+1).reduce((a,b) => a+b)
);
console.info( outArr );В качестве альтернативы .....
Вы можете немного изменить свой код, чтобы сделать эту версию более эффективной, чем приведенная выше:
const
outArr = [],
intArr = [0,2,4,6,8,10];
for( const [i, v] of intArr.entries() ) {
outArr.push( (outArr[i-1] || 0) + v );
}
console.info( outArr );
вам нужно будет поддерживать массивы с динамическим размером? или это единственные массивы в решении? вы используете 2D-массив? можешь перечислить все свои данные? похоже, вы будете использовать 6 разных массивов.