ruby: come trovare elementi non univoci nella matrice e stampare ciascuno con il numero di occorrenze?

Question

Ho

a = ["a", "d", "c", "b", "b", "c", "c"] 

e la necessità di stampare qualcosa di simile (discendente ordinati secondo il numero di occorrenze):

c:3 
b:2 

ho capito prima parte (la ricerca non univoco) è:

b = a.select{ |e| a.count(e) > 1 } 
=> ["c", "b", "b", "c", "c"] 

o

puts b.select{|e, c| [e, a.count(e)] }.uniq 

c 
b 

Come stampare ogni non univoco con il numero di occorrenze ordinato all'indietro?

Answer 1

puts a.uniq. 
     map { | e | [a.count(e), e] }. 
     select { | c, _ | c > 1 }. 
     sort.reverse. 
     map { | c, e | "#{e}:#{c}" } 

Answer 2

Questo vi darà un hash con element => occurrences:

b.reduce(Hash.new(0)) do |hash, element| 
    hash[element] += 1 
    hash 
end 

Answer 3

Il metodo group_by viene utilizzato per questo spesso:

 
a.group_by{ |i| i } 
{ 
    "a" => [ 
     [0] "a" 
    ], 
    "d" => [ 
     [0] "d" 
    ], 
    "c" => [ 
     [0] "c", 
     [1] "c", 
     [2] "c" 
    ], 
    "b" => [ 
     [0] "b", 
     [1] "b" 
    ] 
} 

mi piace:

 
a.group_by{ |i| i }.each_with_object({}) { |(k,v), h| h[k] = v.size } 
{ 
    "a" => 1, 
    "d" => 1, 
    "c" => 3, 
    "b" => 2 
} 

Or :

 
Hash[a.group_by{ |i| i }.map{ |k,v| [k, v.size] }] 
{ 
    "a" => 1, 
    "d" => 1, 
    "c" => 3, 
    "b" => 2 
} 

Uno di quelli potrebbe graffiare il tuo prurito. Da lì è possibile ridurre il risultato usando un piccolo test:

 
Hash[a.group_by{ |i| i }.map{ |k,v| v.size > 1 && [k, v.size] }] 
{ 
    "c" => 3, 
    "b" => 2 
} 

Se si desidera solo per stampare la vendita Note:

 
puts a.group_by{ |i| i }.map{ |k,v| "#{k}: #{v.size}" } 
a: 1 
d: 1 
c: 3 
b: 2 

Answer 4

puts a.uniq. 
    map { |e| a.count(e) > 1 ? [e, a.count(e)] : nil }.compact. 
    sort { |a, b| b.last <=> a.last } 

Answer 5

a.reduce(Hash.new(0)) { |memo,x| memo[x] += 1; memo } # Frequency count. 
    .select { |_,count| count > 1 } # Choose non-unique items. 
    .sort_by { |x| -x[1] } # Sort by number of occurrences descending. 
# => [["c", 3], ["b", 2]] 

anche:

a.group_by{|x|x}.map{|k,v|[k,v.size]}.select{|x|x[1]>1}.sort_by{|x|-x[1]} 
# => [["c", 3], ["b", 2]] 

Answer 6

Che ne dite di:

a.sort.chunk{|x| a.count(x)}.sort.reverse.each do |n, v| 
    puts "#{v[0]}:#{n}" if n > 1 
end 

Answer 7

Personalmente, come questa soluzione:

a.inject({}) {|hash, val| hash[val] ||= 0; hash[val] += 1; hash}. 
    reject{|key, value| value == 1}.sort.reverse. 
    each_pair{|k,v| puts("#{k}:#{v}")}