# Remove excessive occurrences

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 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.

• Brownie points for beating my 8 byte Jelly answer Commented Feb 24, 2021 at 0:11
• @manatwork Yeah, you can take input in either order Commented Feb 24, 2021 at 0:19
• I like how well thought and friendly this challenge is: no corner cases with empty arrays; values are single-digit positive integers so more esolangs can participate Commented Feb 24, 2021 at 1:05
• @LuisMendo I like "Remove excessive repetitions", changed to that :) Commented Feb 24, 2021 at 1:14
• Correction: brownie points for beating 6 bytes in Jelly Commented Feb 24, 2021 at 1:18

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!

# Clojure, 76 bytes

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


Try it online!

# 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


# Wolfram Language (Mathematica), 31 28 bytes

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


Try it online!

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

# 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.

• An answer must be a function or a full program. Yours is a snippet because it assumes the input is already stored in the variable A, so it is invalid. You can make it a function by adding lambda A: to the start. Also, please use the permalink feature on TIO. (You can find the Code Golf post formatter there too.) Commented Feb 25, 2021 at 7:12
• you need to submit this as a function for it to be valid. your Try it online link is also empty. Commented Feb 25, 2021 at 7:13
• Changed it to a function. Removed the try it online as I need to wrap my head around how to use it. Not sure this answer is valid as it mutates list A to the desired form, but the function itself returns None. Commented Feb 25, 2021 at 7:32
• Mutating the input list is definitely a valid output form Commented Mar 1, 2021 at 17:01

# 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>

# 05AB1E, 6 bytes

ʒˆ¯¤¢@


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)


# 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]


# 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