objects - Ruby: ¿Cómo encontrar el elemento en la matriz que tiene la mayor cantidad de apariciones?

ruby select

Question

[1, 1, 1, 2, 3].mode
=> 1
[''cat'', ''dog'', ''snake'', ''dog''].mode
=> dog

Answer 1

Aquí hay otra versión que te da los lazos como un modo debe:

def mode
group_by {|x| x}.group_by {|k,v| v.size}.sort.last.last.map(&:first)
end

En otras palabras, agrupe los valores, luego agrupe esos pares de kv por el número de valores, luego clasifique los pares de kv, tome el último (más alto) grupo de tamaño y luego desenrolle sus valores. Me gusta group_by .

Answer 2

Este es un duplicado de esta pregunta: Ruby - Elementos únicos en Array

Aquí está la solución de la pregunta:

group_by { |n| n }.values.max_by(&:size).first

Esa versión parece ser incluso más rápida que la respuesta de Nilesh C. Aquí está el código que usé para compararlo (OS X 10.6 Core 2 2.4GHz MB).

Felicitaciones a Mike Woodhouse por el código de referencia (original):

class Array
def mode1
group_by { |n| n }.values.max_by(&:size).first
end
def mode2
freq = inject(Hash.new(0)) { |h,v| h[v] += 1; h }
max = freq.values.max # we''re only interested in the key(s) with the highest frequency
freq.select { |k, f| f == max } # extract the keys that have the max frequency
end
end
arr = Array.new(1_0000) { |i| rand(100000) } # something to test with
Benchmark.bm(30) do |r|
(1..2).each do |i| r.report("mode#{i}") { 100.times do arr.send("mode#{i}").inspect; end }; end
end

Y aquí están los resultados del benchmark:

 user system total real
mode1 1.830000 0.010000 1.840000 ( 1.876642)
mode2 2.280000 0.010000 2.290000 ( 2.382117)
mode1 = 70099
mode2 = [[70099, 3], [70102, 3], [51694, 3], [49685, 3], [38410, 3], [90815, 3], [30551, 3], [34720, 3], [58373, 3]]

Como puede ver, esta versión es aproximadamente un 20% más rápida con la advertencia de ignorar vínculos. También me gusta la brevedad, personalmente la uso tal como está sin parche de mono por todas partes. :)

Answer 3

Mientras adoro la solución grep por su elegancia y por recordarme (o enseñarme) acerca de un método en Enumerable que había olvidado (o pasado por alto por completo), es lento, lento, lento. Acepto al 100% que la creación del método de Array#mode es una buena idea, sin embargo, esto es Ruby, no necesitamos una biblioteca de funciones que actúen sobre matrices, podemos crear una mezcla que agregue las funciones necesarias a la clase Array sí mismo.

Pero la alternativa de inyección (Hash) usa una ordenación, que tampoco necesitamos realmente: solo queremos el valor con mayor ocurrencia.

Ninguna de las soluciones aborda la posibilidad de que más de un valor sea el modo. Tal vez eso no es un problema en el problema como se dijo (no se puede decir). Creo que me gustaría saber si hubo empate, y de todos modos, creo que podemos mejorar un poco el rendimiento.

require ''benchmark''
class Array
def mode1
sort_by {|i| grep(i).length }.last
end
def mode2
freq = inject(Hash.new(0)) { |h,v| h[v] += 1; h }
sort_by { |v| freq[v] }.last
end
def mode3
freq = inject(Hash.new(0)) { |h,v| h[v] += 1; h }
max = freq.values.max # we''re only interested in the key(s) with the highest frequency
freq.select { |k, f| f == max } # extract the keys that have the max frequency
end
end
arr = Array.new(1_000) { |i| rand(100) } # something to test with
Benchmark.bm(30) do |r|
res = {}
(1..3).each do |i|
m = "mode#{i}"
r.report(m) do
100.times do
res[m] = arr.send(m).inspect
end
end
end
res.each { |k, v| puts "%10s = %s" % [k, v] }
end

Y aquí está el resultado de una ejecución de muestra.

 user system total real
mode1 34.375000 0.000000 34.375000 ( 34.393000)
mode2 0.359000 0.000000 0.359000 ( 0.359000)
mode3 0.219000 0.000000 0.219000 ( 0.219000)
mode1 = 41
mode2 = 41
mode3 = [[41, 17], [80, 17], [72, 17]]

El modo "optimizado" 3 tomó el 60% del tiempo del poseedor del registro anterior. Tenga en cuenta también las entradas múltiples de frecuencia más alta.

EDITAR

Unos meses después, noté la respuesta de Nilesh , que ofrecía esto:

def mode4
group_by{|i| i}.max{|x,y| x[1].length <=> y[1].length}[0]
end

No funciona con 1.8.6 de fábrica, porque esa versión no tiene Array # group_by. ActiveSupport lo tiene, para los desarrolladores de Rails, aunque parece un 2-3% más lento que el modo 3 anterior. Sin embargo, el uso de la (excelente) joya de backports produce una ganancia del 10-12%, además de entregar una pila completa de 1.8.7 y 1.9 extras.

Lo anterior se aplica únicamente a 1.8.6 , y principalmente solo si está instalado en Windows. Desde que lo tengo instalado, esto es lo que obtienes de IronRuby 1.0 (en .NET 4.0):

========================== IronRuby =====================================
(iterations bumped to **1000**) user system total real
mode1 (I didn''t bother :-))
mode2 4.265625 0.046875 4.312500 ( 4.203151)
mode3 0.828125 0.000000 0.828125 ( 0.781255)
mode4 1.203125 0.000000 1.203125 ( 1.062507)

Entonces, en caso de que el rendimiento sea súper crítico, compare las opciones en su versión de Ruby & SO. YMMV .

Answer 4

Mike: encontré un método más rápido. Prueba esto:

 class Array
def mode4
group_by{|i| i}.max{|x,y| x[1].length <=> y[1].length}[0]
end
end

El resultado de Benchmark:

 user system total real
mode1 24.340000 0.070000 24.410000 ( 24.526991)
mode2 0.200000 0.000000 0.200000 ( 0.195348)
mode3 0.120000 0.000000 0.120000 ( 0.118200)
mode4 0.050000 0.010000 0.060000 ( 0.056315)
mode1 = 76
mode2 = 76
mode3 = [[76, 18]]
mode4 = 76

Answer 5

Primero construya un hash mapeando cada valor en la matriz a su frecuencia ...

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

... luego usa la tabla de frecuencias para encontrar el elemento con la frecuencia más alta:

arr.max_by { |v| freq[v] }
#=> 1

Answer 6

si intentas evitar el aprendizaje de #inject (que no debes hacer ...)

words = [''cat'', ''dog'', ''snake'', ''dog'']
count = Hash.new(0)
words.each {|word| count[word] += 1}
count.sort_by { |k,v| v }.last

pero si leo esta respuesta antes, ahora no sabría nada sobre #inject y man, necesitas saber sobre #inject.

Answer 7

arr = [ 1, 3, 44, 3 ]
most_frequent_item = arr.uniq.max_by{ |i| arr.count( i ) }
puts most_frequent_item
#=> 3

No es necesario ni siquiera pensar en mapeos de frecuencia.

Answer 8

array.max_by { |i| array.count(i) }

Answer 9

def mode(array)
count = [] # Number of times element is repeated in array
output = []
array.compact!
unique = array.uniq
j=0
unique.each do |i|
count[j] = array.count(i)
j+=1
end
k=0
count.each do |i|
output[k] = unique[k] if i == count.max
k+=1
end
return output.compact.inspect
end
p mode([3,3,4,5]) #=> [3]
p mode([1,2,3]) #=> [1,2,3]
p mode([0,0,0,0,0,1,2,3,3,3,3,3]) #=> [0,3]
p mode([-1,-1,nil,nil,nil,0]) #=> [-1]
p mode([-2,-2,3,4,5,6,7,8,9,10,1000]) #=> [-2]

Answer 10

idx = {}
[2,2,1,3,1].each { |i| idx.include?(i) ? idx[i] += 1 : idx[i] = 1}

Esto es solo un indexador simple. Podría reemplazar la matriz [2,2,1 ..] con cualquier tipo de identificador basado en símbolo / cadena, esto no funcionaría con los objetos, tendría que introducir un poco más de complejidad, pero esto es bastante simple.

Al releer sus preguntas, esta solución está un poco sobre-diseñada ya que le devolverá un índice de todas las ocurrencias, no solo la que tiene más.