Question

如何使用Ruby计算数字数组的中位数？

我是初学者，在我学习的过程中，我努力坚持已经教过的东西。因此，我发现的其他问题超出了我的范围。

以下是我的笔记和我的尝试：

按升序对数组进行排序。
弄清楚它是奇数还是长度。
如果是奇数，则将排序后的数组长度+1分成两半。那是中位数的指数。返回此值。
如果是偶数，找到排序数组的中间两个数字并将其除以1/2。返回此值。
找到中间的两个数字：
将排序后的数组长度分成两半。这是指数pt。第一个中间数字。
将排序后的数组长度+ 2分成两半。这是指数pt。的第二个中间数字。

取这两个中间数的平均值。

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

与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 4

  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?
        array[(array.length - 1) / 2] #find value at this index
      else array.length.even?                #is the length of the array even?
       (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 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

处理边缘情况的更正确的解决方案：

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

有一些规格需要证明：

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 7

def median(arr)
    sorted = arr.sort 
    if sorted == []
       return nil
    end  

    if sorted.length % 2 != 0
       result = sorted.length / 2 # 7/2 = 3.5 (rounded to 3)
       return sorted[result] # 6 
    end

    if sorted.length % 2 == 0
       result = (sorted.length / 2) - 1
       return (sorted[result] + sorted[result+1]) / 2.0 #  (4 + 5) / 2
    end
end

p median([5, 0, 2, 6, 11, 10, 9])

Answer 8

这是一个解决方案：

app_arry = [2, 3, 4, 2, 5, 6, 16].sort

# check array isn't empty
if app_arry.empty?  || app_arry == ""
  puts "Sorry, This will not work."
  return nil
end

length = app_arry.length
puts "Array length = #{length}"
puts "Array = #{app_arry}"

if length % 2  == 0
 # even number of elements
 puts "median is #{(app_arry[length/2].to_f +  app_arry[(length-1)/2].to_f)/2}"
else
 # odd number of elements
 puts "median is #{app_arry[(length-1)/2]}"
end

输出

数组长度= 7

Array = [2、3、4、2、5、6、16]

中位数为2

Answer 9

def median(array, already_sorted=false)
    return nil if array.empty?
    array = array.sort unless already_sorted
    m_pos = array.size / 2
    return array.size % 2 == 1 ? array[m_pos] : mean(array[m_pos-1..m_pos])
end

Answer 10

我喜欢使用 Refinements，这是一种Monkey Patch ruby 类的安全方法，不会对系统产生附带影响。

用法比新方法更简洁。

使用 Refinements，您可以对 Array 类进行猴子修补，实现 Array#median 并且此方法仅在使用细化的类的范围内可用！ :)

改进

module ArrayRefinements
  refine Array do
    def median
      return nil if empty?
      sorted = sort
      (sorted[(length - 1) / 2] + sorted[length / 2]) / 2.0
    end
  end
end

class MyClass
  using ArrayRefinements
  # You can use the Array#median as you wish here

  def test(array)
    array.median
  end
end

MyClass.new.test([1, 2, 2, 2, 3])
=> 2.0

Answer 11

我认为这很好：

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

在Ruby中计算中位数

11 个答案:

改进