Tâche

Étant donné (par tout moyen) un ensemble de données en virgule flottante trié, renvoyer (par tout moyen et à moins de 1 ‰ de la valeur correcte) la moyenne interquartile .

Un algorithme possible

1. Jeter les trimestres les plus bas et les plus hauts des points de données.
2. Calculez la moyenne (somme divisée par le nombre) des points de données restants.

Remarque: Si la taille de l'ensemble de données n'est pas divisible de façon égale en quatre, vous devrez peser les points de données partagés par les sous-ensembles. Voir l' exemple d'évaluation 2 ci-dessous.

Exemple d'évaluation 1

Étant donné {1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38}

1. Le nombre de données est de 12, nous supprimons donc les 3 points de données les plus bas et les plus hauts:
   { 1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38 }
2. Moyenne des 6 points de données restants:
   (5 + 6 + 6 + 7 + 7 + 8) / 6 = 6,5

Exemple d'évaluation 2

Étant donné {1, 3, 5, 7, 9, 11, 13, 15, 17}

1. Le nombre est de 9, donc chaque trimestre a 2¼ points de données:
   { 1, 2, (0,25 × 5), (0,75 × 5), 7, 9, 11, (0,75 × 13), (0,25 × 13), 15, 17 }
2. Moyenne des 4,5 points de données restants:
   (0,75 × 5 + 7 + 9 + 11 + 0,75 × 13) / 4,5 = 9

Scilab, 8 octets

trimmean

Consultez la documentation . Par défaut, discard=50donc l'IQM est calculé.

EDIT: Vous savez, c'est une réponse intégrée triviale, donc je la marque comme CW .

Pyth , 11 10 octets

.O> <lQS * 4Ql
.OsPtc4S * 4

Suite de tests.

Comment ça marche

Il quadruple la liste d'entrée pour garantir que le nombre de données est divisible par 4.

Il a toujours besoin d'être trié, car il *4s'applique à la liste entière plutôt qu'à chaque élément individuel.

Ensuite, il divise la liste en quatre parties égales, puis supprime la première et la dernière partie.

La liste restante est aplatie et la moyenne est prise.

MATL , 12 11 octets

4Y"G"6L)]Ym

L'entrée est un vecteur horizontal, au format

[1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38]

ou

[1 3 4 5 6 6 7 7 8 8 9 38]

Essayez-le en ligne!

Explication

4Y"    % Input horizontal vector implicitly. Repeat each element 4 times (run-length
       % decoding). The resulting array is still sorted.
G"     % Push input, for each: repeat as many times as the input size
  6L)  %   Remove first and last elements, by applying the index "2:end-1"
]      % End for each
Ym     % Compute mean. Display implicitly

Bonhomme de neige , 66 octets

}vg","aS:10sB;aM4aRAsOal`,4nD,`aG0AaGal`NdE`AaL1AfL:nA;alaF,nDtSsP

Essayez-le en ligne!

Utilise le même algorithme que les réponses de @LeakyNun .

}         enable variables b, e, and g
vg        read a line of input into b
","aS     split on commas (in-place)
:10sB;aM  convert each element in resulting array to number ("frombase(10)-map")
4aR       repeat the array 4 times
AsO       sort the array
al        take the length and put it in e without consuming b (the array)
`,        swap b and e, then move e to g; now b=length g=array
4nD       divide b by 4 (4 was stored in e, which is why the array was moved)
,`        move the array and length/4 back to their original positions
aG        split the array into groups of length (length/4)
0AaG      take all elements with index >0 (i.e. remove the first element)
al        store the length of the new array in e again
`NdE`     bring it up to b, decrement, and put it back
AaL       take all elements with index <length-1 (i.e. remove last)
1AfL      flatten the array 1 level deep
:nA;      push a block that adds two numbers (to e)
al        store the length of this new array in g
aF        fold b over e (sum the numbers)
,         move g (the length) into e
nD        divide the sum by the length, resulting in the average
tSsP      to-string and print

Python 3, 50 octets

lambda n:sum(sorted(n*4)[len(n):-len(n)])/len(n)/2

Ideone it!

Comment ça marche

C'est une traduction de ma réponse en Pyth .

Gelée , 14 13 12 octets

x4ṫL '$ ḣLN $ S ÷ LH 
x4ṫLḊḣLN $ S ÷ LH
x4œs4ḊṖFS ÷ LH

Essayez-le en ligne!

Suite de tests.

Comment ça marche

C'est une traduction de ma réponse en Pyth .

Pyke, 16 13 octets

4*S4ftOsDsRl/

Essayez-le ici!

Brachylog , 21 octets

:3jo@4brbcLl/N,L+:N*.

Essayez-le en ligne! ou vérifier plusieurs cas de test

Explication

Il s'agit essentiellement de l'algorithme de réponse Pyth de @ LeakyNun.

:3j      Append 3 copies of the input to itself
o@4      Sort and split in 4 lists of equal length
brb      Remove the head and the tail of the list of lists
cL       Concatenate the 2 sublists into a list L
l/N,     N is the inverse of the length of L
L+:N*.   Output is the product of N and the sum of the elements of L

La seule petite astuce consiste à multiplier par l'inverse de la longueur au lieu de diviser par la longueur, car la division entre 2 entiers est une division entière.

Octave , 44 octets

@(x)mean(reshape(~~(1:4)'*x,[],4)(:,2:3)(:))

Cela définit une fonction anonyme.

L'entrée est un vecteur horizontal.

Essayez-le sur ideone .

Explication

Le vecteur horizontal d'entrée est d'abord multiplié *par matrice ( ) par un vecteur colonne de quatre (construit avec ~~(1:4)'). Le résultat est une matrice à quatre colonnes où chaque ligne est une copie du vecteur d'entrée. Celui-ci est ensuite remodelé, tout en conservant l'ordre linéaire des éléments, dans une matrice à 4 colonnes ( reshape(...,[],4)). Les deux colonnes centrales sont conservées ( (:,2:3)) et linéarisées en une seule colonne ( (:)), dont la moyenne est calculée ( mean(...)).

J , 20 18 octets

2 octets grâce à @miles

# -: @% ~ - @ # + / @}. #}. 4 #]
- @ # (+ /% #) @}. #}. 4 #]

Essayez-le en ligne! ( Interprète en ligne )

Usage

>> f =: -@#(+/%#)@}.#}.4#]
>> f 1 3 5 7 9 11 13 15 17
<< 9

Comment ça marche

C'est une traduction de ma réponse en Pyth .

En fait , 20 15 13 octets

; l╗; +; + S╜ @ t╜τ @ HΣ╜τ @ /
 ; l; τ; a; +; + StHΣ /
; l; τ; aττStHΣ /

Essayez-le en ligne!

Comment ça marche

C'est une traduction de ma réponse en Pyth .

Octave, 42 octets

Une autre fonction anonyme pour Octave.

@(x)mean([x;x;x;x](:)((b=numel(x))+1:3*b))

Vous pouvez l' essayer en ligne . Entrez simplement cette commande, puis exécutez ans([1 2 4 5 6 9])ou tout nombre requis.

Celui-ci commence par créer à partir du tableau d'entrée un avec 4 de chaque élément d'entrée en concaténant d'abord quatre copies verticalement, puis en l'aplatissant verticalement. Cela maintient l'ordre de tri.

Puis est extrait la plage d'éléments de la longueur du tableau d'entrée plus 1 à trois fois la longueur du tableau d'entrée. Parce que le nouveau tableau est quatre fois plus long, cela coupe les quartiles supérieur et inférieur.

Enfin, la moyenne du nouveau tableau est retournée.

05AB1E, 15 octets

€D€D¹gô¦¨˜DOsg/

Explication

€D€D             # quadruple each element in list
    ¹gô          # split into pieces the size of input
       ¦¨˜       # remove the first and last and flatten the middle 2
          DOsg/  # sum and divide by length

Essayez-le en ligne

APL (Dyalog) , 15 octets

IQM←(+/÷≢)≢↓-∘≢↓4∘/

Essayez-le en ligne!

4∘/ quadrupler chaque élément

-∘≢↓ supprimer autant d'éléments de fin qu'il y a d'éléments dans les arguments

≢↓ déposer autant d'éléments de tête qu'il y a d'élément dans l'argument

(… ) Appliquez la fonction tacite suivante:

 +/ la somme

 ÷ divisé par

 ≢ le décompte

JavaScript (ES6), 75 octets

a=>a.concat(a,a,a).sort(g=(x,y)=>x-y).slice(l=a.length,-l).reduce(g,0)/l/-2

Utilise l'approche évidente en quadruple et tri, et j'arrive à l'utiliser reduce, ce qui est bien. La seule astuce ici est d'économiser 4 octets en réutilisant le comparateur de tri pour soustraire tous les éléments du tableau de zéro, ce qui me donne -2lfois la réponse que je veux.

Golfscript, 28 29 octets

~ .4 * $ \,. @ / 1> 2 <{+} * {+} * '/' @ 2 *
~ .4 * $ \,. @ / 1> 2 <{+} * {+} * \ 2 * -1? *

Essayez-le en ligne!

En fait, 12 octets

4α;l¼≈;±(Htæ

Essayez-le en ligne! (ne fonctionne pas actuellement car TIO est derrière quelques versions)

Explication:

4α;l¼≈;±(Htæ
4α            repeat each element 4 times
  ;l¼≈        length divided by 4, as integer
      ;±      copy, unary negate
        (Ht   remove first and last quartiles
           æ  mean

Mathematica, 51 octets

Mean@#[[(l=1+Length@#/4);;-l]]&@Sort@Join[#,#,#,#]&

Trie quatre copies de la liste (pour éviter les problèmes de longueur de liste et non des multiples de quatre), participe "1 quarter the length of resulting list plus 1"à la "1/4 length list + 1 from the end", prend leur Mean.

Java 146 octets

Une telle java beaucoup verbeuse!

float m(float[]n){float r=0;int l=n.length,i=l/4;r-=(n[i])*(l%4)/4;r+=n[i*3]*(4-(l%4))/4;for(;i<l*3/4;r+=n[i],i++);return r/l*2;}

Ungolfed plus ancien partiellement lisible avec des cas de test

/**
 *
 * @author rohan
 */
public Golf{

float m(float[]n){
//declarations 
float r=0;
int x,i=0,l=n.length;
//sum the array 
for(float m:n){r+=m;}
//remove the excess
for(;i<l/4;r-=n[i]+n[l-i-1],i++);
//weight the quartiles
r-=(n[l/4]+n[l*3/4])*(l%4)/4;
//return the sum/length but multiply by two since only half of the set is averaged
return r/l*2;
    }
static void interQuartileMean(float... set){
    System.out.println(new Golf().m(set));
}
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    //test cases pass with flying colours
        interQuartileMean(1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38);
        interQuartileMean(1, 3, 5, 7, 9, 11, 13, 15, 17);   
    }

}

Clojure, 82 81 octets

Edit: 1 octet de moins en réécrivant la partie "didvide by 2 n".

#(let[n(count %)](*(/ n)0.5(apply +(subvec(vec(for[i % j(range 4)]i))n(* 3 n)))))

Précédent:

#(let[n(count %)](/(apply +(subvec(vec(for[i % j(range 4)]i))n(* 3 n)))(* 2.0 n)))

Utilise forpour générer 4 valeurs répétées, en utilisant float 2.0pour ne pas avoir de résultats fractionnaires, le reste est juste standard.

R, 17 11 octets

mean(n,0.25)

En supposant que nle vecteur d'entrée est sous la forme R standardn=c(1, 2, 3, ...) .

Cela n'est en rien surprenant puisque R peut être considéré comme «LE langage pour le calcul statistique» et possède de nombreuses statistiques intégrées.

MISE À JOUR. 6 octets enregistrés grâce à rturnbull car trimc'est le premier argument optionnel par défaut!

Cas de test:

a <- c(1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38)
b <- c(1, 3, 5, 7, 9, 11, 13, 15, 17)
mean(a,trim=0.25) # Returns 6.5
mean(b,trim=0.25) # Returns 9

Excel, 17 octets

=TRIMMEAN(A:A,.5)

Le format d'entrée détendu rend cela facile. Entrez un par ligne dans la colonne A.