(una paradoja, una paradoja, una paradoja muy ingeniosa)

Esta es la primera parte de una serie de varias partes inspirada en diferentes funciones de R.

La tarea

Dado un conjunto de datos $D$ de números enteros positivos, necesito que permite calcular el resumen 5 Número de $D$ . Sin embargo, estoy trabajando en grandes conjuntos de datos, por lo que necesito que su código sea lo más pequeño posible, lo que me permite almacenarlo en mi computadora.

El resumen de cinco números consiste en:

• Valor mínimo
• Primer cuartil (Q1)
• Mediana / segundo cuartil (Q2)
• Tercer cuartil (Q3)
• Valor máximo

Hay varias formas diferentes de definir los cuartiles, pero utilizaremos la implementada por R:

Definiciones:

• Mínimo y máximo: los valores más pequeños y más grandes, respectivamente.
• Mediana: el valor medio si $D$ tiene un número impar de entradas, y la media aritmética de los dos valores más medios si $D$ tiene un número par de entradas. Tenga en cuenta que esto significa que la mediana puede ser un valor no entero. Hemos tenido que calcular la mediana antes .
• Primer y tercer cuartiles: divida los datos en dos mitades, incluido el elemento central en cada mitad si $D$ tiene un número impar de entradas, y encuentre el valor medio de cada mitad. La mediana de la mitad inferior es el primer cuartil, y la mediana de la mitad superior es el tercer cuartil.

Ejemplos:

$D=[1,2,3,4,5]$ . La mediana es entonces$3$ , y la mitad inferior es$[1,2,3]$ , produciendo un primer cuartil de$2$ , y la mitad superior es$[3,4,5]$ , produciendo un tercer cuartil de$4$ .

$D=[1,3,3,4,5,6,7,10]$ . La mediana es$4.5$ , y la mitad inferior es$[1,3,3,4]$ , produciendo un primer cuartil de$3$ , y la mitad superior es$[5,6,7,10]$ , produciendo un tercer cuartil de$6.5$ .

Reglas adicionales:

• La entrada es como una matriz o el equivalente más cercano a su idioma.
• Puede suponer que la matriz está ordenada en orden ascendente o descendente (pero especifique cuál).
• Puede devolver / imprimir los resultados de manera consistente orden y en el formato flexible que desee, pero indique el orden y el formato en su respuesta.
• Funciones incorporadas equivalentes a fivenumSe permiten , pero también implemente su propia solución.
• Puedes no asume cada uno de los cinco números será un entero.
• Se alientan las explicaciones.
• Este es el código de golf , por lo que gana la respuesta más corta en cada idioma.

Casos de prueba generados aleatoriamente

1 1 1 1 1 2 2 2 2 2 3 3 4 4 4 4 4 5 5 5 -> 1 1.5 2.5 4 5 
1 2 2 2 4 4 5 5 6 7 7 8 9 9 9 9 9 10 10 10 -> 1 4 7 9 10 
2 2 2 6 8 10 15 16 21 22 23 24 26 33 35 38 38 45 46 47 48 -> 2 10 23 38 48 
1 2 9 -> 1 1.5 2 5.5 9 
1 2 3 3 3 4 9 -> 1 2.5 3 3.5 9
1 1 2 5 7 7 8 8 15 16 18 24 24 26 26 27 27 28 28 28 29 29 39 39 40 45 46 48 48 48 48 49 50 52 60 63 72 73 79 85 86 87 88 90 91 93 94 95 95 97 100 -> 1 25 45 76 100
2 2 4 4 6 8 10 11 13 14 14 15 17 21 23 24 26 27 27 28 28 30 31 33 33 34 36 36 38 38 39 40 41 42 42 43 45 45 47 47 47 47 47 48 48 48 50 51 53 53 55 56 56 56 57 57 58 62 62 63 64 64 65 65 66 67 67 67 68 69 69 71 71 71 74 79 80 81 81 81 82 82 83 83 86 86 86 87 89 94 94 94 95 95 97 98 99 100 100 100 -> 2 33.5 54 76.5 100
1 3 3 4 -> 1 2 3 3.5 4
1 3 3 3 4 -> 1 3 3 3 4

R , 7 bytes

fivenum

Pruébalo en línea!

Obvia respuesta descarada. ;-)

Curiosamente, fivenum(x)no es equivalente summary(x)incluso cuando xes numérico, ya que los cuantiles se calculan de manera diferente: fivenumpromedios en discontinuidades, mientras que summaryinterpola. Puede forzar summarya comportarse como fivenumcon la opción quantile.type, pero esto aún es más largo que

R , 51 bytes

function(x)quantile(x,(0:4)/4,t=2+5*!sum(!!x)%%4-3)

Pruébalo en línea!

t=2$n\equiv 3\pmod 4$

Tenga en cuenta que el código fuente del fivenumincorporado es muy diferente (y mucho más largo).

MATL , 18 bytes

tno?t.5Xqh]5:q4/Xq

El orden de salida está aumentando, como en los casos de prueba.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

MATL, como MATLAB, calcula cuantiles usando interpolación lineal si es necesario (tal como se especifica en el desafío para la mediana). Para lograr el comportamiento requerido para el primer y tercer cuartiles, es suficiente repetir la mediana si la longitud de la entrada es impar. Entonces los resultados son solo los cuantiles 0, .25, .5, .75 y 1.

t       % Implicit input: numeric row array. Duplicate
no      % Length, parity
?       % If not zero (that is, if input length is odd)
  .5    %   Push .5
  Xq    %   .5-quantile: median. For even length it behaves as required
  h     %   Concatenate horizontally
]       % End
5:q     % Push [0 1 2 3 4]
4/      % Divide by 4, element-wise: gives [0 .25 .5 .75 1]
Xq      % [0 .25 .5 .75 1]-quantiles. Implicit display

Jalea , 13 bytes

œs2a\;WÆṁ;Ḣ;Ṫ

Pruébalo en línea!

Orden: [Q1, Q3, Q2/med, min, max].

Python 3.8 (prelanzamiento) , 66 bytes

lambda l:[(l[~-i//4]+l[-~i//4])/2for i in[1,n:=len(l),~n-n,~n,-3]]

Pruébalo en línea!

La entrada y la salida están en orden ascendente.

Python 3.8, 97 bytes

lambda l:[l[0],l[-1]]+[(i[x(i)//2]+i[~x(i)//2])/2for i in(l[:~((x:=len)(l)//2-1)],l,l[x(l)//2:])]

Esto supone que la lista de entrada está ordenada en orden ascendente. fes la función para devolver el resumen de 5 números.

$\{min, max, Q1, Q2,Q3\}$

Saqué algunos bytes tomando algunas pistas de la respuesta de FlipTack a Compute the Median.

Pruébalo en línea!

¿Como funciona?

lambda l:
    [l[0],l[-1]] # The minimum and maximum, because l is assumed to be sorted in ascending order
    +[(i[x(i)//2]+i[~x(i)//2])/2 # This line computes the median...
    for i in(l[:~((x:=len)(l)//2-1)],l,l[x(l)//2:])] # ...for each of these lists (the first half, the overall list, and the second half)
    # The (x:=len) is an assignment expression from Python 3.8.
    # It assigns the len function to the variable x but also returns len.
    # Therefore, x can be used as len to save a byte (yes, just one byte)

Carbón , 33 bytes

≔⊖ＬθηＩＥ⟦⁰⊘÷η²⊘η⁻η⊘÷η²η⟧⊘⁺§θ⌊ι§θ⌈ι

Pruébalo en línea! El enlace es a la versión detallada del código. Salidas en orden ascendente o descendente dependiendo de si la entrada está en orden ascendente o descendente. Explicación:

≔⊖Ｌθη

Obtenga el índice del último elemento.

ＩＥ

Asigne los elementos de la siguiente matriz y convierta el resultado en una cadena para impresión implícita en líneas separadas.

⟦⁰⊘÷η²⊘η⁻η⊘÷η²η⟧

Calcule las posiciones de los elementos del cuartil, donde un extra 0.5indica que el valor es el promedio de dos elementos adyacentes.

⊘⁺§θ⌊ι§θ⌈ι

Calcule el cuartil en cada posición tomando el promedio de los valores en el piso y el techo de la posición.

Ruby 2.7-preview1 , 59 bytes

Un puerto de estafa directa de la respuesta Python de xnor .

->a{[1,n=a.size,~n-n,~n,-3].map{(a[~-@1/4]+a[-~@1/4])/2.0}}

Pruébalo en línea! (un byte más, ya que TiO está usando Ruby 2.5 y no tiene parámetros de bloque numerados, por ejemplo @1).

C (gcc) , 123 121 119 bytes

-2 gracias a ceilingcat.

Asume una lista ordenada en orden ascendente.

Salidas en orden: mín., Q1, Q2, Q3, máx.

#define M(K,x)(K[~-x/2]+K[x/2])/2.,
f(L,n,m)int*L;{m=n-n/2;printf("%d %f %f %f %d",*L,M(L,m)M(L,n)M((L+n/2),m)L[n-1]);}

Pruébalo en línea!

05AB1E , 18 bytes

2F2äнIR})€ÅmIWsà‚«

Salida de orden es: [Q1, Q3, Q2, min, max].

Pruébelo en línea o verifique todos los casos de prueba . (He agregado un tipo {para el conjunto de pruebas, por lo que los casos de prueba son más fáciles de verificar en el orden [min, Q1, Q2, Q3, max]).

Explicación:

2F                 # Loop 2 times:
  2ä               #  Split the list at the top of the stack into two halves
                   #  (which is the (implicit) input-list in the first iteration)
    н              #  Only leave the first halve
     IR            #  Push the input in reverse
       })          # After the loop: wrap all three lists into a list
         €         # For each of the lists:
          Åm       #  Get the middle/median depending on the parity of the size of the list
            I      # Then push the input-list again
             W     # Get the minimum (without popping)
              s    # Swap to get the input-list again
               à   # Get the maximum (by popping the list)
                ‚  # Pair the min-max together to a pair
                 « # And merge both lists together
                   # (after which the result is output implicitly)