Grenzwert Anzahl von doppelten Elemente innerhalb eines Arrays zu einem gegebenen Wert

Question

In Ruby, wenn ich eine array mit Dubletten in ihm haben und einen bestimmten Wert n:

array = [1,56,1,245,56,1,56,1,56,1,56] 

n = 2 

Wie konnte begrenzen ich die Anzahl der Duplikate innerhalb der array zu n während auch die Positionierung der restlichen Elemente beibehalten, um dies zu produzieren?

array = [1,56,1,245,56] 

Answer 1

def ndup(list, n) 
    cnts = {} 
    list.select do |item| 
    cnts[item] ||= 0 
    cnts[item] += 1 
    cnts[item] <= n 
    end 
end 

ndup([1,56,1,245,56,1,56,1,56,1,56], 2) 
#=> [1, 56, 1, 245, 56] 

Answer 2

def ff(array, n) 
    occurances = Hash.new(0) 
    array.uniq do |element| 
    occurances[element] = occurances[element] < n ? occurances[element].next : n 
    [element, occurances[element]] 
    end 
end 

Answer 3

eine Zählung Hash Verwendung ist der Weg hier zu gehen, aber hier ist eine Alternative:

array.each_with_index. 
     group_by(&:first). 
     values. 
     flat_map { |a| a.first(n) }. 
     sort_by(&:last). 
     map(&:first) 
    #=> [1, 56, 1, 245, 56] 

Die Schritte sind wie folgt.

enum = array.each_with_index 
    #=> #<Enumerator: [1, 56, 1, 245, 56, 1, 56, 1, 56, 1, 56]:each_with_index> 
h = enum.group_by(&:first) 
    #=> { 1=>[[1, 0], [1, 2], [1, 5], [1, 7], [1, 9]], 
    #  56=>[[56, 1], [56, 4], [56, 6], [56, 8], [56, 10]], 
    # 245=>[[245, 3]]} 
a = h.values 
    #=> [[[1, 0], [1, 2], [1, 5], [1, 7], [1, 9]], 
    # [[56, 1], [56, 4], [56, 6], [56, 8], [56, 10]], 
    # [[245, 3]]] 
b = a.flat_map { |a| a.first(n) } 
    #=> [[1, 0], [1, 2], [56, 1], [56, 4], [245, 3]] 
c = b.sort_by(&:last) 
    #=> [[1, 0], [56, 1], [1, 2], [245, 3], [56, 4]] 
c.map(&:first) 
    #=> [1, 56, 1, 245, 56]