Wyzwanie

Biorąc pod uwagę niepustą listę liczb rzeczywistych, oblicz jej medianę.

Definicje

Mediana jest obliczana w następujący sposób: Najpierw posortuj listę,

• jeśli liczba wpisów jest nieparzysta , mediana jest wartością na środku posortowanej listy,
• w przeciwnym razie mediana jest średnią arytmetyczną dwóch wartości znajdujących się najbliżej środka posortowanej listy.

Przykłady

[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 bajtów

Funkcja bez nazwy, która zwraca wynik. -1 bajt dzięki xnor.

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

Pierwszym krokiem jest oczywiście posortowanie tablicy za pomocą l.sort(). Możemy jednak mieć tylko jedną instrukcję w lambda, dlatego wykorzystujemy fakt, że funkcja sortowania zwraca wartość Nonedodając or- podobnie jak Nonefalsy w Pythonie, co nakazuje jej ocenę i zwrócenie następnej części instrukcji.

Teraz mamy posortowaną listę, musimy znaleźć środkową lub środkową dwie wartości.

Używanie warunkowego sprawdzania parzystości długości byłoby zbyt szczegółowe, więc zamiast tego otrzymujemy indeksy len(l)/2i ~len(l)/2:

• Pierwszą jest podłoga (długość / 2) , która otrzymuje środkowy element, jeśli długość jest nieparzysta, lub lewy element w środkowej parze, jeśli długość jest równa.
• Drugi to binarna inwersja długości listy, której wynikiem jest -1 - floor (length / 2) . Ze względu na ujemne indeksowanie Pythona, robi to w zasadzie to samo co pierwszy indeks, ale wstecz od końca tablicy.

Jeśli lista ma nieparzystą długość, indeksy te wskażą tę samą wartość. Jeśli jest równej długości, będą wskazywać na środkowe dwa elementy.

Teraz, gdy mamy te dwa indeksy, znajdujemy te wartości na liście, sumujemy je i dzielimy przez 2. Końcowe miejsce po przecinku /2.zapewnia, że ​​jest to dzielenie zmiennoprzecinkowe, a nie dzielenie całkowite.

Wynik jest domyślnie zwracany, ponieważ jest to funkcja lambda.

Wypróbuj online!

Python3 - 31 30 bajtów

Zapisano bajt dzięki @Dennis!

Nie planowałem wbudowanej odpowiedzi, ale znalazłem ten moduł i pomyślałem, że to naprawdę fajne, ponieważ nie miałem pojęcia, że ​​istnieje.

from statistics import*;median

Wypróbuj online tutaj .

Właściwie 1 bajt

║

Wypróbuj online!

Galaretka , 9 bajtów

L‘HịṢµ÷LS

Wypróbuj online!

Wyjaśnienie

Wciąż mam problemy z galaretką ... Nie byłem w stanie znaleźć wbudowanych mediany ani środka listy, ale jest to bardzo wygodne dla tego wyzwania, że ​​Jelly pozwala indeksom niecałkowitym na listy, w takim przypadku zwróci parę dwóch najbliższych wartości. Oznacza to, że możemy pracować z połową długości wejściowej jako indeksem i uzyskać parę wartości, gdy musimy ją uśrednić.

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 bajtów

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

Wymaga -Aflagi do uruchomienia.

Wypróbuj online!

Wyjaśnienie

Podstawą tego algorytmu jest bąbelkowy rodzaj, który napisałem jakiś czas temu.

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

Nie pamiętam, jak to działa, więc nie pytaj mnie. Ale wiem, że sortuje stos, a nawet działa na negatywy

Po uporządkowaniu wszystkiego znajduję 2 razy medianę z następującą porcją

([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>)  #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

Teraz pozostało tylko przekonwertować na 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 bajtów

median

Nic dziwnego, że R, statystyczny język programowania, ma to wbudowane.

MATL , 4 bajty

.5Xq

Znajduje to 0,5-kwantyl, który jest medianą.

Wypróbuj online!

Pyth - 11 bajtów

Znajduje średnią środkowego elementu wykonanego zarówno do tyłu, jak i do przodu.

.O@R/lQ2_BS

Pakiet testowy .

Oktawa , 38 bajtów

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

Definiuje to anonimową funkcję. Dane wejściowe to wektor wiersza.

Wypróbuj online!

Wyjaśnienie

            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 bajtów

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

Posortuj tablicę numerycznie. Jeśli tablica ma równą długość, znajdź 2 środkowe liczby i uśrednij je. Jeśli tablica jest nieparzysta, znajdź środkową liczbę dwa razy i podziel przez 2.

Matlab / Octave, 6 bajtów

Nudne wbudowane:

median

Wypróbuj online!

Mathematica, 6 bajtów

Median

Jak tylko odkryję Mthmtca , zamieszczam w nim rozwiązanie.

Perl 6 , 31 bajtów

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

Spróbuj

Rozszerzony:

*\     # 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 bajtów

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

Wypróbuj online!

To jest pociąg. Pierwotny dfn był {(2+/2/⍵[⍋⍵])[≢⍵]÷2}.

Pociąg ma następującą strukturę

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

⊢ oznacza właściwy argument.

⌷ indeks

• ⊂∘⍋indeksy indeksowane do ⊢wyników ⊢są sortowane

• ÷∘2w ⊢podzielonej przez 2

2/powtórz to dwa razy, tak 1 5 7 8się stanie1 1 5 5 7 7 8 8

2+/ weź sumę par, staje się (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ z tego wyboru

• ≢ element o indeksie równym długości ⊢

Poprzednie rozwiązania

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

Common Lisp, 89

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

Obliczam średnią z elementów na pozycji, (floor middle)a (ceiling middle)gdzie middlejest liczony od zera indeks środkowego elementu posortowanej listy. Możliwe jest, middleaby być liczbą całkowitą, na przykład 1dla listy danych wejściowych o rozmiarze 3, na przykład (10 20 30), lub ułamkiem dla list z parzystą liczbą elementów, na przykład 3/2dla (10 20 30 40). W obu przypadkach obliczamy oczekiwaną wartość mediany.

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

Vim, 62 bajty

Zrobiłem to początkowo w V, używając do końca tylko manipulacji tekstem, ale byłem sfrustrowany obsługą [X] i [X, Y], więc oto prosta wersja. Są mniej więcej tej samej długości.

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

Wypróbuj online!

Materiały niedrukowalne:

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

Wyróżnienie:

• ^O wyjdzie z trybu wstawiania dla jednego polecenia (polecenie let).
• ^R" wstawia szarpany tekst (w tym przypadku listę)

TI-Basic, 2 bajty

median(Ans

Bardzo proste.

C #, 126 bajtów

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

Całkiem proste, tutaj z LINQ, aby uporządkować wartości, pominąć połowę listy, wziąć jedną lub dwie wartości w zależności od parzystości / nieparzystości i uśrednić je.

C ++ 112 bajtów

Dzięki @ original.legin za pomoc w oszczędzaniu bajtów.

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

Stosowanie:

    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 bajtów

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

Wypróbuj online!

Oprócz sztuczki BMO polegającej na powielaniu tablic odkryłem, że możemy dodać całą tablicę posortowaną w dwóch kierunkach. Potem zdałem sobie sprawę, że dwa kroki można odwrócić, tj. Dodać dwie tablice, a następnie powielić je i wziąć ten nelement.

Jak to działa

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

Poprzednie odpowiedzi

J z statsdodatkiem, 18 bajtów

load'stats'
median

Wypróbuj online!

Funkcja biblioteki FTW.

medianImplementacja wygląda następująco:

J , 31 bajtów

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

Wypróbuj online!

Jak to działa

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)
         (<.,>.)@(-:@<:@#)       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

Trochę gry w golfa daje:

J , 28 bajtów

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

Wypróbuj online!

J, 19 bajtów

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

Wyjaśnienie:

        (        )~   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 bajtów

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 bajtów

Gra w golfa:

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

Nie golfowany:

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

Wypróbuj online

Pari / GP - 37 39 bajtów

Niech być rowvector zawierające wartości.

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

Ponieważ Pari / GP jest interaktywny, nie jest potrzebne dodatkowe polecenie do wyświetlenia wyniku.

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)       

Wypróbuj online!

Japt, 20 bajtów

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

Przetestuj online! Japt naprawdę nie ma żadnych wbudowanych potrzebnych do stworzenia naprawdę krótkiej odpowiedzi na to wyzwanie ...

Wyjaśnienie

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 bajtów

Parzystość jest fajna! Oto lambda od double[]do Double.

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

Nie dzieje się tu nic skomplikowanego. Tablica jest sortowana, a następnie biorę średnią z dwóch liczb z tablicy. Istnieją dwa przypadki:

• Jeśli długość jest parzysta, to pierwsza liczba jest pobierana tuż przed środkiem tablicy, a druga liczba jest pobierana z pozycji przed nią przez dzielenie liczb całkowitych. Średnia z tych liczb jest medianą danych wejściowych.
• Jeśli długość jest nieparzysta si s-1oba dzielą się na indeks środkowego elementu. Liczba jest dodawana do siebie, a wynik dzielony przez dwa, dając pierwotną wartość.

Wypróbuj online

SmileBASIC, 45 bajtów

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

Pobiera średnią z elementów na podłodze (długość / 2) i podłodze (długość / 2-0,5) Bardzo proste, ale udało mi się zaoszczędzić 1 bajt, przenosząc rzeczy:

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

Łuska , 10 bajtów

½ΣF~e→←½OD

Wypróbuj online!

Wyjaśnienie

$[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

_{Niestety ½dla list ma typ, [a] -> [[a]]a [a] -> ([a],[a])który nie pozwala, F~+→←ponieważ foldl1potrzebuje funkcji typu a -> a -> ajako pierwszego argumentu, zmuszając mnie do użycia e.}

R bez użycia medianwbudowanego 51 bajtów

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

Wypróbuj online!

GolfScript , 27 25 20 17 bajtów

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

Pobiera dane wejściowe jako tablicę liczb całkowitych na stdin. Wyjścia jako ułamek nieredukowany. Wypróbuj online!

Wyjaśnienie

$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

Wynik będzie podobny 10/2.