Défi

Étant donné une liste non vide de nombres réels, calculez sa médiane.

Définitions

La médiane est calculée comme suit: triez d'abord la liste,

• si le nombre d'entrées est impair , la médiane est la valeur au centre de la liste triée,
• sinon la médiane est la moyenne arithmétique des deux valeurs les plus proches du centre de la liste triée.

Exemples

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

Une fonction sans nom qui renvoie le résultat. -1 octet grâce à xnor.

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

La première étape consiste évidemment à trier le tableau à l'aide de l.sort(). Cependant, nous ne pouvons avoir qu'une seule instruction dans un lambda, nous utilisons donc le fait que la fonction de tri renvoie Noneen ajoutant un or- comme Nonec'est faux dans Python, cela lui dit d'évaluer et de renvoyer la partie suivante de l'instruction.

Maintenant que nous avons la liste triée, nous devons trouver les valeurs du milieu ou les deux du milieu.

L'utilisation d'un conditionnel pour vérifier la parité de la longueur serait trop verbeuse, donc à la place nous obtenons les index len(l)/2et ~len(l)/2:

• Le premier est le plancher (longueur / 2) , qui obtient l'élément central si la longueur est impaire, ou l'élément gauche dans la paire centrale si la longueur est paire.
• Le second est l'inversion binaire des longueurs de liste, évaluant à -1 - étage (longueur / 2) . En raison de l'indexation négative de Python, cela fait essentiellement la même chose que le premier index, mais en arrière à partir de la fin du tableau.

Si la liste est de longueur impaire, ces index pointeront vers la même valeur. S'il est de même longueur, alors ils pointeront vers les deux éléments centraux.

Maintenant que nous avons ces deux index, nous trouvons ces valeurs dans la liste, les additionnons et les divisons par 2. La décimale de fin dans /2.s'assure qu'il s'agit d'une division flottante plutôt que d'une division entière.

Le résultat est implicitement renvoyé, car il s'agit d'une fonction lambda.

Essayez-le en ligne!

Python3 - 31 30 octets

Un octet enregistré grâce à @Dennis!

Je ne prévoyais pas de réponse intégrée, mais j'ai trouvé ce module et j'ai pensé que c'était vraiment cool parce que je ne savais pas qu'il existait.

from statistics import*;median

Essayez-le en ligne ici .

En fait , 1 octet

║

Essayez-le en ligne!

Gelée , 9 octets

L‘HịṢµ÷LS

Essayez-le en ligne!

Explication

Je suis toujours en train de comprendre Jelly ... Je n'ai pas pu trouver des éléments intégrés pour la médiane ou la moyenne d'une liste, mais il est très pratique pour ce défi que Jelly autorise des indices non entiers dans les listes, auquel cas il renverra une paire des deux valeurs les plus proches. Cela signifie que nous pouvons travailler avec la moitié de la longueur d'entrée en tant qu'index et obtenir une paire de valeurs lorsque nous devons la moyenne.

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 octets

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

Requiert le -Adrapeau pour fonctionner.

Essayez-le en ligne!

Explication

L'épine dorsale de cet algorithme est une sorte de bulle que j'ai écrite il y a quelque temps.

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

Je ne me souviens pas comment cela fonctionne, alors ne me demandez pas. Mais je sais que cela trie la pile et fonctionne même pour les négatifs

Après que tout a été trié, je trouve 2 fois la médiane avec le morceau suivant

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

Maintenant, tout ce qui reste est de faire la conversion en 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 octets

median

Pas étonnant que R, un langage de programmation statistique, dispose de cette fonction intégrée.

MATL , 4 octets

.5Xq

Cela trouve le 0,5-quantile, qui est la médiane.

Essayez-le en ligne!

Pyth - 11 octets

Recherche la moyenne de l'élément du milieu pris à la fois en arrière et en avant.

.O@R/lQ2_BS

Suite de test .

Octave , 38 octets

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

Cela définit une fonction anonyme. L'entrée est un vecteur ligne.

Essayez-le en ligne!

Explication

            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 octets

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

Triez le tableau numériquement. Si le tableau est de longueur paire, trouvez les 2 nombres du milieu et faites-en la moyenne. Si le tableau est impair, trouvez le nombre du milieu deux fois et divisez par 2.

Matlab / Octave, 6 octets

Un ennuyeux intégré:

median

Essayez-le en ligne!

Mathematica, 6 octets

Median

Dès que j'ai compris Mthmtca , j'y poste une solution.

Perl 6 , 31 octets

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

L'essayer

Étendu:

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

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

Essayez-le en ligne!

Ceci est un train. Le DFN d'origine était {(2+/2/⍵[⍋⍵])[≢⍵]÷2}.

Le train est structuré comme suit

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

⊢ désigne le bon argument.

⌷ indice

• ⊂∘⍋les indices qui se sont indexés en ⊢résultats à ⊢trier

• ÷∘2en ⊢divisé par 2

2/reproduire cela deux fois, 1 5 7 8devient1 1 5 5 7 7 8 8

2+/ prendre la somme par paire, cela devient (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ de ce choix

• ≢ élément d'index égal à la longueur de ⊢

Solutions précédentes

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

Lisp commun, 89

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

Je calcule la moyenne des éléments en position (floor middle)et (ceiling middle), où middleest l'indice de base zéro pour l'élément central de la liste triée. Il est possible que ce middlesoit un nombre entier, comme 1pour une liste d'entrée de taille 3 comme (10 20 30), ou une fraction pour des listes avec un nombre pair d'éléments, comme 3/2pour (10 20 30 40). Dans les deux cas, nous calculons la valeur médiane attendue.

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

Vim, 62 octets

À l'origine, j'ai fait cela en V en utilisant uniquement la manipulation de texte jusqu'à la fin, mais je suis frustré de gérer [X] et [X, Y], alors voici la version facile. Ils ont à peu près la même longueur.

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

Essayez-le en ligne!

Non imprimables:

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

Mention honorable:

• ^O vous fait sortir du mode d'insertion pour une commande (la commande let).
• ^R" insère le texte qui a été retiré (dans ce cas la liste)

TI-Basic, 2 octets

median(Ans

Très simple.

C #, 126 octets

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

Assez simple, ici avec LINQ pour ordonner les valeurs, sauter la moitié de la liste, prendre une ou deux valeurs en fonction de pair / impair et les faire la moyenne.

C ++ 112 octets

Merci à @ original.legin de m'avoir aidé à économiser des octets.

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

Usage:

    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 octets

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

Essayez-le en ligne!

En plus de l'astuce de duplication des baies de BMO , j'ai constaté que nous pouvons ajouter la totalité du tableau trié dans deux directions. Ensuite, j'ai réalisé que les deux étapes peuvent être inversées, c'est-à-dire ajouter les deux tableaux, puis les dupliquer et prendre le ne élément.

Comment ça marche

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

Réponses précédentes

J avec statsaddon, 18 octets

load'stats'
median

Essayez-le en ligne!

Fonction de bibliothèque FTW.

medianL'implémentation de ceci ressemble à ceci:

J , 31 octets

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

Essayez-le en ligne!

Comment ça marche

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)
         (<.,>.)@(-:@<:@#)       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 peu de golf donne ceci:

J , 28 octets

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

Essayez-le en ligne!

J, 19 octets

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

Explication:

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

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 octets

Golfé:

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

Essayez-le en ligne

Pari / GP - 37 39 octets

Soit a un vecteur ligne contenant les valeurs.

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

Puisque Pari / GP est interactif, aucune commande supplémentaire n'est nécessaire pour afficher le résultat.

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)       

Essayez-le en ligne!

Japt, 20 octets

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

Testez-le en ligne! Japt n'a vraiment pas les éléments nécessaires pour créer une réponse très courte à ce défi ...

Explication

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 octets

La parité est amusante! Voici un lambda de double[]à Double.

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

Rien de trop complexe ne se passe ici. Le tableau est trié, puis je prends la moyenne de deux nombres du tableau. Il y a deux cas:

• Si la longueur est paire, le premier nombre est pris juste en avant du milieu du tableau et le deuxième nombre est pris de la position précédente par division entière. La moyenne de ces nombres est la médiane de l'entrée.
• Si la longueur est impaire, set les s-1deux se divisent à l'indice de l'élément central. Le nombre est ajouté à lui-même et le résultat divisé par deux, ce qui donne la valeur d'origine.

Essayez-le en ligne

SmileBASIC, 45 octets

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

Obtient la moyenne des éléments au sol (longueur / 2) et au sol (longueur / 2-0,5) Très simple, mais j'ai pu économiser 1 octet en déplaçant les choses:

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

Coque , 10 octets

½ΣF~e→←½OD

Essayez-le en ligne!

Explication

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

_{Malheureusement ½pour les listes a le type [a] -> [[a]]et non [a] -> ([a],[a])ce qui ne permet pas F~+→←car a foldl1besoin d'une fonction de type a -> a -> acomme premier argument, me forçant à utiliser e.}

R sans utiliser la fonction medianintégrée, 51 octets

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

Essayez-le en ligne!

GolfScript , 27 25 20 17 octets

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

Prend l'entrée comme un tableau d'entiers sur stdin. Sorties sous forme de fraction non réduite. Essayez-le en ligne!

Explication

$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

La sortie sera quelque chose comme 10/2.