web-dev-qa-db-fra.com

Calcul de la médiane en rubis

Comment calculer la médiane d'un tableau de nombres à l'aide de Ruby?

Je suis un débutant et dans les progrès de mon apprentissage, j'essaie de m'en tenir à ce qui a déjà été enseigné. Ainsi, les autres questions que j'ai trouvées dépassent mon cadre.

Voici mes notes et ma tentative:

  1. trier le tableau par ordre croissant. 
  2. déterminez si c'est impair ou même de longueur. 
  3. si impair, divisez la longueur du tableau trié +1 en deux. C’est l’indice de la médiane. Renvoie cette valeur. 
  4. si pair, trouvez les deux nombres du milieu du tableau trié et divisez-les en 1/2 ..__ Renvoyez cette valeur. 
  5. Trouver les deux nombres du milieu: 
  6. diviser la longueur du tableau trié en deux. Ceci est l'index pt. premier nombre du milieu.
  7. diviser la longueur du tableau trié + 2 en deux. C'est l'index pt. du deuxième chiffre du milieu. 

  8. prendre moyenne de ces deux nombres moyens.

    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
rubymedian
41
tomgalpin

Voici une solution qui fonctionne à la fois sur les tableaux de longueur pair et impair et qui ne modifiera pas le tableau:

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

Si par calcul de la médiane, vous voulez dire ceci

Ensuite 

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]
3
AnkitG

Semblable à nbarraille, mais je trouve un peu plus facile de savoir pourquoi celui-ci fonctionne:

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 = nombre d'éléments jusqu'à et y compris (pour un tableau avec un nombre impair d'éléments) milieu du tableau.

Encore plus simple:

class Array
  def median
    sorted = self.sort
    mid = (sorted.length - 1) / 2.0
    (sorted[mid.floor] + sorted[mid.ceil]) / 2.0
  end
end
2
Kal
  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
1
Kyle Snow Schwartz
def median(array)
  half = array.sort!.length / 2
  array.length.odd? ? array[half] : (array[half] + array[half - 1]) / 2 
end

* Si la longueur est paire, vous devez ajouter le point central plus le point central - 1 pour tenir compte de l'index commençant à 0

0
user3007294

Solution plus correcte avec la gestion des cas Edge:

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

Il y a une spécification à prouver:

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
0
Alexander