Calculando Mediana en Ruby

Question

¿Cómo calculo la mediana de una matriz de números usando Ruby?

Soy un principiante y, en el progreso de mi aprendizaje, trato de atenerme a lo que ya se ha enseñado. Por lo tanto, las otras preguntas que he encontrado están más allá de mi alcance.

Aquí están mis notas y mi intento:

1. ordenar la matriz en orden ascendente.
2. averiguar si es impar o incluso de longitud.
3. si es impar, divida la longitud del conjunto ordenado +1 por la mitad. Ese es el índice de la mediana. Devuelve este valor
4. si es así, encuentre los dos números centrales de la matriz ordenada y divídalos en 1/2. Devuelve este valor
5. Encontrar los dos números centrales:
6. divide la longitud del conjunto ordenado por la mitad. Este es el índice pt. primer número medio.
7. divide la longitud de la matriz ordenada + 2 a la mitad. Este es el índice pt. del segundo número medio.

8. tome el promedio de estos dos números medios.

   def median(array)
   ascend = array.sort
   if ascend % 2 != 0
   (ascend.length + 1) / 2.0
   else
   ((ascend.length/2.0) + ((ascend.length + 2)/2.0) / 2.0)
   end
   end

Answer 1

Aquí hay una solución que funciona en una matriz de longitud par e impar y no altera la matriz:

def median(array)
sorted = array.sort
len = sorted.length
(sorted[(len - 1) / 2] + sorted[len / 2]) / 2.0
end

Answer 2

Creo que esta bien:

#!/usr/bin/env ruby
#in-the-middle value when odd or
#first of second half when even.
def median(ary)
middle = ary.size/2
sorted = ary.sort_by{ |a| a }
sorted[middle]
end

o

#in-the-middle value when odd or
#average of 2 middle when even.
def median(ary)
middle = ary.size/2
sorted = ary.sort_by{ |a| a }
ary.size.odd? ? sorted[middle] : (sorted[middle]+sorted[middle-1])/2.0
end

Utilicé sort_by en lugar de ordenar porque es más rápido: ordenando una matriz en orden descendente en Ruby .

Answer 3

Si al calcular Median te refieres a this

Entonces

a = [12,3,4,5,123,4,5,6,66]
a.sort!
elements = a.count
center = elements/2
elements.even? ? (a[center] + a[center+1])/2 : a[center]

Answer 4

Similar a la de nbarraille, pero me resulta un poco más fácil hacer un seguimiento de por qué funciona esta:

class Array
def median
sorted = self.sort
half_len = (sorted.length / 2.0).ceil
(sorted[half_len-1] + sorted[-half_len]) / 2.0
end
end

half_len = número de elementos hasta e incluyendo (para la matriz con número impar de elementos) en el medio de la matriz.

Aún más simple:

class Array
def median
sorted = self.sort
mid = (sorted.length - 1) / 2.0
(sorted[mid.floor] + sorted[mid.ceil]) / 2.0
end
end

Answer 5

Solución más correcta para manejar casos extremos:

class Array
def median
sorted = self.sort
size = sorted.size
center = size / 2
if size == 0
nil
elsif size.even?
(sorted[center - 1] + sorted[center]) / 2.0
else
sorted[center]
end
end
end

Hay una especificación para probar:

describe Array do
describe ''#median'' do
subject { arr.median }
context ''on empty array'' do
let(:arr) { [] }
it { is_expected.to eq nil }
end
context ''on 1-element array'' do
let(:arr) { [5] }
it { is_expected.to eq 5 }
end
context ''on 2-elements array'' do
let(:arr) { [1, 2] }
it { is_expected.to eq 1.5 }
end
context ''on odd-size array'' do
let(:arr) { [100, 5, 2, 12, 1] }
it { is_expected.to eq 5 }
end
context ''on even-size array'' do
let(:arr) { [7, 100, 5, 2, 12, 1] }
it { is_expected.to eq 6 }
end
end
end

Answer 6

 def median(array) #Define your method accepting an array as an argument.
array = array.sort #sort the array from least to greatest
if array.length.odd? #is the length of the array odd?
return array[(array.length - 1) / 2] #find value at this index
else array.length.even? #is the length of the array even?
return ( array[array.length/2] + array[array.length/2 - 1] )/2.to_f
#average the values found at these two indexes and convert to float
end
end

Answer 7

def median(array)
half = array.sort!.length / 2
array.length.odd? ? array[half] : (array[half] + array[half - 1]) / 2
end

* Si la longitud es pareja, debe agregar el punto medio más el punto medio - 1 para tener en cuenta el índice que comienza en 0