(un paradoxe, un paradoxe, un paradoxe des plus ingénieux)

Il s'agit de la première partie d'une série en plusieurs parties inspirée par différentes fonctions R.

La tâche

Étant donné un ensemble de données $D$ d'entiers positifs, je dois vous calculer le résumé du numéro 5 de $D$ . Cependant, je travaille sur de grands ensembles de données, j'ai donc besoin que votre code soit aussi petit que possible, ce qui me permet de le stocker sur mon ordinateur.

Le résumé à cinq chiffres comprend:

• Valeur minimum
• Premier quartile (T1)
• Médiane / deuxième quartile (T2)
• Troisième quartile (T3)
• Valeur maximum

Il existe plusieurs façons de définir les quartiles, mais nous utiliserons celle implémentée par R:

Définitions:

• Minimum et maximum: les plus petites et les plus grandes valeurs, respectivement.
• Médiane: la valeur moyenne si $D$ a un nombre impair d'entrées et la moyenne arithmétique des deux valeurs les plus moyennes si $D$ a un nombre pair d'entrées. Notez que cela signifie que la médiane peut être une valeur non entière. Nous avons dû calculer la médiane avant .
• Premier et troisième quartiles: divisez les données en deux moitiés, y compris l'élément central dans chaque moitié si $D$ a un nombre impair d'entrées, et trouvez la valeur médiane de chaque moitié. La médiane de la moitié inférieure est le premier quartile et la médiane de la moitié supérieure est le troisième quartile.

Exemples:

$D=[1,2,3,4,5]$ . La médiane est alors de$3$ , et la moitié inférieure est$[1,2,3]$ , ce qui donne un premier quartile de$2$ , et la moitié supérieure est$[3,4,5]$ , ce qui donne un troisième quartile de$4$ .

$D=[1,3,3,4,5,6,7,10]$ . La médiane est de$4.5$ et la moitié inférieure est$[1,3,3,4]$ , ce qui donne un premier quartile de$3$ , et la moitié supérieure est$[5,6,7,10]$ , ce qui donne un troisième quartile de$6.5$ .

Règles supplémentaires:

• L'entrée est un tableau ou l'équivalent le plus proche de votre langue.
• Vous pouvez supposer que le tableau est trié dans l'ordre croissant ou décroissant (mais veuillez préciser lequel).
• Vous pouvez renvoyer / imprimer les résultats dans n'importe quel ordre cohérent et dans le format flexible que vous aimez, mais veuillez indiquer l'ordre et le format dans votre réponse.
• Fonctions intégrées équivalentes à fivenum sont autorisées, mais veuillez également implémenter votre propre solution.
• Vous ne pouvez pas supposer que chacun des cinq nombres sera un entier.
• Des explications sont encouragées.
• C'est le golf de code , donc la réponse la plus courte dans chaque langue gagne!

Cas de test générés aléatoirement

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 octets

fivenum

Essayez-le en ligne!

Réponse coquine évidente. ;-)

Fait intéressant, fivenum(x)n'est pas équivalent à summary(x)même lorsqu'il xest numérique, car les quantiles sont calculés différemment: fivenummoyennes aux discontinuités, alors summaryqu'interpolées. Vous pouvez forcer summaryà se comporter comme fivenumavec l'option quantile.type, mais cela reste plus long que

R , 51 octets

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

Essayez-le en ligne!

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

Notez que le code source du fivenumintégré est très différent (et beaucoup plus long).

MATL , 18 octets

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

L'ordre de sortie augmente, comme dans les cas de test.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

MATL, comme MATLAB, calcule les quantiles en utilisant une interpolation linéaire si nécessaire (tout comme spécifié dans le défi pour la médiane). Pour obtenir le comportement requis pour les premier et troisième quartiles, il suffit de répéter la médiane si la longueur de l'entrée est impaire. Les résultats ne sont alors que les quantiles 0, 0,25, 0,5, 0,75 et 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

Gelée , 13 octets

œs2a\;WÆṁ;Ḣ;Ṫ

Essayez-le en ligne!

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

Python 3.8 (pré-version) , 66 octets

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

Essayez-le en ligne!

L'entrée et la sortie sont en ordre croissant.

Python 3.8, 97 octets

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

Cela suppose que la liste d'entrée est triée par ordre croissant. fest la fonction pour renvoyer le résumé à 5 chiffres.

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

J'ai enlevé quelques octets en prenant quelques indices de la réponse de FlipTack à Calculer la médiane.

Essayez-le en ligne!

Comment ça marche?

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)

Fusain , 33 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Sorties dans l'ordre croissant ou décroissant selon que l'entrée est dans l'ordre croissant ou décroissant. Explication:

≔⊖Ｌθη

Récupère l'index du dernier élément.

ＩＥ

Mappez les éléments du tableau suivant et transformez le résultat en chaîne pour une impression implicite sur des lignes distinctes.

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

Calculez les positions des éléments du quartile, où un extra 0.5indique que la valeur est la moyenne de deux éléments adjacents.

⊘⁺§θ⌊ι§θ⌈ι

Calculez le quartile à chaque position en prenant la moyenne des valeurs au plancher et au plafond de la position.

Ruby 2.7-preview1 , 59 octets

Un directe ripoff port de réponse Python xnor .

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

Essayez-le en ligne! (un octet de plus car TiO utilise Ruby 2.5 et n'a pas de paramètres de bloc numérotés par exemple @1).

C (gcc) , 123 121 119 octets

-2 grâce au plafond.

Suppose une liste triée par ordre croissant.

Sorties dans l'ordre: min, Q1, Q2, Q3, max.

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

Essayez-le en ligne!

05AB1E , 18 octets

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

Est ordre de sortie: [Q1, Q3, Q2, min, max].

Essayez-le en ligne ou vérifiez tous les cas de test . (J'ai ajouté un tri {pour la suite de tests, donc les cas de test sont plus faciles à vérifier dans l'ordre [min, Q1, Q2, Q3, max].)

Explication:

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)