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