Delete occurrences of an element if it occurs more than n times

Question

i'm trying to create a function that gives me an array of numbers with a limitation of repetition for each number. for example

([1,1,3,3,7,2,2,2,2], 3)

should give me

[1, 1, 3, 3, 7, 2, 2, 2]

it deletes a [2] because the max repetition of numbers is 3.

here is my code but i don't know why it doesn't work:

function deleteNth(arr,n){
  var results = [];
  for(var i=0; i<arr.length; i++){
  if (count(results, arr[i])<=n) {
    results.push(arr[i]);
  }
}
return results;
}
function count(array, what){
  var count =0;
  for (var i=0; i<array.length; i++){
    if (array[i]===what){
      count++;
    }
  }
  return count;
}
console.log(deleteNth([1,1,3,3,7,2,2,2,2], 3));

you have an off by one error, should be `count(results, arr[i]) < n` — dhuang, Mar 07 '18 at 04:55
Is your maximum for total occurrences, or for consecutive occurrences? In other words, if you had [2, 2, 1, 3, 2, 2], and set a max of 3 repetitions, should the last 2 be thrown out or not? — kshetline, Mar 07 '18 at 04:55
i don't care about preserving the order. and by max i mean the maximum for total occurrences and not for consecutive occurrences. — Sur Khosh, Mar 07 '18 at 05:06
yes aznbanana9 you are right! and thank you all for your answers! — Sur Khosh, Mar 07 '18 at 05:12

score 8 · Answer 1 · answered Mar 07 '18 at 05:16

8

i also found this :

function deleteNth(arr,x) {
  var cache = {};
  return arr.filter(function(n) {
    cache[n] = (cache[n]||0) + 1;
    return cache[n] <= x;
  });
}

answered Mar 07 '18 at 05:16

Sur Khosh

115
1
8

2

I like this even more than my own answer; More terse but still readable. – nicholaswmin Mar 07 '18 at 05:35

nicholaswmin · Accepted Answer · 2018-03-07T05:05:12.607

I would use a reduce to iterate over all elements of the array and a dictionary to keep track of the number of times I found an element.

Here's an example:

const filterReps = (arr, maxReps) => {
  return arr.length ? arr.reduce((acc, num, i) => {
    // Add this number to our dictionary,
    // if already present add +1 to it's count
    acc.found[num] = acc.found[num] ? ++acc.found[num] : 1

     // If the dictionary says the number has been found less or equal
     // times to our max repetitions, push it into the accumulating array
    if (acc.found[num] <= maxReps)
      acc.arr.push(num)

    // If this is the final iteration, just return only the result array
    // and not the dictionary
    return i === nums.length - 1 ? acc.arr : acc
  }, { found: {}, arr: [] }) : arr
}

const nums = [1, 1, 1, 1, 2, 2, 2, 2]
console.log(filterReps(nums, 3))

score 1 · Answer 3 · answered Mar 31 '22 at 09:01

1

onece more

let deleteNth = function func(arr,n){ 
    for (let i=0; i<= arr.length; i++){ 
        while( arr.filter( (item) => item == arr[i]).length > n ){ 
           arr.splice(arr.lastIndexOf(arr[i]),1); 
        }
    }
    return arr;
}

answered Mar 31 '22 at 09:01

GROL COON

43
5

score 0 · Answer 4 · answered Mar 07 '18 at 05:07

You can make this a bit simpler by using just a single function. Here's an example of how it could be done:

function dn(arr,n){
  results = {};
  for(var i=0; i<arr.length; i++){
    if(!results[arr[i]]){
      results[arr[i]] = 1;
    }else if(results[arr[i]] + 1 <= n){
      results[arr[i]]++
    }
  }
  data = []
  Object.keys(results).forEach(function(key){
    for(i=0; i<results[key]; i++){
      data.push(key);
    }
  });
  return data;
}

score 0 · Answer 5 · answered Mar 07 '18 at 05:22

Try this one, I think this may help you too.

function removeMoreDups(your_array, limit) {
  new_arr = [];
  var counts = {};
  your_array.forEach(function(x) {
    counts[x] = (counts[x] || 0)+1;
    if (counts[x] <= limit) {
     new_arr.push(x);
    }
  });
  return new_arr;
}

your_array = [1,1,3,3,7,2,2,2,2];
limit = 3;
new_arr = removeMoreDups(your_array, limit);
console.log(new_arr);

score 0 · Answer 6 · answered Feb 25 '20 at 08:34

var itemCounter = ((char, tab) => tab.filter((tabItem) => (tabItem === char)).length);

function deleteNth(arr,n){
  var tempTab = [];
  arr.forEach((item) => {
    if(itemCounter(item,tempTab) < n) 
      tempTab.push(item);
  });
  return tempTab;
}

Delete occurrences of an element if it occurs more than n times

6 Answers6