Reto

Dada una lista no vacía de números reales, calcule su mediana.

Definiciones

La mediana se calcula de la siguiente manera: primero ordena la lista,

• si el número de entradas es impar , la mediana es el valor en el centro de la lista ordenada,
• de lo contrario, la mediana es la media aritmética de los dos valores más cercanos al centro de la lista ordenada.

Ejemplos

[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

Una función sin nombre que devuelve el resultado. -1 byte gracias a xnor.

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

El primer paso es obviamente ordenar la matriz, usando l.sort(). Sin embargo, solo podemos tener una declaración en una lambda, por lo que utilizamos el hecho de que la función de clasificación regresa Noneagregando un or- como Nonees falso en Python, esto le dice que evalúe y devuelva la siguiente parte de la declaración.

Ahora que tenemos la lista ordenada, necesitamos encontrar los valores intermedios o intermedios.

Usar un condicional para verificar la paridad de la longitud sería demasiado detallado, por lo que en su lugar obtenemos los índices len(l)/2y ~len(l)/2:

• El primero es el piso (longitud / 2) , que obtiene el elemento central si la longitud es impar, o el elemento izquierdo en el par central si la longitud es par.
• El segundo es la inversión binaria de la longitud de la lista, evaluando a -1 - piso (longitud / 2) . Debido a la indexación negativa de Python, esto esencialmente hace lo mismo que el primer índice, pero hacia atrás desde el final de la matriz.

Si la lista tiene una longitud impar, estos índices apuntarán al mismo valor. Si es de longitud uniforme, apuntarán a los dos elementos centrales.

Ahora que tenemos estos dos índices, encontramos estos valores en la lista, los sumamos y los dividimos entre 2. El lugar decimal al final /2.se asegura de que sea una división flotante en lugar de una división entera.

El resultado se devuelve implícitamente, ya que esta es una función lambda.

Pruébalo en línea!

Python3 - 31 30 bytes

¡Ahorré un byte gracias a @Dennis!

No estaba planeando una respuesta integrada, pero encontré este módulo y pensé que era realmente genial porque no tenía idea de que existía.

from statistics import*;median

Pruébelo en línea aquí .

En realidad , 1 byte

║

Pruébalo en línea!

Jalea , 9 bytes

L‘HịṢµ÷LS

Pruébalo en línea!

Explicación

Todavía estoy entendiendo a Jelly ... No pude encontrar elementos integrados para la mediana o el promedio de una lista, pero es muy conveniente para este desafío que Jelly permita índices no enteros en las listas, en cuyo caso devolverá un par de los dos valores más cercanos. Eso significa que podemos trabajar con la mitad de la longitud de entrada como índice y obtener un par de valores cuando necesitamos promediarlo.

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

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

Requiere la -Abandera para correr.

Pruébalo en línea!

Explicación

La columna vertebral de este algoritmo es un tipo de burbuja que escribí hace un tiempo.

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

No recuerdo cómo funciona esto, así que no me preguntes. Pero sí sé que ordena la pila e incluso funciona para negativos

Después de que todo ha sido ordenado, encuentro 2 veces la mediana con el siguiente fragmento

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

Ahora todo lo que queda es convertir a 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 bytes

median

No es sorprendente que R, un lenguaje de programación estadística, tenga esto incorporado.

MATL , 4 bytes

.5Xq

Esto encuentra el cuantil 0.5, que es la mediana.

Pruébalo en línea!

Pyth - 11 bytes

Encuentra el promedio del elemento medio tomado hacia atrás y hacia adelante.

.O@R/lQ2_BS

Test Suite .

Octava , 38 bytes

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

Esto define una función anónima. La entrada es un vector de fila.

Pruébalo en línea!

Explicación

            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

Ordenar la matriz numéricamente. Si la matriz tiene una longitud par, encuentre los 2 números intermedios y promedie. Si la matriz es impar, encuentre el número del medio dos veces y divídalo entre 2.

Matlab / Octave, 6 bytes

Un aburrido incorporado:

median

Pruébalo en línea!

Mathematica, 6 bytes

Median

Tan pronto como descubro Mthmtca , publico una solución en él.

Perl 6 , 31 bytes

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

Intentalo

Expandido:

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

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

Pruébalo en línea!

Este es un tren. El dfn original era {(2+/2/⍵[⍋⍵])[≢⍵]÷2}.

El tren está estructurado de la siguiente manera

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

⊢ denota el argumento correcto.

⌷ índice

• ⊂∘⍋los índices que se indexaron en ⊢resultados en ⊢ser ordenados

• ÷∘2en ⊢dividida por 2

2/replicar esto dos veces, entonces se 1 5 7 8convierte1 1 5 5 7 7 8 8

2+/ tomar la suma por pares, esto se convierte en (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ de esta selección

• ≢ elemento con índice igual a la longitud de ⊢

Soluciones anteriores

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

Lisp común, 89

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

Calculo la media de los elementos en la posición (floor middle)y (ceiling middle), donde middleestá el índice de base cero para el elemento central de la lista ordenada. Es posible middleque sea un número entero, como 1para una lista de entrada de tamaño 3 como (10 20 30), o una fracción para listas con un número par de elementos, como 3/2para (10 20 30 40). En ambos casos, calculamos el valor medio esperado.

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

Vim, 62 bytes

Originalmente hice esto en V usando solo manipulación de texto hasta el final, pero me sentí frustrado con el manejo de [X] y [X, Y], así que aquí está la versión fácil. Tienen aproximadamente la misma longitud.

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

Pruébalo en línea!

No imprimibles

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

Mención de Honor:

• ^O lo saca del modo de inserción para un comando (el comando let).
• ^R" inserta el texto que se tiró (en este caso, la lista)

TI-Basic, 2 bytes

median(Ans

Muy sencillo

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

Bastante sencillo, aquí con LINQ para ordenar los valores, omitir la mitad de la lista, tomar uno o dos valores dependiendo de pares / impares y promediarlos.

C ++ 112 bytes

Gracias a @ original.legin por ayudarme a guardar bytes.

#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 bytes

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

Pruébalo en línea!

Además del truco de duplicación de matrices de BMO , descubrí que podemos agregar toda la matriz ordenada en dos direcciones. Luego me di cuenta de que los dos pasos pueden invertirse, es decir, agregar las dos matrices, luego duplicarlas y tomar el nelemento th.

Cómo funciona

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

Respuestas anteriores

J con statscomplemento, 18 bytes

load'stats'
median

Pruébalo en línea!

Función de biblioteca FTW.

medianLa implementación de esta se ve así:

J , 31 bytes

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

Pruébalo en línea!

Cómo funciona

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)
         (<.,>.)@(-:@<:@#)       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 poco de golf da esto:

J , 28 bytes

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

Pruébalo en línea!

J, 19 bytes

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

Explicación:

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

Golfizado:

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

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

Pruébalo en línea

Pari / GP - 37 39 Bytes

Vamos a ser un rowvector que contiene los valores.

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

Como Pari / GP es interactivo, no se necesita ningún comando adicional para mostrar el resultado.

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)       

Pruébalo en línea!

Japt, 20 bytes

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

¡Pruébelo en línea! Japt realmente carece de los elementos necesarios para crear una respuesta realmente corta para este desafío ...

Explicación

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

¡La paridad es divertida! Aquí hay una lambda de double[]a Double.

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

Aquí no pasa nada demasiado complejo. La matriz se ordena, y luego tomo la media de dos números de la matriz. Hay dos casos:

• Si la longitud es par, entonces el primer número se toma justo por delante del centro de la matriz, y el segundo número se toma de la posición anterior por división entera. La media de estos números es la mediana de la entrada.
• Si la longitud es impar, sy s-1ambos se dividen en el índice del elemento medio. El número se agrega a sí mismo y el resultado se divide entre dos, produciendo el valor original.

Pruébalo en línea

SmileBASIC, 45 bytes

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

Obtiene el promedio de los elementos en el piso (longitud / 2) y el piso (longitud / 2-0.5) Muy simple, pero pude ahorrar 1 byte moviendo las cosas:

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

Casco , 10 bytes

½ΣF~e→←½OD

Pruébalo en línea!

Explicación

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

_{Desafortunadamente ½para las listas tiene el tipo [a] -> [[a]]y no [a] -> ([a],[a])lo que no permite, F~+→←ya que foldl1necesita una función de tipo a -> a -> acomo primer argumento, lo que me obliga a usar e.}

R sin usar el medianincorporado, 51 bytes

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

Pruébalo en línea!

GolfScript , 27 25 20 17 bytes

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

Toma datos como una matriz de enteros en stdin. Salidas como una fracción no reducida. Pruébalo en línea!

Explicación

$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 salida será algo así 10/2.