Remove excessive occurrences

Question

Given an array \$A\$ of positive integers between \$1\$ and \$9\$ inclusive and a positive integer \$n\$, remove all integers in \$A\$ which appear more than \$n\$ times.

For example:

             [1,2,3,2,3,2,4,1,2], n = 2
Occurrence:   1 1 1 2 2 3 1 2 4
Keep?         1 1 1 1 1 0 1 1 0
Kept values: [1,2,3,2,3,  4,1  ]

so the output is [1,2,3,2,3,4,1]

You can assume that:

• At least one element will always appear more than \$n\$ times
• At least one element will appear fewer than \$n\$ times
• \$A\$ will have a minimum of 2 distinct elements
• \$n\$ and the length of \$A\$ are within the integer bounds of your language.

You may take input and output in any convenient method. As the elements of \$A\$ are digits, you may also take input as an integer, or a single string, if that suits you.

This is code-golf so the shortest code in bytes wins

Test cases

A, n -> out
[7,3,3,9], 1 -> [7,3,9]
[4,1,7,7,4,2,1], 1 -> [4,1,7,2]
[6,9,7,6,7,9,9], 2 -> [6,9,7,6,7,9]
[6,5,3,9,4,9,6,9], 2 -> [6,5,3,9,4,9,6]
[4,8,9,7,3,1,7,5,4,6], 1 -> [4,8,9,7,3,1,5,6]
[5,6,7,8,1,7,3,3,6,4], 1 -> [5,6,7,8,1,3,4]
[2,3,8,1,6,4,8,2,8,3], 2 -> [2,3,8,1,6,4,8,2,3]
[4,1,4,4,2,4,4,5,7,1,3], 1 -> [4,1,2,5,7,3]
[1,5,5,2,5,1,4,1,6,7,7,6,9,8,8,1,7,8,1,3,1,1,7,4], 3 -> [1,5,5,2,5,1,4,1,6,7,7,6,9,8,8,7,8,3,4]
[8,8,6,2,9,6,4,7,1,2,9,5,5,6,6,2,5,8,9,1,2,8,4,4,7,2,1,1], 3 -> [8,8,6,2,9,6,4,7,1,2,9,5,5,6,2,5,8,9,1,4,4,7,1]
[8,8,4,9,7,1,2,9,8,8,5,2,2,9,1,7,4,6,6,8,6,6,1,6,1,9,2,8,5,1,2,6,1,7,6,4,7,9], 4 -> [8,8,4,9,7,1,2,9,8,8,5,2,2,9,1,7,4,6,6,6,6,1,1,9,2,5,7,4,7]
[8,8,9,2,7,4,7,5,6,9,7,2,7,7,6,2,6,9,6,3,5,1,1,6,2,8,7,4,2,4,5,9,3,3,3,3,7,4,8,7,5,4,1,4,7,8], 2 -> [8,8,9,2,7,4,7,5,6,9,2,6,3,5,1,1,4,3]
[6,8,1,8,6,9,2,2,5,8,7,6,2,5,4,3,3,1,4,2,7,1,6,3,9,8,9,5,2,6,8,8,7,7,5,2,5,1,4,7,5,5,3,7,6,3,7,6,3,6,7], 4 -> [6,8,1,8,6,9,2,2,5,8,7,6,2,5,4,3,3,1,4,2,7,1,6,3,9,8,9,5,7,7,5,1,4,3]
[1,3,5,6,1,2,8,8,8,4,4,4,5,8,9,9,6,4,5,3,8,7,9,7,8,6,1,6,1,6,4,5,5,3,9,3,5,4,2,1,6,6,5,4,2,6,2,1,1,1,5,5], 2 -> [1,3,5,6,1,2,8,8,4,4,5,9,9,6,3,7,7,2]
[9,9,9,4,6,1,5,4,5,3,7,9,8,9,8,2,9,1,3,4,9,5,8,7,8,6,1,9,9,5,1,3,1,9,5,7,3,5,9,6,6,2,2,4,1,4,2,1,7,5,3,7,9,8,2,3,1,6], 9 -> [9,9,9,4,6,1,5,4,5,3,7,9,8,9,8,2,9,1,3,4,9,5,8,7,8,6,1,9,9,5,1,3,1,5,7,3,5,6,6,2,2,4,1,4,2,1,7,5,3,7,8,2,3,1,6]
[9,6,3,5,5,2,8,2,9,6,7,9,5,3,1,1,1,3,6,9,4,3,6,9,2,2,3,7,5,3,9,5,2,1,1,1,1,6,2,2,4,6,1,5,7,3,7,9,5,3,1,2,6,4,3,1,7,9,3,8,5,2,4,2,8,2,6,7,3,9,1,7,9,4,7,4], 5 -> [9,6,3,5,5,2,8,2,9,6,7,9,5,3,1,1,1,3,6,9,4,3,6,9,2,2,3,7,5,5,2,1,1,6,4,7,7,4,7,8,4,8,4]
[7,1,8,2,2,1,4,9,8,6,5,1,9,7,5,5,8,1,7,8,6,8,5,9,3,2,7,9,4,3,9,1,5,2,5,7,8,5,2,6,6,2,7,6,2,9,3,3,5,3,7,9,8,7,3,6,7,4,6,1,4,5,8,9,8,6,9,1,1,1,8,2,4,2,9,3,4,2,9,6], 8 -> [7,1,8,2,2,1,4,9,8,6,5,1,9,7,5,5,8,1,7,8,6,8,5,9,3,2,7,9,4,3,9,1,5,2,5,7,8,5,2,6,6,2,7,6,2,9,3,3,5,3,7,9,8,7,3,6,4,6,1,4,8,9,6,1,1,2,4,3,4]
[7,2,8,9,7,5,1,4,6,8,6,9,1,8,6,2,2,6,1,1,6,8,4,5,2,6,5,5,4,5,5,3,6,8,3,7,9,3,9,8,4,9,6,7,2,7,9,2,4,8,3,3,2,5,9,1,4,6,4,8,2,5,8,6,8,1,8,3,3,9,4,8,1,1,2,9,1,9,3,3,7], 11 -> [7,2,8,9,7,5,1,4,6,8,6,9,1,8,6,2,2,6,1,1,6,8,4,5,2,6,5,5,4,5,5,3,6,8,3,7,9,3,9,8,4,9,6,7,2,7,9,2,4,8,3,3,2,5,9,1,4,6,4,8,2,5,8,6,8,1,8,3,3,9,4,1,1,2,9,1,9,3,3,7]
[7,7,6,5,9,7,2,6,1,4,4,5,4,3,1,7,5,5,8,1,6,3,9,3,3,9,5,9,1,2,4,3,8,2,6,6,5,2,8,7,5,6,5,7,3,2,5,3,5,8,6,1,9,7,4,3,9,8,2,4,5,7,8,8,2,8,1,8,7,8,7,6,3,8,6,7,9,4,6,1,6,1,2,5,6,7,7,2,8,3,2,1,7], 11 -> [7,7,6,5,9,7,2,6,1,4,4,5,4,3,1,7,5,5,8,1,6,3,9,3,3,9,5,9,1,2,4,3,8,2,6,6,5,2,8,7,5,6,5,7,3,2,5,3,5,8,6,1,9,7,4,3,9,8,2,4,5,7,8,8,2,8,1,8,7,8,7,6,3,8,6,7,9,4,6,1,6,1,2,2,3,2,1]
[3,4,1,1,2,4,4,8,4,9,1,1,7,7,6,8,6,2,9,4,2,9,9,7,5,7,6,5,3,7,6,6,1,9,1,5,2,4,9,6,1,5,4,1,7,2,4,3,8,5,1,9,5,9,1,7,4,7,3,1,2,1,3,8,7,9,2,5,1,6,2,4,5,9,1,5,5,5,2,6,3,7,2,2,5,7,6,8,3,7,5,9,3,3,9], 7 -> [3,4,1,1,2,4,4,8,4,9,1,1,7,7,6,8,6,2,9,4,2,9,9,7,5,7,6,5,3,7,6,6,1,9,1,5,2,4,9,6,1,5,4,7,2,3,8,5,9,5,7,3,2,3,8,2,5,6,3,8,3]

Test case generator. Run with no arguments to have a max length of 100 for \$A\$. For a different max length (no larger than \$891\$), run with that as an argument.

Answer 1

Haskell, 54 bytes

f n|let a?x|sum[1|y<-a,y==x]<n=a++[x]|1>0=a=foldl(?)[]

Try it online!

• I was on the right track, one big step behind @xnor answer which cost me 10 bytes!

Answer 2

Clojure, 76 bytes

#(for[[i v](map vector(range)%1):when(<(count(filter #{v}(take i %1)))%2)]v)

Try it online!

Answer 3

SNOBOL4 (CSNOBOL4), 87 bytes

	N =INPUT
	T =TABLE()
R	I =INPUT	:F(END)
	T<I> =T<I> + 1
	OUTPUT =I LE(T<I>,N)	:(R)
END

Try it online!

Takes input as N, then A, each element separated by newlines.

	N =INPUT			;* Read in N, number to keep
	T =TABLE()			;* create an empty table
R	I =INPUT	:F(END)		;* read in the next input; if none exists, exit
	T<I> =T<I> + 1			;* increment the value at index I (initially 0)
	OUTPUT =I LE(T<I>,N)	:(R)	;* if T<I> is LEQ to N, then output I. Goto R.
END

Answer 4

Wolfram Language (Mathematica), 31 28 bytes

nFold[#||Count@##<n&&#2&]

Try it online!

Returns an Or of digits. Input [n][A].

Answer 5

Python3, 66 Bytes

def f(A,n):[A.pop(-A[::-1].index(i)-1) for i in A if A.count(i)>n]

There are already superior Python answers to this, but thought it's worth a mention as it only uses list methods.

Answer 6

Java (JDK), 101 bytes

l->n->{for(int i=0,j,c;i++<9;)for(j=c=0;j<l.size();)j+=l.get(j)==i?++c>n?l.remove(j)*0:1:1;return l;}

Try it online!

Input: ArrayList<Integer>

Output: ArrayList<Integer>

Answer 7

05AB1E, 6 bytes

ʒˆ¯¤¢@

Try it online or verify all test cases.

Explanation:

ʒ       # Filter the (implicit) input-list by:
 ˆ      #  Pop and push the current value to the global array
  ¯     #  Push the global array
   ¤    #  Get its last item (without popping the list itself)
    ¢   #  Count how many times it occurs in the global array
     @  #  And check if the (implicit) input-integer is >= this count
        # (after which the filtered list is output implicitly)

Answer 8

Arturo, 48 bytes

$[a,n][o:@.of:10 0filter a'x->n<o\[x]:<=o\[x]+1]

Try it!

Explanation

$[a,n][]         ; a function taking args a and n
o:               ; to o, assign
@.of:10 0        ; an array of ten zeros
filter a'x->     ; remove elts from a with func, current elt is x
n<               ; is n less than
o\[x]:<=o\[x]+1  ; increment and return o[x]

Answer 9

Vyxal, 5 bytes

UẋfÞ∩

Try it Online!

   Þ∩ # Take the multiset intersection, preserving order, with
U     # All distinct elements of the input
 ẋf   # Repeated n times