挑战

给定一个从stdin，函数参数，程序参数或其他方法接收的整数数组：

输出只在阵列中的最小和最大数目，通过一个返回值，标准输出，或其它拟合方法。

会话示例

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

参考实施

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

规则

• 您可能无法使用内置函数来计算值。
• 不允许出现标准漏洞。
• 鼓励创造性的实施。
• 这是代码高尔夫球，最短的答案将获胜，但不会被选中。

澄清说明

• 如果数组包含1个元素，则需要输出两次。
• 如果最小值和最大值相同，则需要将它们两者都输出。

果冻，3个字节

Ṣ.ị

在线尝试！

对数组进行排序，然后采用第0.5个元素。

果冻使用1索引，而浮点索引则占用其底线和ceil。

因此，第0.5个元素将为您提供第0个元素和第一个元素。

第0个元素是最后一个元素。

Python，61 49 37 36 34 31字节

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

-12字节感谢RootTwo

感谢chepner，另外-12个字节

-2个字节，感谢johnLate

-3个字节，感谢johnLate

脑高射炮 220个 218字节

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

在线试用！

说明

首先，它使最高值加倍（强制转换列表只有一个长）

(({}))

然后使用我的气泡排序算法：

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

然后，它获取堆栈的最高值（即最小值）

({}<...>)

然后弹出，直到堆栈的高度为一：

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

JavaScript（ES6），34个字节

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

sort就地排序，因此我可以只引用[0]索引来获取pop数组中的最小值和最大值，但是默认情况下它会进行字符串排序，因此我必须通过一个比较器。

Mathematica，18个字节

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

对数组排序并提取第一个和最后一个值。

R，31个字节

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

不是那个原始的，但是嘿！

ARM机器码，26个字节

十六进制转储（小端）：

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

这是一个函数，没有系统调用或库依赖性。编码为Thumb-2，这是用于32位ARM的变量（2或4字节）编码。可以想象，没有简单的方法可以对此处的第一个和最后一个元素进行排序和选择。总的来说，这里没有什么花哨的事情，它与参考实现大致相同。

非高尔夫装配（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

在Raspberry Pi 3上测试；这是测试脚本（C99，通过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个字节

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

在Haskell，min并max给予最小和最大的两个参数不是列表。我无法告诉您这是否被禁止（似乎只是minimum并且maximum将被禁止），所以请让我知道是否是这样，我将立即删除此答案。

八度，20字节

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

这将对输入向量进行排序，并输出第一个和最后一个值。

其实5个字节

S;F@N

在线尝试！

说明：

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

05AB1E，6 4字节

{Âø¬

说明

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

在线尝试

MATL，4个字节

S5L)

在线尝试！

说明

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个字节

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

在Ideone上进行测试。

C，83 81 79字节

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

Try it online!

V, 12 bytes

:sor
ò2Gjkd

Try it online!

Credit to DJMcMayhem for this.

CJam, 10 9 bytes

q~$_(p;W>

Try it online.

I'm really not good at 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);}

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.