Comment compter les doublons dans les tableaux Ruby

Question

Comment comptez-vous les doublons dans un tableau de rubis?

Par exemple, si mon tableau avait trois A, comment pourrais-je compter que

Answer 1

Cela donnera les éléments en double comme un hachage avec le nombre d'occurences pour chaque élément en double. Laissez le code parler:

#!/usr/bin/env ruby 

class Array 
    # monkey-patched version 
    def dup_hash 
    inject(Hash.new(0)) { |h,e| h[e] += 1; h }.select { 
     |k,v| v > 1 }.inject({}) { |r, e| r[e.first] = e.last; r } 
    end 
end 

# unmonkeey'd 
def dup_hash(ary) 
    ary.inject(Hash.new(0)) { |h,e| h[e] += 1; h }.select { 
    |_k,v| v > 1 }.inject({}) { |r, e| r[e.first] = e.last; r } 
end 

p dup_hash([1, 2, "a", "a", 4, "a", 2, 1]) 
# {"a"=>3, 1=>2, 2=>2} 

p [1, 2, "Thanks", "You're welcome", "Thanks", 
    "You're welcome", "Thanks", "You're welcome"].dup_hash 
# {"You're welcome"=>3, "Thanks"=>3} 

Answer 2

Je ne pense pas qu'il existe une méthode intégrée. Si tout ce dont vous avez besoin est le total nombre de doublons, vous pouvez prendre un.length - un.uniq.length. Si vous recherchez le nombre d'un élément particulier, essayez
a.select {|e| e == my_element}.length.

Answer 3

Simple.

arr = [2,3,4,3,2,67,2] 
repeats = arr.length - arr.uniq.length 
puts repeats 

Answer 4

1.8.7+ nécessite pour group_by

ary = %w{a b c d a e f g a h i b} 
ary.group_by{|elem| elem}.select{|key,val| val.length > 1}.map{|key,val| key} 
# => ["a", "b"] 

avec 1.9+ cela peut être légèrement simplifiée car # Hash select retournera un hachage.

ary.group_by{|elem| elem}.select{|key,val| val.length > 1}.keys 
# => ["a", "b"] 

Answer 5

Une autre version d'un hachage avec une clé pour chaque élément de votre tableau et la valeur pour le compte de chaque élément

a = [ 1, 2, 3, 3, 4, 3] 
h = Hash.new(0) 
a.each { | v | h.store(v, h[v]+1) } 

# h = { 3=>3, 2=>1, 1=>1, 4=>1 } 

Answer 6

Pour compter les occurrences d'un usage unique élément injection

array.inject(0){|count,elem| elem == value ? count+1 : count} 

Answer 7

Étant donné:

arr = [ 1, 2, 3, 2, 4, 5, 3] 

M y façon préférée des éléments de comptage est:

counts = arr.group_by{|i| i}.map{|k,v| [k, v.count] } 

# => [[1, 1], [2, 2], [3, 2], [4, 1], [5, 1]] 

Si vous avez besoin d'un hachage au lieu d'un tableau:

Hash[*counts.flatten] 

# => {1=>1, 2=>2, 3=>2, 4=>1, 5=>1} 

Answer 8

Qu'en est-il un grep?

arr = [1, 2, "Thanks", "You're welcome", "Thanks", "You're welcome", "Thanks", "You're welcome"] 

arr.grep('Thanks').size # => 3 

Answer 9

arr = %w(a b c d c b a) 
# => ["a", "b", "c", "d", "c", "b", "a"] 

arr.count('a') 
# => 2 

Answer 10

Il est facile:

words = ["aa","bb","cc","bb","bb","cc"] 

Une ligne solution est simple:

words.each_with_object(Hash.new(0)) { |word,counts| counts[word] += 1 } 

Il fonctionne pour moi.

Merci!

Answer 11

Une autre manière de compter les doublons de tableau est la suivante:

arr= [2,2,3,3,2,4,2] 

arr.group_by{|x| x}.map{|k,v| [k,v.count] } 

résultat

est

[[2, 4], [3, 2], [4, 1]]

Answer 12

Amélioration @ la réponse de Kim:

arr = [1, 2, "a", "a", 4, "a", 2, 1] 
Hash.new(0).tap { |h| arr.each { |v| h[v] += 1 } } 
# => {1=>2, 2=>2, "a"=>3, 4=>1} 

Answer 13

Je l'ai utilisé reduce/inject pour cela dans le passé, comme le suivant

array = [1,5,4,3,1,5,6,8,8,8,9] 
array.reduce (Hash.new(0)) {|counts, el| counts[el]+=1; counts} 

produit

=> {1=>2, 5=>2, 4=>1, 3=>1, 6=>1, 8=>3, 9=>1}