(um paradoxo, um paradoxo, um paradoxo mais engenhoso)

Esta é a primeira parte de uma série multipartes inspirada em diferentes funções R.

A tarefa

Dado um conjunto de dados $D$ de inteiros positivos, eu preciso de você para calcular o resumo 5 Número de . No entanto, estou trabalhando em grandes conjuntos de dados, portanto, preciso que seu código seja o menor possível, permitindo que eu o armazene no meu computador.$D$

O resumo de cinco números consiste em:

• Valor mínimo
• Primeiro quartil (Q1)
• Mediana / Segundo quartil (Q2)
• Terceiro quartil (Q3)
• Valor máximo

Existem várias maneiras diferentes de definir os quartis, mas usaremos o implementado por R:

Definições:

• Mínimo e máximo: os menores e os maiores valores, respectivamente.
• Mediana: o valor do meio, se tiver um número ímpar de entradas, e a média aritmética dos dois valores mais médios, se tiver um número par de entradas. Observe que isso significa que a mediana pode ser um valor não inteiro. Nós tivemos que calcular a mediana antes .$D$$D$
• Primeiro e Terceiro Quartis: Divida os dados em duas metades, incluindo o elemento central em cada metade, se $D$ tiver um número ímpar de entradas, e encontre o valor mediano de cada metade. A mediana da metade inferior é o Primeiro Quartil, e a mediana da metade superior é o Terceiro Quartil.

Exemplos:

$D=[1,2,3,4,5]$ . A mediana é então$3$ , e a metade inferior é $[1,2,3]$ , produzindo um primeiro quartil de $2$ , e a metade superior é $[3,4,5]$ , produzindo um terceiro quartil de $4$ .

$D=[1,3,3,4,5,6,7,10]$ . A mediana é$4.5$ e a metade inferior é$[1,3,3,4]$ , produzindo um primeiro quartil de$3$ , e a metade superior é$[5,6,7,10]$ , produzindo um terceiro quartil de$6.5$ .

Regras adicionais:

• A entrada é como uma matriz ou o equivalente mais próximo do seu idioma.
• Você pode assumir que a matriz está classificada em ordem crescente ou decrescente (mas especifique qual).
• Você pode devolver / imprimir os resultados em qualquer ordem consistente e no formato flexível que desejar, mas indique o pedido e o formato na sua resposta.
• Funções internas equivalentes a fivenumsão permitidas, mas também implemente sua própria solução.
• Você não pode assumir que cada um dos cinco números será um número inteiro.
• As explicações são incentivadas.
• Isso é código-golfe , e a resposta mais curta em cada idioma vence!

Casos de teste gerados 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

Experimente online!

Resposta atrevida óbvia. ;-)

Curiosamente, fivenum(x)não é equivalente summary(x)nem quando xé numérico, pois os quantis são calculados de maneira diferente: fivenummédias em descontinuidades, enquanto summaryinterpolam. Você pode forçar summarya se comportar como fivenumcom a opção quantile.type, mas isso ainda é mais longo do que

R , 51 bytes

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

Experimente online!

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

Observe que o código fonte do fivenum embutido é muito diferente (e muito mais longo).

MATL , 18 bytes

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

A ordem de saída está aumentando, como nos casos de teste.

Experimente online! Ou verifique todos os casos de teste .

Explicação

MATL, como MATLAB, calcula quantis usando interpolação linear, se necessário (exatamente como especificado no desafio para a mediana). Para obter o comportamento necessário para o primeiro e o terceiro quartis, basta repetir a mediana se o comprimento da entrada for ímpar. Então os resultados são apenas os quantis 0, 0,25, 0,5, 0,75 e 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

Gelatina , 13 bytes

œs2a\;WÆṁ;Ḣ;Ṫ

Experimente online!

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

Python 3.8 (pré-lançamento) , 66 bytes

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

Experimente online!

Entrada e saída estão em ordem crescente.

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:])]

Isso pressupõe que a lista de entrada seja classificada em ordem crescente. fé a função para retornar o resumo de 5 números.

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

Tirei alguns bytes tomando algumas dicas da resposta do FlipTack para Calcular a mediana.

Experimente online!

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)

Carvão , 33 bytes

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

Experimente online! Link é a versão detalhada do código. Saídas em ordem crescente ou decrescente, dependendo de a entrada estar em ordem crescente ou decrescente. Explicação:

≔⊖Ｌθη

Obtenha o índice do último elemento.

ＩＥ

Mapeie os elementos da matriz a seguir e converta o resultado em string para impressão implícita em linhas separadas.

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

Calcule as posições dos elementos do quartil, em que um extra 0.5indica que o valor é a média de dois elementos adjacentes.

⊘⁺§θ⌊ι§θ⌈ι

Calcule o quartil em cada posição, calculando a média dos valores no piso e no teto da posição.

Ruby 2.7-preview1 , 59 bytes

Uma porta de ripoff direta da resposta Python do xnor .

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

Experimente online! (um byte a mais, já que o TiO está usando o Ruby 2.5 e não possui parâmetros de bloco numerados, por exemplo @1).

C (gcc) , 123 121 119 bytes

-2 graças a ceilingcat.

Assume uma lista classificada em ordem crescente.

Saídas em ordem: min, 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]);}

Experimente online!

05AB1E , 18 bytes

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

Saída de ordem é: [Q1, Q3, Q2, min, max].

Experimente online ou verifique todos os casos de teste . Adicionei uma classificação {para o conjunto de testes, para que os casos de teste sejam mais fáceis de verificar na ordem [min, Q1, Q2, Q3, max].)

Explicação:

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)