Défi

Étant donné un tableau d'entiers, reçus de stdin, des arguments de fonction, des arguments de programme ou une autre méthode:

Afficher uniquement les nombres minimum et maximum dans le tableau, via une valeur de retour, stdout ou d'autres méthodes d'ajustement.

Exemple de session

> minmax( {0, 15, 2, 3, 7, 18, -2, 9, 6, -5, 3, 8, 9, -14} )
-14 18

Implémentation de référence

// C++14

void minmax(std::vector<int> v) {
    int min = v[0]; int max = v[0];
    for(auto it : v) {
        if (*it < min)
            min = *it;
        if (*it > max)
            max = *it;
    }
    std::cout << min << ' ' << max << std::endl;
}

Règles

• Vous ne pouvez pas utiliser une fonction intégrée pour calculer les valeurs.
• Failles standard interdites.
• Implémentations créatives encouragées.
• Il s'agit du code-golf , la réponse la plus courte gagne mais ne sera pas sélectionnée.

Clarifications

• Si le tableau contient 1 élément, vous devez le sortir deux fois.
• Si les valeurs minimale et maximale sont identiques, vous devez les sortir toutes les deux.

Gelée , 3 octets

Ṣ.ị

Essayez-le en ligne!

Triez le tableau, puis prenez l'élément 0,5-ème.

Jelly utilise l'indexation 1, et l'indexation en virgule flottante signifie prendre son plancher et son plafond.

Ainsi, le 0,5-ème élément vous donnerait le 0ème élément et le 1er élément.

Le 0ème élément est le dernier élément.

Python, 61 49 37 36 34 31 octets

lambda s:s.sort()or[s[0],s[-1]]

-12 octets grâce à RootTwo

Encore -12 octets grâce à chepner

-2 octets grâce à johnLate

-3 octets grâce à johnLate

Brain-Flak 220 218 octets

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

Essayez-le en ligne!

Explication

D'abord, il double la valeur maximale (dans le casting, la liste n'est qu'une seule longue)

(({}))

Ensuite, il utilise mon algorithme de tri à bulles:

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

Ensuite, il récupère la valeur maximale de la pile (c'est-à-dire le min)

({}<...>)

Ensuite, il apparaît jusqu'à ce que la hauteur de la pile soit de un:

((())){{}{}([][()])}{}

JavaScript (ES6), 34 octets

a=>[a.sort((x,y)=>x-y)[0],a.pop()]

sorttrie sur place, donc je peux simplement me référer à l'index [0] pour la valeur la plus basse et popla valeur la plus élevée du tableau, mais il fait un tri de chaîne par défaut, donc je dois passer un comparateur.

Mathematica, 18 octets

Sort[#][[{1,-1}]]&

Trie le tableau et extrait les première et dernière valeurs.

R, 31 octets

l=sort(scan());l[c(1,sum(l|1))]

Pas si original, mais bon!

Code machine ARM, 26 octets

Vidage hexadécimal (petit endian):

6810 4601 f852 cb04 4560 bfc8 4660 4561 bfb8 4661 3b01 d8f5 4770

Il s'agit d'une fonction, sans appel système ni dépendance de bibliothèque. Le codage est Thumb-2, un codage variable (2 ou 4 octets) pour ARM 32 bits. Comme on pourrait l'imaginer, il n'y a pas de moyen facile de simplement trier et sélectionner les premier et dernier éléments ici. Dans l'ensemble, il n'y a rien de vraiment fantastique ici, c'est plus ou moins la même chose que l'implémentation de référence.

Assemblage non golfé (syntaxe GNU):

.syntax unified
.text
.global minmax
.thumb_func
minmax:
    @Input: @r0 and r1 are dummy parameters (they don't do anything)
    @r2 - Pointer to list of integers (int*)
    @r3 - Number of integers to sort (size_t)
    @Output:
    @Minimum of the list in r0 (int)
    @Maximum in r1 (int)
    ldr r0,[r2] @min=r2[0]
    mov r1,r0 @max=min
    loop:
        @ip is intra-procedure call register, a.k.a. r12
        ldr ip,[r2],#4 @ip=*r2++
        cmp r0,ip
        it gt @if (r0>ip)
        movgt r0,ip @r0=ip
        cmp r1,ip
        it lt @if (r1<ip)
        movlt r1,ip @r1=ip
        subs r3,r3,#1
        bhi loop @while (--r3>0)
    bx lr @Return

Testé sur le Raspberry Pi 3; voici le script de test (C99, entrée via argv):

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
//First 2 arguments are dummies.
uint64_t minmax(int,int,int* array,size_t size);

int main(int argc,char** argv) {
    int i;
    int array[argc-1];
    for (i=1;i<argc;i++) {
        array[i-1]=atoi(argv[i]);
    }
    uint64_t result = minmax(0,0,array,argc-1);
    printf("Minimum is %d, maximum is %d.\n",(unsigned)result,(unsigned)(result>>32));
}

Haskell, 27 octets

f x=(`foldl1`x)<$>[min,max]

Dans Haskell, minet maxdonnez au minimum et au maximum deux arguments, pas d'une liste. Je ne pourrais pas dire si cela est interdit (il semble qu'au lieu de cela seulement minimumet maximumserait refusé), veuillez donc me le faire savoir et je supprimerai rapidement cette réponse.

Octave, 20 octets

@(n)sort(n)([1,end])

Cela trie le vecteur d'entrée et sort la première et la dernière valeur.

En fait, 5 octets

S;F@N

Essayez-le en ligne!

Explication:

S;F@N
S      sort
 ;     dupe
  F    first element
   @N  and last element

05AB1E , 6 4 octets

{Âø¬

Explication

{     # sort list
 Â    # bifurcate
  ø   # zip
   ¬  # head

Essayez-le en ligne

MATL , 4 octets

S5L)

Essayez-le en ligne!

Explication

S    % Implicitly input the array. Sort
5L   % Push [1 0]. When used as a (modular, 1-based) index, this means "first and last"
)    % Apply as an indexing vector into the sorted array. Implicitly display

Python, 29 octets

lambda s:s[s.sort():1]+s[-1:]

Testez-le sur Ideone .

C, 83 81 79 octets

m,M;f(a,s)int*a;{for(m=M=*a;s--;++a)*a<m?m=*a:*a>M?M=*a:0;pr‌​intf("%i %i",m,M);}

Brachylog , 9 octets

oOtT,Oh:T

Essayez-le en ligne!

V , 12 octets

:sor
ò2Gjkd

Essayez-le en ligne!

Nous remercions DJMcMayhem pour cela.

CJam, 10 9 octets

q~$_(p;W>

Essayez-le en ligne.

Je ne suis vraiment pas bon à CJam.

q~          e# eval input
  $         e# sort
   _        e# duplicate
    (       e# pop first
     p      e# print
      ;     e# remove array
       W>   e# get last element

Python 2, 34 octets

x=sorted(input());print x[0],x[-1]

PHP, 44 octets

function a($a){sort($a);echo $a[0].end($a);}

Traitement, 59 52 octets

void m(int[]x){x=sort(x);print(x[0],x[x.length-1]);}

Le traitement ne me permet pas réellement de lire depuis stdin que j'ai pu trouver, et je ne sais pas si son compilateur Java interne prend en charge les lambdas (et cela fait si longtemps que je n'ai pas dû écrire de Java sérieux ne me souviens pas comment).

Perl 6 13 octets

*.sort[0,*-1]

Tester:

my &min-max = *.sort[0,*-1];

say min-max 1;
# (1 1)
say min-max (0, 15, 2, 3, 7, 18, -2, 9, 6, -5, 3, 8, 9, -14)
# (-14 18)

C #, 60 octets

n=>{System.Array.Sort(n);return new[]{n[0],n[n.Length-1]};};

Une méthode naïve à 93 octets:

n=>{var r=new[]{n[0],n[0]};foreach(int i in n){if(i<r[0])r[0]=i;if(i>r[1])r[1]=i;}return r;};

POSIX Awk, 44 octets

awk '{for(;NF-1;NF--)if($1>$NF)$1=$NF}1' RS=

Octave , 35 octets

@(x)[x(all(t=x<=x')) x(sum(t)==1)]

Il s'agit d'une fonction anoynymous. Essayez-le chez ideone .

Le code évite d'utiliser le tri. A savoir, il effectue toutes les comparaisons par paires "inférieures ou égales" entre les éléments de l'entrée. Le minimum est l'élément pour lequel toutes les comparaisons sont vraies. Le maximum est celui pour lequel une seule comparaison est vraie.

Python, 35 34 octets

lambda s:sorted(s+s[:1])[::len(s)]

Version alternative:

lambda s:sorted(s+s)[::len(s)*2-1]

Ancienne version, 35 octets.

lambda s:sorted(s+[s[0]])[::len(s)]

Assez simple: prenez la liste d'entrée, ajoutez le premier élément, triez-le, puis prenez le premier et (longueur) e élément de la liste résultante. La longueur de l'entrée après ajout d'un élément étant de longueur + 1, cela finit par prendre le premier et le dernier élément de ladite liste, qui sont les éléments minimum et maximum.

zsh, 22 octets

(){echo $1 $_} ${(n)@}

définit une fonction lambda qui imprime son premier arg ( $1) et le dernier argument à la commande précédente ( $_), et la passe $@après l'avoir triée pour que la commande précédente devienne l'invocation de ce lambda

zsh, 21 octets

cela ne fonctionne que s'il y a plus d'un argument :(

<<<"${${(n)@}/ * / }"

trie $@, en fait une chaîne et remplace tout du premier espace au dernier par un seul espace, puis le passe en entrée à cat avec<<<

usage:

$ ./minmax 23 342 21 10
10 342

Scala, 55 octets

val s=args.map(_.toInt).sorted
print(s.head+" "+s.last)

Éxécuter:

$ scala minmax.scala 1 2 3 4 5 6 7 8 9

Bash + coreutils, 30 octets

tr \  \\n|sort -n|sed '$p;1!d'

Le script sed affiche, une fois l'entrée triée, le premier et le dernier entier.

cc, 110 octets

?ddsMsmzdsAsa[z1-:az0<S]dsSx[>R]s?[la;asM]sR[lM]sQ[lQxla1-dsa;al?xla0<N]dsNxlAsa[<R]s?[la;asm]sR[lm]sQlNxlmlMf

Aidez-moi, dcers! Vous êtes mon seul espoir!

Merci à @seshoumara d'avoir trouvé ce bug!

J'ajouterai une explication plus tard. Ici, c'est un peu brisé:

?dd sM sm
zd sA sa
[z 1- :a z0<S]dsSx
 [>R]s?
 [la;asM]sR
 [lM]sQ
[lQx la 1- dsa ;a l?x la0<N]dsNx
lA sa
 [<R]s?
 [la;a sm]sR
 [lm]sQ
lNx
lm lM f

Java, 115 octets

String f(int[]i){int t=i[0],a=t,b=t;for(int c=0;c<i.length;c++){a=i[c]<a?i[c]:a;b=i[c]>b?i[c]:b;}return""+a+" "+b;}

Non golfé:

String f(int[] i) {
    int t=i[0], a=t, b=t; // assigns a and b to i[0]
    for (int c=0; c < i.length; c++) { // loop through the array
        a=(i[c]<a) ? i[c] : a;
        b=(i[c]>b) ? i[c] : b; // assignment with ternary operator
    }
    return ""+a+" "+b; // returns a string
}

Ma toute première solution de code "golf".