Как сгруппировать по количеству в массиве без использования цикла

Question

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

Как подсчитать массив по значению группы при сортировке?Мне нужен следующий вывод:

x[1] = 2  
x[2] = 2  
x[3] = 1  
x[4] = 1  
x[5] = 1

Answer 1

x = arr.inject(Hash.new(0)) { |h, e| h[e] += 1 ; h }

Answer 2

Доступно только под ruby ​​1.9

В основном то же самое, что и ответ Михаила , но немного короче:

x = arr.each_with_object(Hash.new(0)) {|e, h| h[e] += 1}

В подобных ситуациях

• Если начальный элемент является изменяемым объектом, таким как Array, Hash, String, вы можете использовать each_with_object, как в случае выше.

• Если начальным элементом является неизменяемый объект, такой как Numeric, вы должны использовать inject, как показано ниже.

  sum = (1..10).inject(0) {|sum, n| sum + n} # => 55

Answer 3

Еще один - похожий на другие - подход:

result=Hash[arr.group_by{|x|x}.map{|k,v| [k,v.size]}]

1. Группировка по значению каждого элемента.
2. Сопоставить группировку с массивом из [значение, счетчик] пар.
3. Превратить массив paris в значения ключа в хэше, т. Е. Получить доступ через result[1]=2 ....

Answer 4

x = Hash[arr.uniq.map{ |i| [i, arr.count(i)] }]

Answer 5

Всякий раз, когда вы обнаруживаете, что кто-то утверждает, что что-то является самым быстрым в этом типе примитивной рутины, мне всегда интересно подтверждать это, потому что без подтверждения большинство из нас на самом деле просто гадают.Итак, я взял все методы здесь и протестировал их.

Я взял массив из 120 ссылок, извлеченных из веб-страницы, которые мне нужно было сгруппировать по количеству, и реализовал все это с помощью секунды = Benchmark.realtime.делай петлю и получай все время.

Предположим, что ссылки - это имя массива, который мне нужно сосчитать:

#0.00077
seconds = Benchmark.realtime do
  counted_links = {}
  links.each { |e| counted_links[e] = links.count(e) if counted_links[e].nil?}
end
seconds

#0.000232
seconds = Benchmark.realtime do
  counted_links = {}
  links.sort.group_by {|x|x}.each{|x,y| counted_links[x] = y.size}
end

#0.00076
seconds = Benchmark.realtime do 
  Hash[links.uniq.map{ |i| [i, links.count(i)] }]
end

#0.000107 
seconds = Benchmark.realtime do 
  links.inject(Hash.new(0)) {|h, v| h[v] += 1; h}
end

#0.000109
seconds = Benchmark.realtime do 
  links.each_with_object(Hash.new(0)) {|e, h| h[e] += 1}
end

#0.000143
seconds = Benchmark.realtime do 
  links.inject(Hash.new(0)) { |h, e| h[e] += 1 ; h }
end

А затем немного рубина, чтобы выяснить ответ:

times = [0.00077, 0.000232, 0.00076, 0.000107, 0.000109, 0.000143].min
==> 0.000107

Итак, самый быстрый метод, конечно же, ymmv:

links.inject(Hash.new(0)) {|h, v| h[v] += 1; h}

Answer 6

Существует короткая версия, которая находится в ruby 2.7 => Enumerable#tally.

[1,2,1,3,5,2,4].tally  #=> { 1=>2, 2=>2, 3=>1, 5=>1, 4=>1 }

# Other possible usage

(1..6).tally { |i| i%3 }   #=> { 0=>2, 1=>2, 2=>2 }

Answer 7

Только для записи, я недавно прочитал о Object#tap здесь .Мое решение было бы:

Hash.new(0).tap{|h| arr.each{|i| h[i] += 1}}

Метод #tap передает вызывающего в блок, а затем возвращает его.Это очень удобно, когда вам нужно постепенно наращивать массив / хэш.

Answer 8

Я уверен, что есть лучшие способы,

>> arr.sort.group_by {|x|x}.each{|x,y| print "#{x} #{y.size}\n"}
1 2
2 2
3 1
4 1
5 1

присваивать значения х и у хешу по мере необходимости.

Answer 9

Это должно сделать это

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

puts arr.inject(Hash.new(0)) {|h, v| h[v] += 1; h}
#=> {1=>2, 2=>2, 3=>1, 5=>1, 4=>1}

Answer 10

arr = [1,2,1,3,5,2,4]
r = {}
arr.each { |e| r[e] = arr.count(e) if r[e].nil?}

Выходы

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