我正在尝试计算数组中所有重复项的总和。例如：
duplicate([1,1,2,3,3]) --> 应该返回 8。
我编写了以下函数来使用 JavaScript 计算数组中重复项的总和。目前它正在返回一个数组，其中重复的数组比数组中的数组少一个。
function duplicate(arr) {
var sum = 0;
arr.sort();
var stack = [];
for(var i = 0; i < arr.length; i++){
if (arr[i] === arr[i+1]) {
stack.push(arr[i])
}
}
return stack;
}
console.log(duplicate([1,2,1,2,2,3,3]))
这是返回 [ 1, 2, 2, 3 ]
如何获得正确的数组并计算正确的总和？我必须为此使用 Object 吗？
【问题讨论】：
标签： javascript arrays
这是一种使用单个Array.reduce 的方法，仅此而已。没有Array.indexOf 或Array.lastIndexOf。尽管它可能不那么简洁，但它不会遍历数组多次查找索引，也没有任何Array.filter:
const sumDubs = arr => arr.reduce((r,c) => {
if(r[c]) {
r[c] += 1
r.sum += r[c] > 2 ? (r[c]*c) - ((r[c]-1)*c) : r[c]*c
} else r[c] = 1
return r
}, { sum: 0 }).sum
console.log(sumDubs([1, 1, 2, 3, 3])) // 8
console.log(sumDubs([1, 2, 1, 2, 2, 3, 3])) // 14
console.log(sumDubs([1, 2, 1, 2, 2, 3, 3, 3, 1, 2, 4, 4])) // 28我们的想法是通过Array.reduce 的累加器中的一个属性来跟踪正在进行的总和，并简单地根据重复的数字以及更重要的次数来计算总和。
【讨论】：
虽然我对 JavaScript 了解不多，但如果我是你，我会简单地保留一个临时数组，它复制所有重复的变量，然后使用该数组进行求和。 此外，如果您想添加特定数字的次数，我会建议创建一个类似于稀疏矩阵中的表 然后在添加过程中引用它。 这种逻辑虽然不节省空间，但很容易实现。
【讨论】：
Array.reduce() 和 Array.lastIndexOf() 将轻松解决您的问题。
function sum(arr)
{
return arr.reduce(function(sum, item){
return arr.lastIndexOf(item)!==arr.indexOf(item) ? sum+=item : sum;
},0)
}
console.log(sum([1,1,2,3,3]));
console.log(sum([1,2,3,4]));
console.log(sum([1,2,2,3,4]));
console.log(sum([1,1,2,2,3,3,4,4]));【讨论】：
您可以稍微修改一下您原来的排序方法：
if (arr[i] === arr[i + 1] || arr[i] === arr[i - 1])
也就是说，检查排序数组中的前一个或下一个元素是否等于当前元素，以使其符合重复条件。
以下解决方案使用filter 和reduce 完成此操作：
function duplicate(array) {
return array
.sort((a, b) => a - b)
.filter((a, i, arr) => (arr[i] === arr[i + 1] || arr[i] === arr[i - 1]))
.reduce((a, b) => a + b, 0);
}
console.log(duplicate([1, 1, 2, 3, 3]));
console.log(duplicate([1, 2, 1, 2, 3, 3]));【讨论】：
问题是您正在将值与数组中的下一个值匹配，在已经排序的数组中它将起作用，但在未排序的数组中则不行。所以尝试先对数组进行排序，然后再运行你的代码。
编辑： 貌似代码里加了排序，
但另一个条件 => 如果有重复超过两次的数字，则应该处理它并且只在堆栈中出现一次，如果需要的话。
这将：console.log(duplicate([1,2,1,2,2,3,3]))
结果如下：[1,2,3]
function duplicate(arr) {
var sum = 0;
arr.sort();
var stack = [];
for(var i = 0; i < arr.length; i++){
if (arr[i] === arr[i+1]) {
if(stack.length == 0 || (arr[i] != stack[stack.length-1])){
stack.push(arr[i])
}
}
}
return stack;
}
【讨论】：
for被执行之前已经对代码进行了排序。
试试这个
const arr = [1,1,2,3,3]
let dup = arr.filter((value, index)=>{
// creating a copy of main array
let copyarr = [].concat(arr)
// removing present value
copyarr.splice(index,1)
// after removing present value, if you still
// get the value in copied array that means
// it has duplicates
if(copyarr.indexOf(value)>-1){
return true
}
return false
})
// now add it using reduce
let sum = dup.reduce((acc, value)=> acc+value,0)
console.log(sum)
复制以上代码并粘贴到 chrome devTool 中。你会得到答案的。
【讨论】：
首先创建一个对象，其中键是整数，值是出现次数。然后如果出现次数大于 1 ，则将次数乘以出现次数。
function duplicate(arr) {
let dupVal = 0;
let k = arr.reduce((acc, curr, index) => {
if (acc[curr] === undefined) {
acc[curr] = 1
} else {
acc[curr] += 1;
}
return acc
}, {});
for (let keys in k) {
if (k[keys] > 1) {
dupVal += parseInt(keys, 10) * k[keys]
}
}
return dupVal;
}
console.log(duplicate([1, 2, 1, 2, 2, 3, 3]))【讨论】：
您可以使用JS Array.reduce 方法以更短的方式完成您的要求
function sumDplicates(arr) {
return arr.reduce(function(tot, val, index, _arr) {
if (_arr.lastIndexOf(val) > index || _arr.indexOf(val) != index)
return tot + val;
return tot
}, 0)
}
console.log(sumDplicates([1, 1, 2, 3, 3]));
console.log(sumDplicates([1, 2, 1, 2, 2, 3, 3]));【讨论】：
为了使逻辑更简单，您可以通过检查数组中的indexOf 是否等于数组中的lastIndexOf 来filter 排除非重复项：
function duplicate(arr) {
const duplicates = arr.filter(elm => arr.indexOf(elm) !== arr.lastIndexOf(elm));
return duplicates.reduce((a, b) => a + b);
}
console.log(duplicate([1,1,2,3,3])); // --> should return 8.
console.log(duplicate([1,2,1,2,2,3,3]));【讨论】：