Calcul de la médiane dans Ruby
comment calculer la médiane d'un tableau de nombres en utilisant Ruby?
je suis un débutant et dans le progrès de mon apprentissage, j'essaie de m'en tenir à ce qui a déjà été enseigné. Donc les autres questions que j'ai trouvées sont au-delà de ma portée.
Voici mes notes et ma tentative:
- trier le tableau dans l'ordre croissant.
- déterminer s'il est impair ou même en longueur.
- si Impair, divisez la longueur du tableau trié +1 en deux. Que est l'indice de la médiane. Retournez cette valeur.
- si Pair, trouver les deux nombres du milieu du tableau trié et les diviser en 1/2. Retournez cette valeur.
- trouver les deux numéros du milieu:
- divisez la longueur du tableau en deux. C'est l'indice pt. premier numéro du milieu.
- diviser tableau trié longueur + 2 dans la moitié. C'est l'indice pt. de la deuxième moyen de nombre.
-
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
7 réponses
Voici une solution qui fonctionne à la fois sur le tableau de longueur Pair et impaire et ne va pas modifier le tableau:
def median(array)
sorted = array.sort
len = sorted.length
(sorted[(len - 1) / 2] + sorted[len / 2]) / 2.0
end
semblable à celui de nbarraille, mais je trouve qu'il est 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 tableau avec un nombre impair d'éléments) milieu de 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
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
def median(array)
half = array.sort!.length / 2
array.length.odd? ? array[half] : (array[half] + array[half - 1]) / 2
end
* si la longueur est égale, vous devez ajouter le point milieu plus le point milieu - 1 pour tenir compte de l'indice commençant à 0
solution plus correcte pour la manipulation des bordures:
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 un spécications pour le 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
je pense que c'est une bonne chose:
#!/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
ou
#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
j'ai utilisé sort_by plutôt que tri car c'est plus rapide: Tri un tableau en ordre décroissant dans Ruby .