(un paradosso, un paradosso, un paradosso molto geniale)

Questa è la prima parte di una serie multipart ispirata a diverse funzioni R.

L'obiettivo

Dato un insieme di dati $D$ di interi positivi, ho bisogno di calcolare il sommario 5 il numero di $D$ . Tuttavia, sto lavorando su set di dati di grandi dimensioni, quindi ho bisogno che il tuo codice sia il più piccolo possibile, permettendomi di memorizzarlo sul mio computer.

Il riepilogo dei cinque numeri è composto da:

• Valore minimo
• Primo quartile (Q1)
• Mediana / Secondo quartile (Q2)
• Terzo quartile (Q3)
• Valore massimo

Esistono diversi modi per definire i quartili, ma useremo quello implementato da R:

definizioni:

• Minimo e massimo: i valori più piccoli e più grandi, rispettivamente.
• Mediana: il valore medio se $D$ ha un numero dispari di voci e la media aritmetica dei due valori più centrali se ha un numero pari di voci. Si noti che ciò significa che la mediana può essere un valore non intero. In precedenza abbiamo dovuto calcolare la mediana .$D$
• Primo e terzo quartile: dividi i dati in due metà, incluso l'elemento centrale in ogni metà se ha un numero dispari di voci e trova il valore mediano di ciascuna metà. La mediana della metà inferiore è il primo quartile e la mediana della metà superiore è il terzo quartile.$D$

Esempi:

$D=[1,2,3,4,5]$3 . La mediana è quindi e la metà inferiore è [ 1 , 2 , 3 ] , producendo un primo quartile di 2 , e la metà superiore è [ 3 , 4 , 5 ] , producendo un terzo quartile di 4 .$3$$[1,2,3]$$2$$[3,4,5]$$4$

$D=[1,3,3,4,5,6,7,10]$ . La mediana è$4.5$ e la metà inferiore è$[1,3,3,4]$ , producendo un primo quartile di$3$ , e la metà superiore è$[5,6,7,10]$ , producendo un terzo quartile di$6.5$ .

Regole aggiuntive:

• L'input è un array o l'equivalente più vicino della tua lingua.
• Si può presumere che l'array sia ordinato in ordine crescente o decrescente (ma specificare quale).
• Puoi restituire / stampare i risultati in qualsiasi ordine coerente e in qualsiasi formato flessibile ti piaccia, ma ti preghiamo di indicare l'ordine e il formato nella tua risposta.
• fivenumSono ammesse funzioni integrate equivalenti a , ma implementa anche la tua soluzione.
• Si può non assumere ciascuno dei cinque numeri sarà un numero intero.
• Le spiegazioni sono incoraggiate.
• Questo è code-golf , quindi vince la risposta più breve in ogni lingua!

Casi di test generati casualmente

1 1 1 1 1 2 2 2 2 2 3 3 4 4 4 4 4 5 5 5 -> 1 1.5 2.5 4 5 
1 2 2 2 4 4 5 5 6 7 7 8 9 9 9 9 9 10 10 10 -> 1 4 7 9 10 
2 2 2 6 8 10 15 16 21 22 23 24 26 33 35 38 38 45 46 47 48 -> 2 10 23 38 48 
1 2 9 -> 1 1.5 2 5.5 9 
1 2 3 3 3 4 9 -> 1 2.5 3 3.5 9
1 1 2 5 7 7 8 8 15 16 18 24 24 26 26 27 27 28 28 28 29 29 39 39 40 45 46 48 48 48 48 49 50 52 60 63 72 73 79 85 86 87 88 90 91 93 94 95 95 97 100 -> 1 25 45 76 100
2 2 4 4 6 8 10 11 13 14 14 15 17 21 23 24 26 27 27 28 28 30 31 33 33 34 36 36 38 38 39 40 41 42 42 43 45 45 47 47 47 47 47 48 48 48 50 51 53 53 55 56 56 56 57 57 58 62 62 63 64 64 65 65 66 67 67 67 68 69 69 71 71 71 74 79 80 81 81 81 82 82 83 83 86 86 86 87 89 94 94 94 95 95 97 98 99 100 100 100 -> 2 33.5 54 76.5 100
1 3 3 4 -> 1 2 3 3.5 4
1 3 3 3 4 -> 1 3 3 3 4

R , 7 byte

fivenum

Provalo online!

Risposta sfacciata ovvia. ;-)

È interessante notare che fivenum(x)non è equivalente summary(x)anche quando xè numerico, poiché i quantili sono calcolati in modo diverso: fivenummedie alle discontinuità, mentre summaryinterpola. Puoi forzare summarya comportarti come fivenumcon l'opzione quantile.type, ma questo è ancora più lungo di

R , 51 byte

function(x)quantile(x,(0:4)/4,t=2+5*!sum(!!x)%%4-3)

Provalo online!

t=2$n\equiv 3\pmod 4$

Si noti che il codice sorgente del fivenumbuilt-in è molto diverso (e molto più lungo).

MATL , 18 byte

tno?t.5Xqh]5:q4/Xq

L'ordine di uscita è in aumento, come nei casi di test.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

MATL, come MATLAB, calcola i quantili usando l'interpolazione lineare se necessario (proprio come specificato nella sfida per la mediana). Per ottenere il comportamento richiesto per il primo e il terzo quartile, è sufficiente ripetere la mediana se la lunghezza dell'input è dispari. Quindi i risultati sono solo i quantili 0, .25, .5, .75 e 1.

t       % Implicit input: numeric row array. Duplicate
no      % Length, parity
?       % If not zero (that is, if input length is odd)
  .5    %   Push .5
  Xq    %   .5-quantile: median. For even length it behaves as required
  h     %   Concatenate horizontally
]       % End
5:q     % Push [0 1 2 3 4]
4/      % Divide by 4, element-wise: gives [0 .25 .5 .75 1]
Xq      % [0 .25 .5 .75 1]-quantiles. Implicit display

Gelatina , 13 byte

œs2a\;WÆṁ;Ḣ;Ṫ

Provalo online!

Ordina: [Q1, Q3, Q2/med, min, max].

Python 3.8 (pre-release) , 66 byte

lambda l:[(l[~-i//4]+l[-~i//4])/2for i in[1,n:=len(l),~n-n,~n,-3]]

Provalo online!

Ingresso e uscita sono in ordine crescente.

Python 3.8, 97 byte

lambda l:[l[0],l[-1]]+[(i[x(i)//2]+i[~x(i)//2])/2for i in(l[:~((x:=len)(l)//2-1)],l,l[x(l)//2:])]

Ciò presuppone che l'elenco di input sia ordinato in ordine crescente. fè la funzione per restituire il riepilogo a 5 numeri.

$\{min, max, Q1, Q2,Q3\}$

Ho tolto qualche byte prendendo alcuni suggerimenti dalla risposta di FlipTack a Calcola la mediana.

Provalo online!

Come funziona?

lambda l:
    [l[0],l[-1]] # The minimum and maximum, because l is assumed to be sorted in ascending order
    +[(i[x(i)//2]+i[~x(i)//2])/2 # This line computes the median...
    for i in(l[:~((x:=len)(l)//2-1)],l,l[x(l)//2:])] # ...for each of these lists (the first half, the overall list, and the second half)
    # The (x:=len) is an assignment expression from Python 3.8.
    # It assigns the len function to the variable x but also returns len.
    # Therefore, x can be used as len to save a byte (yes, just one byte)

Carbone , 33 byte

≔⊖ＬθηＩＥ⟦⁰⊘÷η²⊘η⁻η⊘÷η²η⟧⊘⁺§θ⌊ι§θ⌈ι

Provalo online! Il collegamento è alla versione dettagliata del codice. Emette in ordine crescente o decrescente a seconda che l'input sia in ordine crescente o decrescente. Spiegazione:

≔⊖Ｌθη

Ottieni l'indice dell'ultimo elemento.

ＩＥ

Mappare sugli elementi dell'array seguente e trasmettere il risultato su stringa per la stampa implicita su linee separate.

⟦⁰⊘÷η²⊘η⁻η⊘÷η²η⟧

Calcola le posizioni degli elementi quartili, dove un extra 0.5indica che il valore è la media di due elementi adiacenti.

⊘⁺§θ⌊ι§θ⌈ι

Calcola il quartile in ciascuna posizione prendendo la media dei valori al piano e al soffitto della posizione.

Ruby 2.7-preview1 , 59 byte

Una porta ripoff diretta della risposta Python di xnor .

->a{[1,n=a.size,~n-n,~n,-3].map{(a[~-@1/4]+a[-~@1/4])/2.0}}

Provalo online! (un byte in più poiché TiO utilizza Ruby 2.5 e non ha parametri di blocco numerati, ad es @1.).

C (gcc) , 123 121 119 byte

-2 grazie a ceilingcat.

Presuppone un elenco ordinato in ordine crescente.

Uscite in ordine: min, Q1, Q2, Q3, max.

#define M(K,x)(K[~-x/2]+K[x/2])/2.,
f(L,n,m)int*L;{m=n-n/2;printf("%d %f %f %f %d",*L,M(L,m)M(L,n)M((L+n/2),m)L[n-1]);}

Provalo online!

05AB1E , 18 byte

2F2äнIR})€ÅmIWsà‚«

Uscita-ordine è: [Q1, Q3, Q2, min, max].

Provalo online o verifica tutti i casi di test . (Ho aggiunto un ordinamento {per la suite di test, quindi i casi di test sono più facili da verificare nell'ordine [min, Q1, Q2, Q3, max].)

Spiegazione:

2F                 # Loop 2 times:
  2ä               #  Split the list at the top of the stack into two halves
                   #  (which is the (implicit) input-list in the first iteration)
    н              #  Only leave the first halve
     IR            #  Push the input in reverse
       })          # After the loop: wrap all three lists into a list
         €         # For each of the lists:
          Åm       #  Get the middle/median depending on the parity of the size of the list
            I      # Then push the input-list again
             W     # Get the minimum (without popping)
              s    # Swap to get the input-list again
               à   # Get the maximum (by popping the list)
                ‚  # Pair the min-max together to a pair
                 « # And merge both lists together
                   # (after which the result is output implicitly)