Berechnen Sie den Median

32

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
Fehler
quelle
Können wir als Bruch über 2 ausgeben (zB 7/2oder 8/2)
Weizen-Assistent
Nach diesen Fraktionen sind in Ordnung.
Fehler
15
Wie ist das nicht schon eine Herausforderung?
Orlp
1
@orlp Dies ist eine Teilmenge dieser Herausforderung .
AdmBorkBork
3
Es ist auch eine schöne Herausforderung für den schnellsten Code, da es einige interessante lineare Zeitalgorithmen gibt.

Antworten:

18

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!

FlipTack
quelle
Sieht aus wie ein Lambda trotz der Wiederholung gewinnt:lambda l:l.sort()or(l[len(l)/2]+l[~len(l)/2])/2.
xnor
@ xnor Danke! Als ich das versuchte, zählte ich versehentlich dief= und dachte, sie sei 1 Byte länger.
FlipTack
13

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 .

Maltysen
quelle
6
from statistics import*;medianSpeichert ein Byte.
Dennis
@ Tennis oh cool. ist das immer kürzer
Maltysen
2
Es schlägt immer mit __import__, import math;math.logwürde aber schlagen from math import*;log.
Dennis
9

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.
Martin Ender
quelle
Natürlich Æṁwird jetzt funktionieren
Caird Coinheringaahing
9

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
Weizen-Assistent
quelle
7

R, 6 Bytes

median

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

rturnbull
quelle
4
RJelly: D: D: D schlagen
JAD
5

MATL , 4 Bytes

.5Xq

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

Probieren Sie es online!

Luis Mendo
quelle
Ich wollte es gerade herausfinden!
Fehler
Ah nein, ich meine, ich habe herausgefunden, wie es in MATL gemacht wird =) (Aber ich hatte eine 5-Byte-Lösung, also ja ...)
Fehler
@flawr Dann poste es! Es wird sicherlich interessanter sein als meins
Luis Mendo
Nein, es war das gleiche wie bei Ihnen, nur mit einem i vor :)
Fehler
@flawr Dasselbe i, das du vorgeschlagen hast, implizit zu machen? :-P
Luis Mendo
5

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 .

Maltysen
quelle
5

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
Luis Mendo
quelle
1
Ugh ... geschickte Verwendung von " bsxfun" und mean:-)
Stewie Griffin
5

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.

Grax32
quelle
1
Ich habe festgestellt, dass Array.sort()das mit Dezimalzahlen nicht richtig funktioniert
TrojanByAccident
3
Es funktioniert, wenn Sie eine Sortierfunktion übergeben, wie ich es getan habe. Wenn Sie Array.sort () ohne Parameter aufrufen, wird eine alphabetische Sortierung verwendet.
Grax32
Interessant.
Wusste
Sie können ein paar Bytes sparen, indem Sie den Rückgabewert von sort()direkt verwenden und die tVariable v=>(v.sort((a,b)=>a-b)[(x=v.length)>>1]+v[--x>>1])/2
Arnauld
1
Nicht, dass Sie dies unbedingt korrigieren x>=2**31müssten , aber wenn dies fehlschlagen würde. >>ist eine vorzeichenausbreitende Rechtsverschiebung , dh wenn die Zahl als 32-Bit-Ganzzahl interpretiert wird, bleibt sie gesetzt, wenn das MSB gesetzt ist, und das Ergebnis wird negativ für 2**32>x>=2**31. Denn x>=2**32es gibt einfach nach 0.
Patrick Roberts
5

Matlab / Octave, 6 Bytes

Ein langweiliges eingebautes:

median

Probieren Sie es online!

Fehler
quelle
Ich vergesse die Regeln für anonyme Funktionen in MATLAB / Octave. Sollte das so sein @median?
Giuseppe
@ Giuseppe Ich weiß nicht, was die derzeit akzeptierte Methode ist, um integrierte Funktionen zu bewerten.
Fehler
4

Mathematica, 6 Bytes

Median

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

Pavel
quelle
In Mthmtca 0.1 / 10.1.0.0 hätte der Code die Bytes CBC8( ËÈ). Bis ich jedoch einen anderen Patch anwende, entspricht der Begriff des Funktionsaufrufs möglicherweise nicht den PPCG-Standards.
LegionMammal978
4

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
Brad Gilbert b2gills
quelle
1
24 Bytes
Jo King
4

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
Kritixi Lithos
quelle
3

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))
Core-Dump
quelle
3

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)
nmjcman101
quelle
3

TI-Basic, 2 Bytes

median(Ans

Sehr einfach.

Timtech
quelle
2
Ansist keine zulässige E / A-Methode .
Mego
1
@Mego dein Link und Kommentar verwirrt mich ... laut Abstimmung ist das erlaubt. Vermisse ich etwas?
Patrick Roberts
@PatrickRoberts Derzeit gibt es eine Debatte über die Akzeptanzschwelle. Mehrere Benutzer (ich selbst eingeschlossen) haben die Regel befolgt, dass eine Methode mindestens +5 und mindestens doppelt so viele Upvotes wie Downvotes benötigt. Dies war die Regel, die ursprünglich in diesem Beitrag angegeben war (sie wurde seitdem entfernt), und es wird die Regel befolgt für Standardlücken.
Mego
Wer meinen Kommentar zweimal aus meinem eigenen Beitrag entfernt hat, ist nervig. Da es keine eindeutig akzeptierte Regel zur Akzeptanz gibt, sehe ich das Problem hier nicht. Sie können meine Antworten auf SO sehen, wie dies als Argumente für ein Programm verwendet wird.
Timtech
@ Mego +38 ist mehr als zweimal -18
Timtech
3

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.

Jens
quelle
Sie müssen using System.Linq; in Ihre Byteanzahl aufnehmen, können dies jedoch durch einige Änderungen rückgängig machen. Kompilieren Sie zu a Func<float[], float>und weisen Sie einer Variablen für 106 Bytes den Wert des using System.Linq;a=>{int x=a.Length,m=x%2<1?1:0;return a.OrderBy(g=>g).Skip(x/2-m).Take(++m).Average();};
Moduls zu
@TheLethalCoder Ich bin mir nie ganz sicher, was ein vollständiges Programm ausmacht. Sie haben Recht mit der Verwendung. Es ist auch eine gute Idee, die Deklarationen des Moduls mit der Länge zu verketten. Ich habe ein bisschen damit herumexperimentiert, konnte es aber nicht kürzer machen, als es zweimal dort hinein zu stecken. Ich würde sagen, dass Ihre Optimierungen für sich genommen eine Antwort wert sind, da sie sehr umfangreich sind und ich sie mir nicht ausgedacht hätte.
Jens
Die Herausforderung besagt nicht, dass Sie ein vollständiges Programm benötigen, sodass eine anonyme Methode in Ordnung ist. Darüber hinaus habe ich nur einige allgemeine Golftipps angegeben, sodass ich keine Antwort hinzufügen muss, sondern nur Ihre eigenen!
TheLethalCoder
3

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;
    }
Wade Tyler
quelle
1
Sie könnten floatanstelle von doublezwei Bytes speichern. Auf GCC können Sie auch #import<vector>und #import<algorithm>anstelle von verwenden #include. (Beachten Sie, dass Sie das Leerzeichen nach dem #includeoder nicht benötigen #import)
Steadybox
@Steadybox Ich habe die beiden Einschlüsse in der Partitur nicht gezählt. Sollte ich? Außerdem benutze ich hauptsächlich Clang, damit ich nicht viel über GCC weiß, aber danke.
Wade Tyler
Ja, die Includes sollten in die Byteanzahl einbezogen werden, wenn der Code ohne sie nicht kompiliert werden kann.
Steadybox
3

J , 16 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!

Bubbler
quelle
1
Gut gemacht, der J-Port meiner APL-Antwort würde #{0,2+/\2#-:/:]bei knapp 15 Bytes liegen (Mann, den ich vermisse ⎕io).
Kritixi Lithos
2

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
Marinus
quelle
Sie können ein Byte speichern , indem Sie die Klammern zu entfernen und die Anwendung ~direkt auf jede<.@-:@#{/:~-:@+\:~
Meilen
2

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}
TrojanByAccident
quelle
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

peech
quelle
Ich bin ein bisschen enttäuscht, auch wenn Java 7 eine ausreichend kurze Sortiersyntax hat, die en.wikipedia.org/wiki/… suboptimal ist
JollyJoker
Müssen Sie den Import nicht mitzählen java.util.Arrays?
FlipTack
Hoppla, danke, dass du es bemerkt hast. :)
Peech
Hallo aus der Zukunft! Sie können 14 Byte sparen, indem Sie die Längenparität durch Abschneiden der Ganzzahldivision handhaben. Siehe meine Java 8 Antwort .
Jakob
2

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.


Für den Link "Online testen" wird eine Zeile vor und nach hinzugefügt. Zum Ausdrucken wird das Median-Ergebnis in der Variablen w gespeichert

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!

Gottfried Helms
quelle
2

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
ETHproductions
quelle
2

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

Jakob
quelle
2

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
12Me21
quelle
2

Schale , 10 Bytes

½ΣF~e→←½OD

Probieren Sie es online!

Erläuterung

[ein1einN][ein1ein1einNeinN]

½Σ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.

ბიმო
quelle
2

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!

J.Doe
quelle
2
function(x)mean(x,.5)
ngm
2

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

ll-1l

~                  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.

DLosc
quelle