Herausforderung

Ein Array von Ganzzahlen, die von stdin, Funktionsargumenten, Programmargumenten oder einer anderen Methode empfangen wurden:

Geben Sie nur die minimalen und maximalen Zahlen im Array über einen Rückgabewert, stdout oder andere Anpassungsmethoden aus.

Beispielsitzung

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

Referenzimplementierung

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

Regeln

• Möglicherweise verwenden Sie keine integrierte Funktion, um die Werte zu berechnen.
• Standardlücken sind nicht erlaubt.
• Kreative Umsetzungen sind erwünscht.
• Dies ist Code-Golf , die kürzeste Antwort gewinnt, wird aber nicht ausgewählt.

Klarstellungen

• Wenn das Array 1 Element enthält, müssen Sie es zweimal ausgeben.
• Wenn der minimale und der maximale Wert gleich sind, müssen Sie beide Werte ausgeben.

Gelee , 3 Bytes

Ṣ.ị

Probieren Sie es online!

Sortieren Sie das Array und nehmen Sie dann das 0,5-te Element.

Jelly verwendet die 1-Indizierung, und Gleitkomma-Indizierungsmittel nehmen seinen Boden und seine Decke ein.

Das 0,5-te Element würde also das 0. Element und das 1. Element ergeben.

Das 0. Element ist das letzte Element.

Python, 61 49 37 36 34 31 Bytes

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

-12 Bytes dank RootTwo

Weitere -12 Bytes dank chepner

-2 Bytes dank johnLate

-3 Bytes dank johnLate

Brain-Flak 220 218 Bytes

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

Probieren Sie es online!

Erläuterung

Zuerst verdoppelt es den Spitzenwert (in der Besetzung ist die Liste nur eine lange)

(({}))

Dann benutzt es meinen Blasensortierungsalgorithmus:

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

Dann nimmt es den höchsten Wert des Stapels auf (dh die min)

({}<...>)

Dann springt es, bis die Höhe des Stapels eins ist:

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

JavaScript (ES6), 34 Byte

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

sortEs wird direkt an der richtigen Stelle sortiert, sodass ich nur auf den Index [0] für den niedrigsten und popden höchsten Wert aus dem Array verweisen kann. Standardmäßig wird jedoch eine Zeichenfolgensortierung durchgeführt, sodass ich einen Komparator übergeben muss.

Mathematica, 18 Bytes

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

Sortiert das Array und extrahiert den ersten und letzten Wert.

R, 31 Bytes

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

Nicht das Original, aber hey!

ARM-Maschinencode, 26 Byte

Hex Dump (Little Endian):

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

Dies ist eine Funktion ohne Systemaufruf oder Bibliotheksabhängigkeit. Die Codierung ist Thumb-2, eine variable (2 oder 4 Byte) Codierung für 32-Bit-ARM. Wie man sich vorstellen kann, gibt es hier keine einfache Möglichkeit, das erste und das letzte Element zu sortieren und auszuwählen. Insgesamt ist hier nichts Besonderes los, es ist mehr oder weniger das Gleiche wie bei der Referenzimplementierung.

Ungolfed-Assembly (GNU-Syntax):

.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

Getestet auf dem Raspberry Pi 3; Hier ist das Testskript (C99, Eingabe über 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]

In Haskell, minund maxgibt Minimum und Maximum von zwei Argumenten, nicht einer Partei . Ich konnte nicht sagen, ob dies nicht zulässig ist (es scheint, dass dies stattdessen nur zulässig ist minimumund maximumnicht zulässig wäre). Lassen Sie es mich also bitte wissen, wenn dies der Fall ist, und ich werde diese Antwort umgehend löschen.

Oktave, 20 Bytes

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

Dies sortiert den Eingabevektor und gibt den ersten und letzten Wert aus.

Eigentlich 5 Bytes

S;F@N

Probieren Sie es online!

Erläuterung:

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

05AB1E , 6 4 Bytes

{Âø¬

Erläuterung

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

Probieren Sie es online aus

MATL , 4 Bytes

S5L)

Probieren Sie es online!

Erläuterung

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 es auf 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

Probieren Sie es online!

V , 12 Bytes

:sor
ò2Gjkd

Probieren Sie es online!

Wir danken DJMcMayhem dafür.

CJam, 10 9 Bytes

q~$_(p;W>

Probieren Sie es online aus.

Ich bin wirklich nicht gut in 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]

C #, 60 Bytes

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

Eine naive Methode bei 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;};

PHP, 44 Bytes

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

Verarbeitung, 59 52 Bytes

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

Bei der Verarbeitung kann ich nicht aus dem Standard lesen, den ich gefunden habe, und ich weiß nicht, ob der interne Java-Compiler Lambdas unterstützt (und es ist so lange her, dass ich ernsthaftes Java schreiben musste, das ich nicht geschrieben habe weiß nicht mehr wie).

Perl 6 13 Bytes

*.sort[0,*-1]

Prüfung:

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)

POSIX Awk, 44 Bytes

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

Oktave , 35 Bytes

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

Dies ist eine anonyme Funktion. Probiere es bei ideone aus .

Der Code vermeidet das Sortieren. Das heißt, es werden alle paarweisen "kleiner oder gleich" Vergleiche zwischen Elementen der Eingabe durchgeführt. Das Minimum ist das Element, für das alle Vergleiche zutreffen. Das Maximum ist das, für das nur ein Vergleich zutrifft.

Python, 35 34 Bytes

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

Alternative Version:

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

Alte Version, 35 Bytes.

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

Ziemlich einfach: Nehmen Sie die Eingabeliste, hängen Sie das erste Element an, sortieren Sie es und nehmen Sie dann das erste und (längste) Element der resultierenden Liste. Da die Länge der Eingabe nach dem Anhängen eines Elements + 1 ist, werden das erste und das letzte Element der Liste verwendet, bei denen es sich um das minimale und das maximale Element handelt.

zsh, 22 Bytes

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

Definiert eine Lambda-Funktion, die das erste $1Argument ( ) und das letzte Argument an den vorherigen Befehl ( $_) ausgibt und $@nach dem Sortieren übergibt , sodass der vorherige Befehl zum Aufruf dieses Lambdas wird

zsh, 21 Bytes

Das funktioniert nur, wenn es mehr als ein Argument gibt :(

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

sortiert $@, macht es zu einer Zeichenkette und ersetzt alles vom ersten bis zum letzten Leerzeichen durch ein einzelnes Leerzeichen und übergibt es dann als Eingabe an cat mit<<<

Verwendung:

$ ./minmax 23 342 21 10
10 342

Scala, 55 Bytes

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

Ausführen:

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

Bash + Coreutils, 30 Bytes

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

Das sed-Skript gibt nach dem Sortieren der Eingabe die erste und die letzte Ganzzahl aus.

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

Helft mir, dcers! Du bist meine einzige Hoffnung!

Vielen Dank an @seshoumara für das Auffinden dieses Fehlers!

Ich werde später eine Erklärung hinzufügen. Hier ist es etwas aufgebrochen:

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

Meine allererste Code "Golf" -Lösung.