Median in Ruby berechnen

Question

Wie berechne ich den Median eines Zahlenfeldes mit Ruby?

Ich bin ein Anfänger und innerhalb des Fortschritts meines Lernens versuche ich bei dem zu bleiben, was bereits gelehrt wurde. Die anderen Fragen, die ich gefunden habe, liegen also außerhalb meines Rahmens.

Hier sind meine Notizen und mein Versuch:

1. sortiert das Array in aufsteigender Reihenfolge.
2. herauszufinden, ob es ungerade oder gerade ist.
3. Wenn ungerade, teilen Sie die sortierte Array-Länge +1 in zwei Hälften. Das ist der Index des Medians. Gib diesen Wert zurück.
4. wenn gerade, finde die mittleren zwei Zahlen des sortierten Arrays und teile sie in 1/2. Geben Sie diesen Wert zurück.
5. Finden Sie die mittleren zwei Zahlen:
6. teilen Sie die sortierte Array-Länge in zwei Hälften. Das ist Indexpunkt. erste mittlere Nummer.
7. teilen sortierte Array-Länge + 2 in zwei Hälften. Dies ist der Index pt. von der zweiten mittleren Nummer.

8. nehmen Sie Durchschnitt dieser beiden mittleren Zahlen.

   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

Hier ist eine Lösung, die sowohl auf geraden und ungeraden Länge Array arbeitet und das Array nicht ändern:

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

Answer 2

Wenn durch Median Berechnung Sie meinen this

Dann

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 3

I t Hink es ist gut:

#!/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 

oder

#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 

I sort_by eher als Art verwendet, weil es schneller: Sorting an array in descending order in Ruby.

Answer 4

Ähnlich nbarraille ist, aber ich finde es ein bisschen leichter zu verfolgen, warum diese funktioniert:

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 = Anzahl der Elemente bis einschließlich (für Array mit einer ungeraden Anzahl von Elementen) Mitte des Arrays.

Noch einfacher:

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

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

* Wenn die Länge gerade ist, müssen Sie den Mittelpunkt und den mittleren Punkt hinzufügen - 1 zu Konto für den Index, beginnend bei 0

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