Desafío

Dada una matriz de enteros, recibidos de stdin, argumentos de función, argumentos de programa o algún otro método:

Imprima solo los números mínimo y máximo en la matriz, a través de un valor de retorno, stdout u otros métodos de ajuste.

Sesión de ejemplo

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

Implementación de referencia

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

Reglas

• No puede usar una función incorporada para calcular los valores.
• Lagunas estándar no permitidas.
• Implementaciones creativas alentadas.
• Este es el código de golf , la respuesta más corta gana pero no se seleccionará.

Aclaraciones

• Si el conjunto contiene 1 elemento, debe generarlo dos veces.
• Si los valores mínimos y máximos son los mismos, debe enviarlos a ambos.

Jalea , 3 bytes

Ṣ.ị

Pruébalo en línea!

Ordene la matriz y luego toma el elemento 0.5-th.

Jelly utiliza la indexación 1, y la indexación de puntos flotantes significa tomar su piso y su techo.

Entonces, el elemento 0.5 le daría el elemento 0 y el primer elemento.

El elemento 0 es el último elemento.

Python, 61 49 37 36 34 31 bytes

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

-12 bytes gracias a RootTwo

Otros -12 bytes gracias a chepner

-2 bytes gracias a johnLate

-3 bytes gracias a johnLate

Brain-Flak 220 218 bytes

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

¡Pruébelo en línea!

Explicación

Primero duplica el valor superior (en el reparto, la lista es solo una larga)

(({}))

Luego usa mi algoritmo de clasificación de burbujas:

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

Luego recoge el valor superior de la pila (es decir, el mínimo)

({}<...>)

Luego aparece hasta que la altura de la pila es una:

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

JavaScript (ES6), 34 bytes

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

sortordena en el lugar, por lo que puedo referirme al índice [0] para el valor más bajo y popel valor más alto de la matriz, sin embargo, hace una clasificación de cadena por defecto, así que tengo que pasar un comparador.

Mathematica, 18 bytes

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

Ordena la matriz y extrae el primer y último valor.

R, 31 bytes

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

No es tan original, pero ¡oye!

Código de máquina ARM, 26 bytes

Hex dump (little endian):

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

Esta es una función, sin llamada al sistema ni dependencia de la biblioteca. La codificación es Thumb-2, una codificación variable (2 o 4 bytes) para ARM de 32 bits. Como uno podría imaginar, no hay una manera fácil de ordenar y elegir el primer y el último elemento aquí. En general, no hay nada realmente elegante aquí, es más o menos lo mismo que la implementación de referencia.

Ensamblaje no protegido (sintaxis 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

Probado en la Raspberry Pi 3; Aquí está el script de prueba (C99, entrada a través de 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]

En Haskell, miny maxdar mínimo y máximo de dos argumentos, no de una lista. No podría decir si esto no está permitido (parece que solo en cambio minimumy maximumno lo estaría), así que avíseme si lo están y eliminaré esta respuesta de inmediato.

Octava, 20 bytes

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

Esto ordena el vector de entrada y genera el primer y el último valor.

En realidad, 5 bytes

S;F@N

Pruébalo en línea!

Explicación:

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

05AB1E , 6 4 bytes

{Âø¬

Explicación

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

Pruébalo en línea

MATL , 4 bytes

S5L)

Pruébalo en línea!

Explicación

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

Pruébelo en 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);}

Brachylog , 9 bytes

oOtT,Oh:T

Pruébalo en línea!

V , 12 bytes

:sor
ò2Gjkd

Pruébalo en línea!

Gracias a DJMcMayhem por esto.

CJam, 10 9 bytes

q~$_(p;W>

Pruébalo en línea.

Realmente no soy bueno en 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);}

Procesamiento, 59 52 bytes

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

El procesamiento en realidad no me permite leer de stdin que he podido encontrar, y no sé si su compilador interno de Java admite lambdas (y ha pasado tanto tiempo desde que tuve que escribir Java serio que no No recuerdo cómo).

Perl 6 13 bytes

*.sort[0,*-1]

Prueba:

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

Un método ingenuo a 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=

Octava , 35 bytes

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

Esta es una función anónima. Pruébalo en ideone .

El código evita usar la clasificación. Es decir, realiza todas las comparaciones "menores o iguales" por pares entre los elementos de la entrada. El mínimo es el elemento para el cual todas las comparaciones son verdaderas. El máximo es aquel para el que solo una comparación es verdadera.

Python, 35 34 bytes

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

Versión alternativa:

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

Versión anterior, 35 bytes.

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

Bastante simple: tome la lista de entrada, agregue el primer elemento, ordénelo, luego tome el primer elemento (de longitud) de la lista resultante. Como la longitud de la entrada después de agregar un elemento es longitud + 1, esto termina tomando el primer y último elemento de dicha lista, que son los elementos mínimo y máximo.

zsh, 22 bytes

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

define una función lambda que imprime su primer $1argumento ( ) y el último argumento del comando anterior ( $_), y lo pasa$@ después de ordenarlo para que el comando anterior se convierta en la invocación de ese lambda

zsh, 21 bytes

esto solo funciona bien si hay más de 1 argumento :(

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

ordena $@, lo convierte en una cadena y reemplaza todo, desde el primer espacio hasta el último con un solo espacio, luego lo pasa como entrada a cat con<<<

uso:

$ ./minmax 23 342 21 10
10 342

Scala, 55 bytes

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

Ejecutar:

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

Bash + coreutils, 30 bytes

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

El script sed imprime, después de que se ordena la entrada, los enteros primero y último.

cc, 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

Ayuadame, dc Ayúdenme ers! ¡Eres mi única esperanza!

¡Gracias a @seshoumara por encontrar ese error!

Agregaré una explicación más tarde. Aquí se divide un poco:

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

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

Mi primera solución de código "golf".