Compito

Dato (con qualsiasi mezzo) un set di dati in virgola mobile ordinato, restituisce (con qualsiasi mezzo e entro 1 ‰ del valore corretto) la media interquartile .

Un possibile algoritmo

1. Elimina i quarti più basso e più alto dei punti dati.
2. Calcola la media (somma divisa per conteggio) dei punti dati rimanenti.

Nota: se la dimensione del set di dati non è suddivisa in modo uniforme in quattro, sarà necessario pesare i punti dati condivisi dai sottoinsiemi. Vedi Esempio di valutazione 2 di seguito.

Esempio di valutazione 1

Dato {1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38}

1. Il conteggio dei dati è 12, quindi rimuoviamo i 3 punti dati più bassi e più alti:
   { 1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38 }
2. Media dei rimanenti 6 punti dati:
   (5 + 6 + 6 + 7 + 7 + 8) / 6 = 6.5

Esempio di valutazione 2

Dato {1, 3, 5, 7, 9, 11, 13, 15, 17}

1. Il conteggio è 9, quindi ogni trimestre ha 2¼ punti dati:
   { 1, 2, (0,25 × 5), (0,75 × 5), 7, 9, 11, (0,75 × 13), (0,25 × 13), 15, 17 }
2. Media dei 4,5 punti dati rimanenti:
   (0,75 × 5 + 7 + 9 + 11 + 0,75 × 13) / 4,5 = 9

Scilab, 8 byte

trimmean

Vedere la documentazione . Per impostazione predefinita, discard=50viene quindi calcolato IQM.

EDIT: Sai, questa è una banale risposta integrata, quindi la segnerò come CW .

Pyth , 11 10 byte

.O> <LQS * 4QL
.OsPtc4S * 4

Suite di test.

Come funziona

Quadruplica l'elenco di input per garantire che il conteggio dei dati sia divisibile per 4.

Ha ancora bisogno di smistamento, perché *4 applica all'intero elenco anziché a ogni singolo elemento.

Quindi, divide l'elenco in quattro parti uguali, quindi toglie la prima e l'ultima parte.

L'elenco rimanente viene appiattito e viene presa la media.

MATL , 12 11 byte

4Y"G"6L)]Ym

L'input è un vettore orizzontale, con il formato

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

o

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

Provalo online!

Spiegazione

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

Pupazzo di neve , 66 byte

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

Provalo online!

Utilizza lo stesso algoritmo delle risposte di @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 byte

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

Ideone esso!

Come funziona

È una traduzione della mia risposta in Pyth .

Gelatina , 14 13 12 byte

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

Provalo online!

Suite di test.

Come funziona

È una traduzione della mia risposta in Pyth .

Pyke, 16 13 byte

4*S4ftOsDsRl/

Provalo qui!

Brachylog , 21 byte

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

Provalo online! o verifica più casi di test

Spiegazione

Questo è fondamentalmente l'algoritmo di risposta Pyth di @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

L'unico piccolo trucco è nel moltiplicare per l'inverso della lunghezza invece di dividere per la lunghezza, perché la divisione tra 2 numeri interi è la divisione intera.

Ottava , 44 byte

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

Questo definisce una funzione anonima.

L'input è un vettore orizzontale.

Provalo su ideone .

Spiegazione

Il vettore orizzontale di input viene prima moltiplicato per matrice ( *) per un vettore di colonna di quattro (costruito con ~~(1:4)'). Il risultato è una matrice a quattro colonne in cui ogni riga è una copia del vettore di input. Questo viene quindi rimodellato, mantenendo l'ordine lineare degli elementi, in una matrice a 4 colonne ( reshape(...,[],4)). Le due colonne centrali vengono mantenute ( (:,2:3)) e linearizzate in un'unica colonna ( (:)), di cui viene calcolata la media ( mean(...)).

J , 20 18 byte

2 byte grazie a @miles

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

Provalo online! ( Interprete online )

uso

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

Come funziona

È una traduzione della mia risposta in Pyth .

In realtà , 20 15 13 byte

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

Provalo online!

Come funziona

È una traduzione della mia risposta in Pyth .

Ottava, 42 byte

Un'altra funzione anonima per Octave.

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

Puoi provarlo online . Basta inserire quel comando, quindi fare ans([1 2 4 5 6 9])o qualunque numero sia richiesto.

Questo inizia creando dall'array di input uno con 4 di ciascun elemento di input concatenando prima quattro copie verticalmente, quindi appiattendole verticalmente. Ciò mantiene l'ordinamento.

Quindi viene estratto l'intervallo di elementi dalla lunghezza dell'array di input più 1 fino a tre volte la lunghezza dell'array di input. Poiché il nuovo array è quattro volte più lungo, questo taglia i quartili superiore e inferiore.

Alla fine viene restituita la media del nuovo array.

05AB1E, 15 byte

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

Spiegazione

€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

Provalo online

APL (Dyalog) , 15 byte

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

Provalo online!

4∘/ quadruplica ogni elemento

-∘≢↓ elimina tutti gli elementi finali quanti sono gli elementi negli argomenti

≢↓ elimina tutti gli elementi iniziali quanti sono gli elementi nell'argomento

(... ) applica la seguente funzione tacita:

 +/ la somma

 ÷ diviso per

 ≢ il conteggio

JavaScript (ES6), 75 byte

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

Utilizza l'ovvio approccio quadruplicato-e-riordino, e riesco a usarlo reduce, il che è carino. L'unico trucco qui è salvare 4 byte riutilizzando il comparatore di ordinamento per sottrarre tutti gli elementi dell'array da zero, il che mi dà -2lla risposta che desidero.

Golfscript, 28 29 byte

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

Provalo online!

In realtà, 12 byte

4α;l¼≈;±(Htæ

Provalo online! (al momento non funziona perché TIO è indietro di alcune versioni)

Spiegazione:

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 byte

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

Ordina quattro copie dell'elenco (per evitare problemi con lunghezza dell'elenco non multipli di quattro), prende parte "1 quarter the length of resulting list plus 1"al "1/4 length list + 1 from the end", prende il loro Mean.

Java 146 126 byte

Tale java molto prolisso!

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;}

Più vecchio Ungolfed parzialmente leggibile con casi di 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 byte

Modifica: 1 byte in meno riscrivendo la parte "didvide di 2 n".

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

Precedente:

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

Usa forper generare 4 valori ripetuti, usando float per 2.0non avere risultati frazionari, il resto è solo standard.

R, 17 11 byte

mean(n,0.25)

Supponendo che nsia il vettore di input nel modulo R standardn=c(1, 2, 3, ...) .

Ciò non sorprende in quanto R può essere considerato "IL linguaggio per il calcolo statistico" e ha molti incorporati statistici.

AGGIORNARE. 6 byte salvati grazie a rturnbull perché trimè il primo argomento opzionale di default!

Casi 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 byte

=TRIMMEAN(A:A,.5)

Il formato di input rilassato lo rende facile. Inserisci uno per riga nella colonna A.