ruby​​：如何在數組中找到非唯一元素並用每次出現次數打印？

Question

我

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

，需要打印出類似這樣（按出現次數降序排序）：

c:3 
b:2 

我理解第一部分（發現非唯一）是：

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

或

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

c 
b 

如何輸出每個非唯一的發生次數向後排序？

Answer 1

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

Answer 2

這會給你一個哈希值與element => occurrences：

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

Answer 3

的group_by方法用於這往往：

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

我喜歡：

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

或者：

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

其中一個可能會抓撓你的癢。從那裏，你可以使用一個小測試減少的結果：

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

如果你只想打印信息的使用：

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

另外：

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

如何：

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

Answer 7

我個人這樣的解決方案：

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}")}