Desafio

Dada uma matriz de números inteiros, recebidos de stdin, argumentos de função, argumentos de programa ou algum outro método:

Saída apenas os números mínimo e máximo na matriz, através de um valor de retorno, stdout ou outros métodos de ajuste.

Sessão de exemplo

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

Implementação de referência

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

Regras

• Você não pode usar uma função interna para calcular os valores.
• Lacunas padrão não permitidas.
• Implementações criativas incentivadas.
• Este é o código-golfe , a resposta mais curta vence, mas não será selecionado.

Esclarecimentos

• Se a matriz contiver 1 elemento, você precisará produzi-la duas vezes.
• Se os valores mínimo e máximo forem os mesmos, você precisará produzir os dois.

Geléia , 3 bytes

Ṣ.ị

Experimente online!

Classifique a matriz e, em seguida, use o elemento 0,5-th.

A geléia usa a indexação 1 e a indexação de pontos flutuantes significa tomar seu piso e seu teto.

Portanto, o elemento 0,5-th forneceria o 0º elemento e o 1º elemento.

O 0º elemento é o último elemento.

Python, 61 49 37 36 34 31 bytes

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

-12 bytes graças ao RootTwo

Mais -12 bytes graças a chepner

-2 bytes graças a johnLate

-3 bytes graças a johnLate

Brain-Flak 220 218 bytes

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

Experimente Online!

Explicação

Primeiro, ele dobra o valor máximo (no elenco, a lista tem apenas um comprimento)

(({}))

Em seguida, ele usa meu algoritmo de classificação de bolhas:

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

Em seguida, ele pega o valor superior da pilha (ou seja, o mínimo)

({}<...>)

Então ele aparece até a altura da pilha ser uma:

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

JavaScript (ES6), 34 bytes

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

sortclassifica no local, para que eu possa apenas me referir ao índice [0] para o valor mais baixo e popo valor mais alto da matriz, no entanto, ele faz uma sequência de caracteres por padrão, então preciso passar por um comparador.

Mathematica, 18 bytes

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

Classifica a matriz e extrai o primeiro e o último valor.

R, 31 bytes

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

Não é tão original, mas ei!

Código da máquina ARM, 26 bytes

Despejo hexadecimal (little endian):

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

Esta é uma função, sem chamada de sistema ou dependência de biblioteca. A codificação é Thumb-2, uma codificação variável (2 ou 4 bytes) para ARM de 32 bits. Como se pode imaginar, não há uma maneira fácil de classificar e escolher o primeiro e o último elementos aqui. No geral, não há nada realmente tão sofisticado acontecendo aqui, é mais ou menos o mesmo que a implementação de referência.

Montagem não destruída (sintaxe 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

Testado no Raspberry Pi 3; aqui está o script de teste (C99, entrada por 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 bytes

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

Em Haskell, mine maxforneça o mínimo e o máximo de dois argumentos, não de uma lista. Eu não poderia dizer se isso é permitido (parece que em vez única minimume maximumseria anulado) então por favor deixe-me saber se eles são e eu vou apagar imediatamente esta resposta.

Oitava, 20 bytes

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

Isso classifica o vetor de entrada e gera o primeiro e o último valor.

Na verdade, 5 bytes

S;F@N

Experimente online!

Explicação:

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

05AB1E , 6 4 bytes

{Âø¬

Explicação

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

Experimente online

MATL , 4 bytes

S5L)

Experimente online!

Explicação

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 bytes

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

Teste em Ideone .

C, 83 81 79 bytes

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

Braquilog , 9 bytes

oOtT,Oh:T

Experimente online!

V , 12 bytes

:sor
ò2Gjkd

Experimente online!

Os nossos agradecimentos a DJMcMayhem por isso.

CJam, 10 9 bytes

q~$_(p;W>

Experimente online.

Eu realmente não sou bom em 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 bytes

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

PHP, 44 bytes

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

Processando, 59 52 bytes

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

Na verdade, o processamento não me permite ler do stdin que consegui encontrar e não sei se o compilador Java interno suporta lambdas (e faz tanto tempo desde que tive que escrever Java sério que não uso lembro como).

Perl 6 13 bytes

*.sort[0,*-1]

Teste:

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

Um método ingênuo de 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;};

Awak POSIX, 44 bytes

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

Oitava , 35 bytes

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

Esta é uma função anoynymous. Experimente em ideone .

O código evita o uso da classificação. Ou seja, todas as comparações "pares iguais ou inferiores" entre os elementos da entrada. O mínimo é o elemento para o qual todas as comparações são verdadeiras. O máximo é aquele para o qual apenas uma comparação é verdadeira.

Python, 35 34 bytes

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

Versão alternativa:

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

Versão antiga, 35 bytes.

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

Bastante simples: pegue a lista de entrada, adicione o primeiro elemento, classifique-o e depois pegue o primeiro e o comprimento da lista resultante. Como o comprimento da entrada após o acréscimo de um elemento é comprimento + 1, isso acaba levando o primeiro e o último elemento da lista, que são os elementos mínimo e máximo.

zsh, 22 bytes

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

define uma função lambda que imprime seu primeiro arg ( $1) e o último argumento para o comando anterior ( $_) e o passa $@após a classificação para que o comando anterior se torne a invocação desse lambda

zsh, 21 bytes

isso só funciona bem se houver mais de um argumento :(

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

classifica $@, transforma uma string e substitui tudo, desde o primeiro espaço até o último por um único espaço, depois passa como entrada para o gato com<<<

uso:

$ ./minmax 23 342 21 10
10 342

Scala, 55 bytes

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

Executar:

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

Bash + coreutils, 30 bytes

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

O script sed imprime, depois que a entrada é classificada, o primeiro e o último número inteiro.

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

Ajude-me, dc ers! Você é minha única esperança!

Obrigado a @seshoumara por encontrar esse bug!

Vou adicionar uma explicação mais tarde. Aqui está um pouco dividido:

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

Minha primeira solução de código "golfe".