Herausforderung

Berechnen Sie bei einer nicht leeren Liste reeller Zahlen den Median.

Definitionen

Der Median wird wie folgt berechnet: Sortieren Sie zuerst die Liste,

• Wenn die Anzahl der Einträge ungerade ist , ist der Median der Wert in der Mitte der sortierten Liste.
• Andernfalls ist der Median das arithmetische Mittel der beiden Werte, die der Mitte der sortierten Liste am nächsten liegen.

Beispiele

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

Eine unbenannte Funktion, die das Ergebnis zurückgibt. -1 Byte dank xnor.

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

Der erste Schritt ist natürlich das Sortieren des Arrays mit l.sort(). In einem Lambda kann es jedoch nur eine Anweisung geben. Wir nutzen daher die Tatsache, dass die Sortierfunktion Nonedurch Hinzufügen eines or- wie Nonein Python falsch - zurückgibt, um den nächsten Teil der Anweisung auszuwerten und zurückzugeben.

Jetzt haben wir die sortierte Liste, wir müssen entweder die mittleren oder die mittleren zwei Werte finden.

Die Verwendung einer Bedingung zur Überprüfung der Längenparität wäre zu ausführlich. Stattdessen erhalten wir die Indizes len(l)/2und ~len(l)/2:

• Das erste ist floor (Länge / 2) , das das mittlere Element erhält, wenn die Länge ungerade ist, oder das linke Element im mittleren Paar, wenn die Länge gerade ist.
• Die zweite ist die binäre Inversion der Listenlänge und ergibt -1 - Etage (Länge / 2) . Aufgrund der negativen Indizierung von Python entspricht dies im Wesentlichen dem ersten Index, jedoch rückwärts vom Ende des Arrays.

Wenn die Liste ungerade lang ist, zeigen diese Indizes auf denselben Wert. Wenn es von gerader Länge ist, werden sie auf die beiden zentralen Elemente verweisen.

Nachdem wir diese beiden Indizes haben, finden wir diese Werte in der Liste, addieren sie und dividieren sie durch 2. Die nachfolgende Dezimalstelle in /2.stellt sicher, dass es sich um eine Gleitkommadivision und nicht um eine Ganzzahldivision handelt.

Das Ergebnis wird implizit zurückgegeben, da dies eine Lambda-Funktion ist.

Probieren Sie es online!

Python3 - 31 30 Bytes

Dank @Dennis ein Byte gespart!

Ich hatte keine eingebaute Antwort geplant, aber ich fand dieses Modul und fand es wirklich cool, weil ich keine Ahnung hatte, dass es existiert.

from statistics import*;median

Probieren Sie es hier online aus .

Tatsächlich 1 Byte

║

Probieren Sie es online!

Gelee , 9 Bytes

L‘HịṢµ÷LS

Probieren Sie es online!

Erläuterung

Ich habe immer noch den Dreh raus von Jelly ... Ich konnte weder für den Median noch für den Mittelwert einer Liste integrierte Werte finden, aber für diese Herausforderung ist es sehr praktisch, dass Jelly nicht ganzzahlige Indizes in Listen zulässt. In diesem Fall wird ein Paar der beiden nächsten Werte zurückgegeben. Das heißt, wir können mit der halben Eingabelänge als Index arbeiten und ein Wertepaar abrufen, wenn wir einen Durchschnitt bilden müssen.

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 Bytes

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

Benötigt die -AFlagge zu laufen.

Probieren Sie es online!

Erläuterung

Das Rückgrat dieses Algorithmus ist eine Blasensorte, die ich vor einiger Zeit geschrieben habe.

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

Ich erinnere mich nicht, wie das funktioniert, also frag mich nicht. Aber ich weiß, dass es den Stapel sortiert und sogar für Negative funktioniert

Nachdem alles sortiert wurde, finde ich 2 mal den Median mit dem folgenden Chunk

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

Jetzt müssen Sie nur noch in ASCII konvertieren

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

median

Es ist nicht verwunderlich, dass R, eine statistische Programmiersprache, über diese Funktion verfügt.

MATL , 4 Bytes

.5Xq

Dies findet das 0,5-Quantil, das der Median ist.

Probieren Sie es online!

Pyth - 11 Bytes

Ermittelt den Durchschnitt des mittleren Elements, der sowohl vorwärts als auch rückwärts aufgenommen wurde.

.O@R/lQ2_BS

Test Suite .

Oktave , 38 Bytes

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

Dies definiert eine anonyme Funktion. Die Eingabe ist ein Zeilenvektor.

Probieren Sie es online!

Erläuterung

            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 Bytes

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

Sortieren Sie das Array numerisch. Wenn das Array eine gerade Länge hat, ermitteln Sie die 2 mittleren Zahlen und mitteln Sie sie. Wenn das Array ungerade ist, suchen Sie die mittlere Zahl zweimal und dividieren Sie durch 2.

Matlab / Octave, 6 Bytes

Ein langweiliges eingebautes:

median

Probieren Sie es online!

Mathematica, 6 Bytes

Median

Sobald ich Mthmtca herausgefunden habe , veröffentliche ich eine Lösung darin.

Perl 6 , 31 Bytes

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

Versuch es

Erweitert:

*\     # 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

Probieren Sie es online!

Das ist ein Zug. Die ursprüngliche DFN war {(2+/2/⍵[⍋⍵])[≢⍵]÷2}.

Der Zug ist wie folgt aufgebaut

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

⊢ bezeichnet das richtige Argument.

⌷ Index

• ⊂∘⍋die Indizes , die in indexiert ⊢in Ergebnisse ⊢werden sortiert

• ÷∘2in ⊢geteilt durch 2

2/replizieren Sie dies zweimal, so 1 5 7 8wird1 1 5 5 7 7 8 8

2+/ nimm die paarweise Summe, das wird (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ von dieser Auswahl

• ≢ Element mit Index gleich der Länge von ⊢

Bisherige Lösungen

{.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))

Ich berechne den Mittelwert der Elemente an Position (floor middle)und (ceiling middle), wo middleist der auf Null basierende Index für das mittlere Element der sortierten Liste. Es kann middleeine ganze Zahl sein, wie 1bei einer Eingabeliste der Größe 3 (10 20 30), oder ein Bruch für Listen mit einer geraden Anzahl von Elementen, wie 3/2bei (10 20 30 40). In beiden Fällen berechnen wir den erwarteten Medianwert.

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

Vim, 62 Bytes

Ursprünglich habe ich dies in V nur mit Textmanipulationen bis zum Ende gemacht, war aber frustriert, mit [X] und [X, Y] umzugehen. Hier ist also die einfache Version. Sie sind ungefähr gleich lang.

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

Probieren Sie es online!

Unbedruckbares:

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

Auszeichnung:

• ^O Verlässt den Einfügemodus für einen Befehl (den Befehl let).
• ^R" fügt den Text ein, der gezerrt wurde (in diesem Fall die Liste)

TI-Basic, 2 Bytes

median(Ans

Sehr einfach.

126 Bytes

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

Ganz einfach, hier mit LINQ, um die Werte zu ordnen, die Hälfte der Liste zu überspringen, ein oder zwei Werte zu nehmen, je nach Gerade / Ungerade, und sie zu mitteln.

C ++ 112 Bytes

Vielen Dank an @ original.legin, der mir geholfen hat, Bytes zu sparen.

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

Verwendung:

    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 Bytes

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

Probieren Sie es online!

Zusätzlich zum Array-Duplikationstrick von BMO konnte das gesamte Array in zwei Richtungen sortiert hinzugefügt werden. Dann erkannte ich, dass die beiden Schritte umgekehrt werden können, dh die beiden Arrays hinzufügen, dann duplizieren und das nth-Element nehmen.

Wie es funktioniert

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

Vorherige Antworten

J mit statsAddon, 18 Bytes

load'stats'
median

Probieren Sie es online!

Bibliotheksfunktion FTW.

medianDie Implementierung von sieht folgendermaßen aus:

J , 31 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Ein bisschen Golf gibt dies:

J , 28 Bytes

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

Probieren Sie es online!

J, 19 Bytes

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

Erläuterung:

        (        )~   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 Bytes

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 Bytes

Golf gespielt:

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

Probieren Sie es online aus

Pari / GP - 37 39 Bytes

Sei a ein Zeilenvektor, der die Werte enthält.

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

Da Pari / GP interaktiv ist, ist kein zusätzlicher Befehl erforderlich, um das Ergebnis anzuzeigen.

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)       

Probieren Sie es online!

Japt, 20 Bytes

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

Testen Sie es online! Japt fehlen wirklich alle eingebauten Funktionen, um eine wirklich kurze Antwort auf diese Herausforderung zu finden ...

Erläuterung

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 Bytes

Parität macht Spaß! Hier ist ein Lambda von double[]bis Double.

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

Hier ist nichts zu komplexes los. Das Array wird sortiert, und dann nehme ich den Mittelwert aus zwei Zahlen aus dem Array. Es gibt zwei Fälle:

• Wenn die Länge gerade ist, wird die erste Zahl direkt vor der Mitte des Arrays und die zweite Zahl durch Ganzzahldivision von der vorherigen Position übernommen. Der Mittelwert dieser Zahlen ist der Median der Eingabe.
• Wenn die Länge ungerade ist , sund s-1beide teilen auf den Index des mittleren Elements. Die Zahl wird zu sich selbst addiert und das Ergebnis durch zwei geteilt, wodurch der ursprüngliche Wert erhalten wird.

Probieren Sie es online

SmileBASIC, 45 Bytes

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

Ruft den Durchschnitt der Elemente auf Etage (Länge / 2) und Etage (Länge / 2-0,5) ab. Sehr einfach, aber ich konnte 1 Byte sparen, indem ich Dinge bewegte:

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

Schale , 10 Bytes

½ΣF~e→←½OD

Probieren Sie es online!

Erläuterung

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

_{Leider ½für Listen hat der Typ [a] -> [[a]]und nicht [a] -> ([a],[a])der, der nicht zulässt, F~+→←da foldl1eine Funktion vom Typ a -> a -> aals erstes Argument benötigt und mich zwingt, zu verwenden e.}

R ohne Verwendung der medianeingebauten, 51 Bytes

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

Probieren Sie es online!

GolfScript , 27 25 20 17 Bytes

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

Übernimmt die Eingabe als Array von Ganzzahlen für stdin. Ausgaben als nicht reduzierter Bruch. Probieren Sie es online!

Erläuterung

$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

Die Ausgabe wird ungefähr so ​​aussehen 10/2.