Wyzwanie

Biorąc pod uwagę tablicę liczb całkowitych otrzymanych ze stdin, argumentów funkcji, argumentów programu lub innej metody:

Tylko wyjście minimalne i maksymalne liczby w tablicy za pomocą wartości zwracanej, standardowej lub innych metod dopasowania.

Przykładowa sesja

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

Realizacja referencyjna

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

Zasady

• Nie można używać wbudowanej funkcji do obliczania wartości.
• Standardowe luki zabronione.
• Zachęcono do kreatywnych wdrożeń.
• To jest golf golfowy , najkrótsza odpowiedź wygrywa, ale nie zostanie wybrana.

Wyjaśnienia

• Jeśli tablica zawiera 1 element, musisz go wypisać dwukrotnie.
• Jeśli wartości minimalne i maksymalne są takie same, musisz wyprowadzić je oba.

Galaretka , 3 bajty

Ṣ.ị

Wypróbuj online!

Posortuj tablicę, a następnie weź 0,5-ty element.

Galaretka stosuje indeksowanie 1, a indeksowanie zmiennoprzecinkowe oznacza, że ​​zabierze głos i sufit.

Tak więc 0,5-ty element da ci element 0 i element 1.

0 element jest ostatnim elementem.

Python, 61 49 37 36 34 31 bajtów

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

-12 bajtów dzięki RootTwo

Kolejne -12 bajtów dzięki chepnerowi

-2 bajty dzięki johnLate

-3 bajty dzięki johnLate

Brain-Flak 220 218 bajtów

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

Wypróbuj online!

Wyjaśnienie

Najpierw podwaja najwyższą wartość (w obsadzie lista jest tylko jedna długa)

(({}))

Następnie używa mojego algorytmu sortowania bąbelkowego:

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

Następnie wybiera najwyższą wartość stosu (tj. Min)

({}<...>)

Następnie wyskakuje, aż wysokość stosu będzie wynosić jeden:

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

JavaScript (ES6), 34 bajty

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

sortsortuje w miejscu, więc mogę po prostu odwołać się do indeksu [0] dla najniższej wartości i popnajwyższej wartości z tablicy, jednak domyślnie sortuje ciąg znaków, więc muszę przekazać komparator.

Mathematica, 18 bajtów

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

Sortuje tablicę i wyodrębnia pierwszą i ostatnią wartość.

R, 31 bajtów

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

Nie tak oryginalny, ale hej!

Kod maszynowy ARM, 26 bajtów

Zrzut szesnastkowy (mały endian):

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

Jest to funkcja bez zależności wywołania systemowego lub biblioteki. Kodowanie to Thumb-2, zmienne (2 lub 4 bajty) kodowanie dla 32-bitowego ARM. Jak można sobie wyobrazić, nie ma łatwego sposobu na posortowanie i wybranie tutaj pierwszego i ostatniego elementu. Ogólnie rzecz biorąc, nie ma tu nic takiego fantazji, to mniej więcej to samo, co implementacja referencyjna.

Zestaw do gry w golfa (składnia 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

Testowane na Raspberry Pi 3; oto skrypt testowy (C99, wprowadzanie przez 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 bajtów

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

W Haskell mini maxpodaj minimum i maksimum dwa argumenty, a nie listę. Nie mogłem powiedzieć, czy jest to niedozwolone (wydaje się, że zamiast tego minimumi maximumbyłoby niedozwolone), więc daj mi znać, jeśli tak, i niezwłocznie usunę tę odpowiedź.

Oktawa, 20 bajtów

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

To sortuje wektor wejściowy i wyświetla pierwszą i ostatnią wartość.

Właściwie 5 bajtów

S;F@N

Wypróbuj online!

Wyjaśnienie:

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

05AB1E , 6 4 bajtów

{Âø¬

Wyjaśnienie

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

Wypróbuj online

MATL , 4 bajty

S5L)

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Przetestuj na Ideone .

C, 83 81 79 bajtów

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 bajtów

oOtT,Oh:T

Wypróbuj online!

V , 12 bajtów

:sor
ò2Gjkd

Wypróbuj online!

Podziękowania dla DJMcMayhem.

CJam, 10 9 bajtów

q~$_(p;W>

Wypróbuj online.

Naprawdę nie jestem dobry w 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 bajty

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

PHP, 44 bajty

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

Processing, 59 52 bytes

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

Processing doesn't actually let me read from stdin that I've been able to find, and I don't know if its internal Java compiler supports lambdas (and its been so long since I've had to write serious Java that I don't remember how).

Perl 6 13 bytes

*.sort[0,*-1]

Test:

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 bytes

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

A naïve method at 93 bytes:

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 bytes

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

Octave, 35 bytes

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

This is an anoynymous function. Try it at ideone.

The code avoids using sorting. Namely, it does all pairwise "less than or equal" comparisons between elements of the input. The minimum is the element for which all comparisons are true. The maximum is that for which only one comparison is true.

Python, 35 34 bytes

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

Alternative version:

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

Old version, 35 bytes.

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

Fairly simple: take the input list, append the first element, sort it, then take the first and (length)th element of the resulting list. As the length of the input after appending an element is length + 1, this ends up taking the first and last element of said list, which are the minimum and maximum elements.

zsh, 22 bytes

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

defines a lambda function that prints its first arg ($1) and the last argument to the previous command ($_), and passes it $@ after sorting it so the previous command becomes the invocation of that lambda

zsh, 21 bytes

this only works fine if there's more than 1 argument :(

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

sorts $@, makes it a string and replaces everything from the first space to the last one with a single space, then passes it as input to cat with <<<

usage:

$ ./minmax 23 342 21 10
10 342

Scala, 55 bytes

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

To execute:

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

Bash + coreutils, 30 bytes

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

The sed script prints, after the input is sorted, the first and last integers.

dc, 110 bytes

?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

Help me, dcers! You are my only hope!

Thanks to @seshoumara for finding that bug!

I'll add an explanation later. Here it is broken up a bit:

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

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

Ungolfed:

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
}

My first ever code "golf" solution.