var arr = [1, 2, 2, 4, 4]将返回[2, 2, 4, 4]。而[1, 2, 3]将返回[]，因为所有元素都是唯一的。我认为需要检查数组中的每个元素与其他元素是否相同，但不确定如何进行操作。Array#map计算值并使用Array#forEach计数。Array#filter并检查计数。1，返回true（将项目包含在结果集中），否则返回false（不要将项目包含在结果集中）。
function getNotUnique(array) {
var map = new Map();
array.forEach(a => map.set(a, (map.get(a) || 0) + 1));
return array.filter(a => map.get(a) > 1);
}
console.log(getNotUnique([1, 2, 2, 4, 4]));
console.log(getNotUnique([1, 2, 3] ));Map，然后取出原始数组中每个计数大于一的值。 - Alnitakfunction removeUnique(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
var count = 0;
for (var j = 0; j < arr.length; j++) {
if (arr[j] == arr[i]) {
count++;
}
}
if (count >= 2) {
newArr.push(arr[i]);
}
}
return newArr;
}
console.log(removeUnique([1, 2, 2, 4, 4]));indexOf调用无效 - 括号放错了位置。而且，即使它有效，也会通过使其仅返回原始数组中每个非唯一值的一个条目来破坏代码。这是一个不必要的测试，它使得此代码的时间复杂度为O(n^3)，而使用Map可以将其优化到O(n)，甚至更低。 - Alnitakvar arr = [1, 2, 2, 4, 4],
unq = arr.map((e,i,a) => a.filter(f => f === e ).length)
.reduce((p,c,i) => c === 1 ? p : p.concat(arr[i]) ,[]);
console.log(unq);然而，仔细考虑后，以下方式可能更易读且更高效。实际上，我们正在利用JS中的一种罕见情况，通过短路运算实现惰性计算。
var r = [1,2,2,4,4].filter((e,i,a) => a.lastIndexOf(e) != i || a.indexOf(e) != i);
console.log(r);a.indexOf(e) != i部分仅对唯一元素和最后遇到的非唯一元素运行。很酷。function removeUnique(arr) {
var counts = {}
for(var i = 0; i< arr.length; i++) {
var num = arr[i]
counts[num] = counts[num] ? counts[num]+1 : 1
}
var result = []
for(var key in counts) {
if(Object.prototype.hasOwnProperty.call(counts, key) && counts[key] > 1 {
result.push(key)
}
}
return result
}
var arr = [1, 2, 3]
var arr2 = [1, 1, 2, 2, 4, 6, 4]
console.log(removeUnique(arr)) // []
console.log(removeUnique(arr2)) // [ '1', '2', '4' ]
var arr = [1,2,3,4,4];
var temp = [];
var to_keep = [];
for(var x = 0; x < arr.length; x++){
if(temp.indexOf(arr[x]) > -1) {
if(to_keep.indexOf(arr[x]) == -1)
to_keep.push(arr[x]);
} else if(temp.indexOf(arr[x]) == -1) temp.push(arr[x]);
}
for(var y = 0; y < arr.length; y++){
if(to_keep.indexOf(arr[y]) == -1){
arr.splice(y,1);
y--;
}
}
// arr = [4,4];
遍历数组，使用值作为索引进入对象并在原始数据中每次出现时递增。然后遍历对象并提取那些总数大于一的元素。适用于字符串和数字类型。
function dupsOnly(a) {
var T = {};
for (var i = 0; i < a.length; i++) {
if (a[i] in T)
T[a[i]] += 1;
else
T[a[i]] = 1;
}
var D = [];
for (var t in T) {
if (T[t] > 1)
D.push(t);
while (T[t] > 1) {
T[t] -= 1;
D.push(t);
}
}
return D;
}
var arr = [1, 2, 2, 4, 4]
var dict_with_count = {}
for (var i=0; i<arr.length; i++){
dict_with_count[arr[i]] = 0
}
for (var i=0; i<arr.length; i++){
dict_with_count[arr[i]] += 1
}
var new_list = [];
for (key in dict_with_count){
if (dict_with_count[key] > 1){
for (var j=0; j<dict_with_count[key]; j++){
new_list.push(key)
}
}
}
console.log(new_list)
#include <stdio.h>
int main() {
int n;
printf("Enter the length of the array: ");
scanf("%d", &n);
int array[n];
int frequency[1000] = {0}; // Assuming element range from 0 to 999
printf("Enter the elements of the array:\n");
for (int i = 0; i < n; i++) {
scanf("%d", &array[i]);
frequency[array[i]]++;
}
int newSize = 0;
// Remove unique elements directly in the original array
for (int i = 0; i < n; i++) {
if (frequency[array[i]] > 1) {
array[newSize] = array[i];
newSize++;
frequency[array[i]] = 0; // Mark as copied
}
}
printf("Array after deleting unique elements:\n");
for (int i = 0; i < newSize; i++) {
printf("%d ", array[i]);
}
return 0;
}