Sfida

Dato un elenco non vuoto di numeri reali, calcola la sua mediana.

definizioni

La mediana viene calcolata come segue: prima ordina l'elenco,

• se il numero di voci è dispari , la mediana è il valore al centro dell'elenco ordinato,
• altrimenti la mediana è la media aritmetica dei due valori più vicini al centro dell'elenco ordinato.

Esempi

[1,2,3,4,5,6,7,8,9] -> 5
[1,4,3,2] -> 2.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5

Python 2 , 48 byte

Una funzione senza nome che restituisce il risultato. -1 byte grazie a xnor.

lambda l:l.sort()or(l[len(l)/2]+l[~len(l)/2])/2.

Il primo passo è ovviamente quello di ordinare l'array, usando l.sort(). Tuttavia, possiamo avere solo un'istruzione in un lambda, quindi utilizziamo il fatto che la funzione di ordinamento ritorni Noneaggiungendo un or- come Noneè falso in Python, questo le dice di valutare e restituire la parte successiva dell'istruzione.

Ora abbiamo la lista ordinata, dobbiamo trovare i valori centrali o due centrali.

L'uso di un condizionale per verificare la parità della lunghezza sarebbe troppo dettagliato, quindi invece otteniamo gli indici len(l)/2e ~len(l)/2:

• Il primo è floor (lunghezza / 2) , che ottiene l'elemento centrale se la lunghezza è dispari, oppure l'elemento sinistro nella coppia centrale se la lunghezza è pari.
• Il secondo è l'inversione binaria della lunghezza dell'elenco, valutando -1 - piano (lunghezza / 2) . A causa dell'indicizzazione negativa di Python, questo essenzialmente fa lo stesso del primo indice, ma indietro dalla fine dell'array.

Se l'elenco ha una lunghezza dispari, questi indici punteranno allo stesso valore. Se è di lunghezza pari, indicheranno i due elementi centrali.

Ora che abbiamo questi due indici, troviamo questi valori nell'elenco, li sommiamo e li dividiamo per 2. La posizione decimale finale in si /2.assicura che sia divisione float anziché divisione intera.

Il risultato viene restituito implicitamente, poiché si tratta di una funzione lambda.

Provalo online!

Python3 - 31 30 byte

Hai salvato un byte grazie a @Dennis!

Non avevo in programma una risposta integrata , ma ho trovato questo modulo e ho pensato che fosse davvero bello perché non avevo idea che esistesse.

from statistics import*;median

Provalo online qui .

In realtà , 1 byte

║

Provalo online!

Gelatina , 9 byte

L‘HịṢµ÷LS

Provalo online!

Spiegazione

Sto ancora imparando Jelly ... Non sono stato in grado di trovare built-in per la mediana o la media di un elenco, ma è molto conveniente per questa sfida che Jelly permetta indici non interi in elenchi, nel qual caso restituirà una coppia dei due valori più vicini. Ciò significa che possiamo lavorare con la metà della lunghezza dell'input come indice e ottenere una coppia di valori quando dobbiamo mediarlo.

L          Get the length of the input.
 ‘         Increment it.
  H        Halve it. This gives us the index of the median for an odd-length list
           (Jelly uses 1-based indexing), and a half-integer between the two indices
           we need to average for even-length lists.
   ịṢ      Use this as an index into the sorted input. As explained above this will
           either give us the median (in case of an odd-length list) or a pair of
           values we'll now need to average.
     µ     Starts a monadic chain which is then applied to this median or pair...
      ÷L     Divide by the length. L treats atomic values like singleton lists.
        S    Sum. This also treats atomic values like singleton lists. Hence this
             monadic chain leaves a single value unchanged but will return the
             mean of a pair.

Brain-Flak , 914 + 1 = 915 byte

([]){({}[()]<(([])<{({}[()]<([([({}<(({})<>)<>>)<><({}<>)>]{}<(())>)](<>)){({}())<>}{}({}<><{}{}>){{}<>(<({}<({}<>)<>>)<>({}<>)>)}{}({}<>)<>>)}{}<>{}>[()]){({}[()]<({}<>)<>>)}{}<>>)}{}([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>){((<{}{}([[]]()){({}()()<{}>)}{}(({}){}<([]){{}{}([])}{}>)>))}{}{(<{}([[]]()()){({}()()<{}>)}{}({}{}<([]){{}{}([])}{}>)>)}{}([(({}<((((((()()()){}){}){}()){})[()()()])>)<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({}<>)<{(<{}([{}])>)}{}{(({})<((()()()()()){})>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})({}<({}<>)<>>((((()()()){}){}){}){})((()()()()()){})<>({}<>)(()()){({}[()]<([([({})](<()>))](<>())){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({})<>)<>{(<{}([{}])>)}{}({}<>)<>({}<><({}<>)>)>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)<>(({}{}[(())])){{}{}(((<{}>)))}{}{}{(<{}<>([{}])><>)}{}<>}{}>){(<{}(((((()()()()())){}{})){}{})>)}{}

Richiede l' -Aesecuzione della bandiera.

Provalo online!

Spiegazione

La spina dorsale di questo algoritmo è una specie di bolla che ho scritto qualche tempo fa.

([]){({}[()]<(([])<{({}[()]<([([({}<(({})<>)<>>)<><({}<>)>]{}<(())>)](<>)){({}())<>}{}({}<><{}{}>){{}<>(<({}<({}<>)<>>)<>({}<>)>)}{}({}<>)<>>)}{}<>{}>[()]){({}[()]<({}<>)<>>)}{}<>>)}{}

Non ricordo come funziona, quindi non chiedermelo. Ma so che ordina lo stack e funziona anche per i negativi

Dopo che tutto è stato ordinato, trovo 2 volte la mediana con il seguente pezzo

([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>)  #Stack height modulo 2
{((<{}{}          #If odd
 ([[]]())         #Push negative stack height +1
 {                #Until zero 
  ({}()()<{}>)    #add 2 to the stack height and pop one
 }{}              #Get rid of garbage
 (({}){}<         #Pickup and double the top value
 ([]){{}{}([])}{} #Remove everything on the stack
 >)               #Put it back down
>))}{}            #End if
{(<{}                     #If even
  ([[]]()())              #Push -sh + 2
  {({}()()<{}>)}{}        #Remove one value for every 2 in that value
  ({}{}<([]){{}{}([])}{}>)#Add the top two and remove everything under them
>)}{}                     #End if

Ora non resta che convertire in ASCII

([(({}<((((((()()()){}){}){}()){})[()()()])>)<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({}<>)<
{(<{}([{}])>)}{}  #Absolute value (put "/2" beneath everything)

{                 #Until the residue is zero 
(({})<            #|Convert to base 10
((()()()()()){})  #|
>)                #|...
({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})
({}<({}<>)<>>((((()()()){}){}){}){})((()()()()()){})<>({}<>)
                  #|
(()()){({}[()]<([([({})](<()>))](<>())){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({})<>)<>{(<{}([{}])>)}{}({}<>)<>({}<><({}<>)>)>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)<>(({}{}[(())])){{}{}(((<{}>)))}{}{}{(<{}<>([{}])><>)}{}<>
}{}               #|
>)
{(<{}(((((()()()()())){}{})){}{})>)}{}  #If it was negative put a minus sign

R, 6 byte

median

Non sorprende che R, un linguaggio di programmazione statistica, abbia questo incorporato.

MATL , 4 byte

.5Xq

Questo trova lo 0,5-quantile, che è la mediana.

Provalo online!

Pyth - 11 byte

Trova la media dell'elemento centrale preso sia avanti che indietro.

.O@R/lQ2_BS

Test Suite .

Ottava , 38 byte

@(x)mean(([1;1]*sort(x))(end/2+[0 1]))

Questo definisce una funzione anonima. L'input è un vettore di riga.

Provalo online!

Spiegazione

            sort(x)                 % Sort input x, of length k
      [1;1]*                        % Matrix-multiply by column vector of two ones
                                    % This vertically concatenates the sort(x) with 
                                    % itself. In column-major order, this effectively 
                                    % repeats each entry of sort(x)
     (             )(end/2+[0 1])   % Select the entry at position end/2 and the next.
                                    % Entries are indexed in column-major order. Since
                                    % the array has 2*k elements, this picks the k-th 
                                    % and (k+1)-th. Because entries were repeated, for
                                    % odd k this takes the original (k+1)/2-th entry
                                    % (1-based indexing) twice. For even k this takes
                                    % the original (k/2)-th and (k/2+1)-th entries
mean(                            )  % Mean of the two selected entries

JavaScript, 57 52 byte

v=>(v.sort((a,b)=>a-b)[(x=v.length)>>1]+v[--x>>1])/2

Ordina l'array numericamente. Se l'array ha una lunghezza pari, trova i 2 numeri medi e fai una media. Se l'array è dispari, trova il numero medio due volte e dividi per 2.

Matlab / Octave, 6 byte

Un noioso built-in:

median

Provalo online!

Mathematica, 6 byte

Median

Non appena ho scoperto Mthmtca , sto pubblicando una soluzione.

Perl 6 , 31 byte

*.sort[{($/=$_/2),$/-.5}].sum/2

Provalo

Allargato:

*\     # WhateverCode lambda ( this is the parameter )

.sort\ # sort it

[{     # index into the sorted list using a code ref to calculate the positions

  (
    $/ = $_ / 2 # the count of elements divided by 2 stored in ｢$/｣
  ),            # that was the first index

  $/ - .5       # subtract 1/2 to get the second index

                # indexing operations round down to nearest Int
                # so both are effectively the same index if given
                # an odd length array

}]\

.sum / 2        # get the average of the two values

APL (Dyalog Unicode) , 14 byte

≢⊃2+/2/⊂∘⍋⌷÷∘2

Provalo online!

Questo è un treno Il dfn originale era {(2+/2/⍵[⍋⍵])[≢⍵]÷2}.

Il treno è strutturato come segue

┌─┼───┐
≢ ⊃ ┌─┼───┐
    2 / ┌─┼───┐
    ┌─┘ 2 / ┌─┼─┐
    +       ∘ ⌷ ∘
           ┌┴┐ ┌┴┐
           ⊂ ⍋ ÷ 2

⊢ indica l'argomento giusto.

⌷ indice

• ⊂∘⍋gli indici indicizzati in ⊢risultati ⊢vengono ordinati

• ÷∘2in ⊢diviso 2

2/replicalo due volte, così 1 5 7 8diventa1 1 5 5 7 7 8 8

2+/ prendi la somma a coppie, questo diventa (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ da questa scelta

• ≢ elemento con indice uguale alla lunghezza di ⊢

Soluzioni precedenti

{.5×+/(⍵[⍋⍵])[(⌈,⌊).5×1+≢⍵]}
{+/(2/⍵[⍋⍵]÷2)[0 1+≢⍵]}
{+/¯2↑(1-≢⍵)↓2/⍵[⍋⍵]÷2}
{(2+/2/⍵[⍋⍵])[≢⍵]÷2}
{(≢⍵)⊃2+/2/⍵[⍋⍵]÷2}
≢⊃2+/2/2÷⍨⊂∘⍋⌷⊢
≢⊃2+/2/⊂∘⍋⌷÷∘2

Lisp comune, 89

(lambda(s &aux(m(1-(length s)))(s(sort s'<)))(/(+(nth(floor m 2)s)(nth(ceiling m 2)s))2))

Calcolo la media degli elementi in posizione (floor middle)e (ceiling middle), dove si middletrova l'indice in base zero per l'elemento centrale dell'elenco ordinato. È possibile middleessere un numero intero, come 1per un elenco di input di dimensione 3 come (10 20 30), o una frazione per elenchi con un numero pari di elementi, come 3/2per (10 20 30 40). In entrambi i casi, calcoliamo il valore mediano atteso.

(lambda (list &aux
             (m (1-(length list)))
             (list (sort list #'<)))
  (/ (+ (nth (floor m 2) list)
        (nth (ceiling m 2) list))
     2))

Vim, 62 byte

Inizialmente l'ho fatto in V usando solo la manipolazione del testo fino alla fine, ma mi sono frustrato nel gestire [X] e [X, Y], quindi ecco la versione semplice. Hanno circa la stessa lunghezza.

c$:let m=sort(")[(len(")-1)/2:len(")/2]
=(m[0]+m[-1])/2.0

Provalo online!

Unprintables:

c$^O:let m=sort(^R")[(len(^R")-1)/2:len(^R")/2]
^R=(m[0]+m[-1])/2.0

Menzione d'onore:

• ^O ti porta fuori dalla modalità di inserimento per un comando (il comando let).
• ^R" inserisce il testo che è stato strappato (in questo caso l'elenco)

TI-Basic, 2 byte

median(Ans

Molto semplice.

C #, 126 byte

using System.Linq;float m(float[] a){var x=a.Length;return a.OrderBy(g=>g).Skip(x/2-(x%2==0?1:0)).Take(x%2==0?2:1).Average();}

Abbastanza semplice, qui con LINQ per ordinare i valori, saltare metà dell'elenco, prendere uno o due valori a seconda di pari / dispari e mediali.

C ++ 112 byte

Grazie a @ original.legin per avermi aiutato a salvare i byte.

#include<vector>
#include<algorithm>
float a(float*b,int s){std::sort(b,b+s);return(b[s/2-(s&1^1)]+b[s/2])/2;}

Uso:

    int main()
    {
        int n = 4;
        float e[4] = {1,4,3,2};
        std::cout<<a(e,n); /// Prints 2.5

        n = 9;
        float e1[9] = {1,2,3,4,5,6,7,8,9};
        std::cout<<a(e1,n); /// Prints 5

        n = 13;
        float e2[13] = {1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4};
        std::cout<<a(e2,n); /// Prints 1.5

        return 0;
    }

J , ₁₆ 14 byte

2%~#{2#/:~+\:~

Provalo online!

Oltre al trucco di duplicazione dell'array della BMO , ho scoperto che possiamo aggiungere l'intero array ordinato in due direzioni. Poi mi sono reso conto che i due passaggi possono essere invertiti, cioè aggiungere i due array, quindi duplicarli e prendere l' nelemento th.

Come funziona

2%~#{2#/:~+\:~
                Input: array of length n
       /:~      Sort ascending
           \:~  Sort descending
          +     Add the two element-wise
     2#         Duplicate each element
   #{           Take n-th element
2%~             Halve

Risposte precedenti

J con statsaddon, 18 byte

load'stats'
median

Provalo online!

Funzione libreria FTW.

medianL'implementazione si presenta così:

J , 31 byte

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)

Provalo online!

Come funziona

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)
         (<.,>.)@(-:@<:@#)       Find center indices:
                  -:@<:@#          Compute half of given array's length - 1
          <.,>.                    Form 2-element array of its floor and ceiling
                          {/:~   Extract elements at those indices from sorted array
-:@(+/)                          Sum and half

Un po 'di golf dà questo:

J , 28 byte

2%~[:+/(<.,>.)@(-:@<:@#){/:~

Provalo online!

J, 19 byte

<.@-:@#{(/:-:@+\:)~

Spiegazione:

        (        )~   apply monadic argument twice to dyadic function 
         /:           /:~ = sort the list upwards
               \:     \:~ = sort the list downwards
           -:@+       half of sum of both lists, element-wise
<.@-:@#               floor of half of length of list
       {              get that element from the list of sums

JavaScript, 273 byte

function m(l){a=(function(){i=l;o=[];while(i.length){p1=i[0];p2=0;for(a=0;a<i.length;a++)if(i[a]<p1){p1=i[a];p2=a}o.push(p1);i[p2]=i[i.length-1];i.pop()}return o})();return a.length%2==1?l[Math.round(l.length/2)-1]:(l[Math.round(l.length/2)-1]+l[Math.round(l.length/2)])/2}

Java 7, 99 byte

golfed:

float m(Float[]a){java.util.Arrays.sort(a);int l=a.length;return l%2>0?a[l/2]:(a[l/2-1]+a[l/2])/2;}

Ungolfed:

float m(Float[] a)
{
    java.util.Arrays.sort(a);
    int l = a.length;
    return l % 2 > 0 ? a[l / 2] : (a[l / 2 - 1] + a[l / 2]) / 2;
}

Provalo online

Pari / GP - 37 39 byte

Facciamo un essere un rowvector contenente i valori.

b=vecsort(a);n=#b+1;(b[n\2]+b[n-n\2])/2  \\ 39 byte              

n=1+#b=vecsort(a);(b[n\2]+b[n-n\2])/2    \\ obfuscated but only 37 byte

Poiché Pari / GP è interattivo, non è necessario alcun comando aggiuntivo per visualizzare il risultato.

a=vector(8,r,random(999))           
n=1+#b=vecsort(a);w=(b[n\2]+b[n-n\2])/2      
print(a);print(b);print(w)       

Provalo online!

Japt, 20 byte

n gV=0|½*Ul)+Ug~V)/2

Provalo online! Japt manca davvero di tutti gli elementi necessari per creare una risposta molto breve per questa sfida ...

Spiegazione

n gV=0|½*Ul)+Ug~V)/2  // Implicit: U = input list
n                     // Sort U.
   V=0|½*Ul)          // Set variable V to floor(U.length / 2).
  g                   // Get the item at index V in U.
            +Ug~V     // Add to that the item at index -V - 1 in U.
                 )/2  // Divide by 2 to give the median.
                      // Implicit: output result of last expression

Java 8, 71 byte

La parità è divertente! Ecco un lambda da double[]a Double.

l->{java.util.Arrays.sort(l);int s=l.length;return(l[s/2]+l[--s/2])/2;}

Non succede nulla di troppo complesso qui. L'array viene ordinato, quindi prendo la media di due numeri dall'array. Esistono due casi:

• Se la lunghezza è pari, il primo numero viene preso da poco prima della metà dell'array e il secondo numero viene preso dalla posizione precedente per divisione intera. La media di questi numeri è la mediana dell'input.
• Se la lunghezza è dispari sed s-1entrambi si dividono per l'indice dell'elemento centrale. Il numero viene aggiunto a se stesso e il risultato viene diviso per due, ottenendo il valore originale.

Provalo online

SmileBASIC, 45 byte

DEF M A
L=LEN(A)/2SORT A?(A[L-.5]+A[L])/2
END

Ottiene la media degli elementi a pavimento (lunghezza / 2) e pavimento (lunghezza / 2-0,5) Molto semplice, ma sono stato in grado di salvare 1 byte spostando le cose:

DEF M A
SORT A    <- extra line break
L=LEN(A)/2?(A[L-.5]+A[L])/2
END

Buccia , 10 byte

½ΣF~e→←½OD

Provalo online!

Spiegazione

$[a_1 \dots a_N]$$[a_1 \; a_1 \dots a_N \; a_N]$

½ΣF~e→←½OD  -- example input: [2,3,4,1]
         D  -- duplicate: [2,3,4,1,2,3,4,1]
        O   -- sort: [1,1,2,2,3,3,4,4]
       ½    -- halve: [[1,1,2,2],[3,3,4,4]]
  F         -- fold the following
   ~        -- | compose the arguments ..
     →      -- | | last element: 2
      ←     -- | | first element: 3
    e       -- | .. and create list: [2,3]
            -- : [2,3]
 Σ          -- sum: 5
½           -- halve: 5/2

_{Sfortunatamente ½per gli elenchi ha il tipo [a] -> [[a]]e non è [a] -> ([a],[a])ciò che non consente F~+→←dal momento che ha foldl1bisogno di una funzione di tipo a -> a -> acome primo argomento, costringendomi a usarlo e.}

R senza usare l' medianintegrato, 51 byte

function(x,n=sum(x|1)+1)mean(sort(x)[n/2+0:1*n%%2])

Provalo online!

GolfScript , 27 25 20 17 byte

~..+$\,(>2<~+"/2"

Accetta l'input come una matrice di numeri interi su stdin. Output come una frazione non ridotta. Provalo online!

Spiegazione

$l$$l-1$$l$

~                  Evaluate input (converting string -> array)
 ..                Duplicate twice
   +               Concatenate two of the copies
    $              Sort the doubled array
     \,            Swap with the non-doubled array and get its length: l
       (           Decrement: l-1
        >          Array slice: all elements at index (l-1) and greater
         2<        Array slice: first two elements (originally at indices l-1 and l)
           ~       Dump array elements to stack
            +      Add
             "/2"  Push that string
                   Output all items on stack without separator

L'output sarà qualcosa di simile 10/2.