在Ruby中計算中位數

Question

如何計算使用Ruby的數組數組的中位數？

我是初學者，在我學習的過程中，我努力堅持已經教過的內容。因此，我發現的其他問題超出了我的範圍。

這裏是我的筆記，我的嘗試：

1. 升序排序的數組。
2. 找出它是奇數還是長度。
3. 如果奇數，則將排序後的數組長度+1分成兩半。 是中位數的指數。返回這個值。
4. 如果偶數，找到排序數組的中間兩個數字並將它們分成1/2。 返回此值。
5. 查找中間兩位數字：
6. 將排序後的數組長度減半。這是指數點。第一個中間數字。
7. 將排序後的數組長度+ 2分成兩半。這是指數點。 第二個中間數字。

8. 取這兩個中間數的平均值。

   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

這裏是偶數和奇數長度陣列上的工作，並不會改變陣列的解決方案：

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

Answer 2

如果通過計算中值你的意思this

然後

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這是很好的：

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

或

#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 

我使用sort_by而不是那種因爲它的速度更快：Sorting an array in descending order in Ruby。

Answer 4

到nbarraille的相似，但我覺得它有點容易跟蹤爲什麼這一個工程：

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 =元素的數量直至幷包括（與奇數項的數組）數組中間。

更簡單：

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 

*如果長度爲偶數，則必須將中間點加上中間點 - 1到佔該指數從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