Javascript从数组元素求和的条件中获取数组元素

Question

我有一个数组，arr =[2,4,8,7,3,6]当结果为10时，我想使它的每个元素都是求和，然后保存元素，它将被安排到另一个数组。

使结果为10的元素像2和8一样彼此靠近，添加到另一个名为arr2的元素。

result I need: arr2[2,8,3,7,4,6]

my code:

const arr = [2, 4, 8, 7, 3, 6];
let arr2 = [];
for (let i = 0; i < arr.length(); i++) {
let Number1 = arr[i];
let Number2 = arr[(i + 1)];
if (Number1 + Number2 === 10) {
let element1 = arr.indexOf(Number1);
let element2 = arr.indexOf(Number2);
arr2.push(element1, element2);
}
console.log(arr2[i]);
}

有人能解决我的问题吗?

Answer 1

如果您需要创建arr2，以便项目总和为10，您可以在这里使用简单的map:

const arr = [2, 4, 8, 7, 3, 6];
const arr2 = arr.map((item) => 10 - item)
console.log(arr2);

Answer 2

您应该首先遍历数组以创建一个value作为索引的字典，然后再次遍历数组并查找当前值的补值以查找目标。如果它存在，那么是的，你得到了答案。

.filter(x => x > i)是搜索索引比当前索引高的补体，这样我们就不会得到重复的结果。例如输入是[2,8]，你不希望得到[2,8,8,2]

这是我的解决方案

const arr = [2, 4, 8, 7, 3, 6];
let arr2 = [];
function solution(target: number, input: number[]): number[] {
const result: number[] = [];
const lookUpMap: {[key: number]: number[]} = {};
let i = 0;
for (const each of input) {
if (!(each in lookUpMap)) {
lookUpMap[each] = [];
}
lookUpMap[each].push(i);
i++;
}
i = 0;
for (const each of input) {
const difference = target - each;
if (difference in lookUpMap) {
const complementIndex = lookUpMap[difference].filter(x => x > i)[0];

if (complementIndex) {
result.push(input[i], input[complimentingIndex]);
}
}
i++;
}
return result;
}
arr2 = solution(10, arr);
console.log(arr2);

Answer 3

假设可以为给定的arr创建有效的结果一个相当简单的解决方案是先对数组进行排序。然后遍历半个数组，取当前索引上的元素和逆索引(length - 1 - index)上的元素。和push()都在结果数组中。

那么在这里分步骤，假设你有以下数组:

[2, 4, 8, 7, 3, 6]

排序:

[2, 3, 4, 6, 7, 8]

然后遍历一半的索引并取每个元素，以及逆索引上的元素。

[2, 3, 4, 6, 7, 8]
//       /  /  /  
//      ------  /    -> [2, 8, 3, 7, 4, 6]
//     ----------    

const arr = [2, 4, 8, 7, 3, 6];
const sortedArr = Array.from(arr).sort((a, b) => a - b); // ascending
const length    = sortedArr.length;
const nPairs    = length / 2;
const arr2 = [];
for (let i = 0; i < nPairs; ++i) {
arr2.push(
sortedArr[i],
sortedArr[length - 1 - i],
);
}
// or if you want a more functional approach:
// const arr2 = Array.from({ length: nPairs }).flatMap((_, i) => [sortedArr[i], sortedArr[length - 1 - i]]);
console.log(arr2);

请注意，这可能不是最快的解决方案，因为排序是非线性的。

显然，如果给定无效输入，则此解决方案不起作用，例如[7,2,1,8]，它永远无法产生有效输出。