Funkcja minmod jest odmianą znanej min , która pojawia się w schematach wysokiej rozdzielczości ograniczających nachylenie dla równań różniczkowych cząstkowych. Biorąc pod uwagę wiele zboczy, wybiera najbardziej płaskie zbocze, jednocześnie dbając o względne znaki między zboczami.

Funkcja przyjmuje dowolną liczbę parametrów. Następnie minmod (x ₁ , x ₂ , ..., x _n ) definiuje się jako:

• min (x ₁ , x ₂ , ..., x _n ) , jeśli wszystkie x _i są ściśle dodatnie
• max (x ₁ , x ₂ , ..., x _n ) , jeśli wszystkie x _i są ściśle ujemne
• 0 , w przeciwnym razie.

Rozważymy tylko liczby całkowite, ponieważ tak naprawdę nie wpływa to na implementację i powinno być bardziej włączające dla niektórych (ezoterycznych) języków.

Napisz program lub funkcję, która pobiera n liczb całkowitych ze znakiem (dla n> 0 ) przez STDIN, ARGV lub argument funkcji (możesz użyć tablicy, jeśli jest to wygodniejsze niż funkcja variadic), i zwraca lub wypisuje (do STDOUT) wynik od minmod (a, b) .

Nie wolno używać wbudowanych funkcji min lub max (i oczywiście nie ma też wbudowanego minmodu , jeśli można go naprawdę znaleźć). Ponadto nie wolno używać żadnych wbudowanych funkcji sortowania, z wyjątkiem sortowania ustalonej małej liczby elementów (mniej niż 5).

Jeśli twój język nie ma podpisanych typów, możesz użyć niepodpisanego typu i zinterpretować go jako uzupełnienie dwóch. Np. Jeśli twój język używa tylko niepodpisanych bajtów, możesz użyć, 255aby zastąpić -1i 128zastąpić -128, itp.

To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).

Przypadki testowe

Input          Output

2              2
-3             -3
0              0
3 -5           0
2 4 1          1
0 1 2          0
-1 1 2         0
-4 -2 -3 -2    -2
-5 0 -1        0
1 0 -1         0

Liderów

Poniższy fragment kodu generuje zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka. Więc nawet jeśli wybrany język nie pozwala ci wygrać całego wyzwania, dlaczego nie spróbować zająć miejsca na drugiej liście?

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

# Ruby, <s>104</s> <s>101</s> 96 bytes

function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);i=i.replace("{{PLACE}}",t++ +".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=42079;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

GolfScript, 10 9 bajtów

~{0]$1=}*

Zakłada wejście ze standardowego wejścia w formacie [-4 -2 -3 -2]

Korzysta z wbudowanej funkcji sortowania $, ale za każdym razem, gdy jest wywoływana, jest na tablicy 3 elementów, co jest dozwolone.

Demo online

Mathematica, 19 bajtów

Median[#~Riffle~0]&

Kod i gra w golfa dzięki Martinowi Büttnerowi.

Jest to nienazwana czysta funkcja, która przyjmuje na wejściu listę liczb całkowitych. Wywołaj to jak

Median[#~Riffle~0]&[{-2, -3, -2, -4}]

lub podobnie zapisane w zmiennej.

Kod najpierw riffuje zero pomiędzy każdymi dwoma elementami listy wejściowej, co wstawia n-1zera między nelementami. Następnie mediana wymaga odpowiedzi.

To daje min-mod, ponieważ obsługuje każdą skrzynkę:

1. Wszystkie liczby są dodatnie, w którym to przypadku zera znajdują się poniżej nich, a mediana jest najniższą liczbą dodatnią.

2. Wszystkie liczby są ujemne, w którym to przypadku zera są powyżej nich, a mediana jest liczbą najmniej ujemną.

3. Jest zarówno liczba dodatnia, jak i ujemna, więc środkowy element to zero.

Jeśli Mathematica implementuje swoją medianę za pomocą algorytmu wyboru czasu liniowego , wówczas jest to również O (n).

Haskell, 62 61 39 38 37 bajtów

f s=last[x|x<-0:s,and[x*x<=x*y|y<-s]]

używając magii porównawczej zapożyczonej z odpowiedzi @ Zgarba *, mianowicie x*x<=x*y.

x*x<=x*yjest prawdziwe tylko wtedy, gdy xi ymają ten sam znak i y„s wartość bezwzględna jest większa. zwróć uwagę, że kiedy xjest 0to zawsze prawda.

określamy, że xjest to wynik, w którym jest zawarty s, i że dla wszystkich yw s xma ten sam znak yi jest mniejszy w wartości bezwzględnej. jeśli żadna wartość nie sspełnia tej definicji, to0 to wynik.

fnastępnie działa, wyszukując selement spełniający ten warunek i używa 0go domyślnie.

_{* chociaż nie używał go z powodów, dla których go używam, i właściwie się go pozbył}

JavaScript (ES6), 39 bajtów

a=>a.reduce((p,c)=>p*c>0?p*p>c*c?c:p:0)

Python 2, 53

lambda l:reduce(lambda a,b:sorted([a,b,0])[1],l,l[0])

Chodzi o to, aby reduceprzekształcić dwu-wejściową wyszukiwarkę min-mod w nwejściową. Wymyśliłem go niezależnie od innych odpowiedzi, które go wykorzystują. Obsługuje tylko Python 2 reduce.

Rozwiązanie z dwoma wejściami po prostu znajduje medianę dwóch liczb i zero. Zobacz moje odpowiedź Mathematica, aby uzyskać bardziej bezpośredni sposób użycia mediany.

Mniej golfa:

def f(l):
 A=l[0]
 for x in l:A=sorted([a,b,0])[1]
 return A

Hipotetyczna amalgamat Python 2 i Python 3 będzie znak krótsza, z gwiazdką cesją z Python 3 i input()a printod Pythonie 2.

#Not real code!
A,*l=input()
for x in l:A=sorted([A,x,0])[1]
print A

Stary kod, bez sortowania:

lambda l:reduce(lambda a,b:[a,b][a*a>b*b]*(a*b>0),l,l[0])

Cudowny, 210 bajtów

@0
00
]]\\&002
/\..//&0@0
00..02
MMMMMM//\\
:M
}0}1}0}1}0}1}0}2..}2
^7^7||||&0&1&4<3&0=2{>
EqalLteq{0{<{<<2&1--
&2..&3..}100..&2\/{>
>0&6=0&4&5&6..\/
&3..&5\/{<{0
\/..\/
:|
}000}0
&0Subt
{0&1
}0{0
^7
=0&1
&0
\/

Użyto tu trzech desek.

|Wyżywienie ( Abw wersji czytelnej) przyjmuje wartość bezwzględną marmuru (albo przez zwrócenie przeszedł marmuru lub zero minus przeszedł marmuru, jak wszystkie działania arytmetyczne w Marbelous jest niepodpisany).

MWyżywienie (Minabs w czytelnej) Znajduje i wyjścia po lewej stronie pierwszego lub drugiego marmuru przechodzi (w zależności od tego ma mniejszą wartość bezwzględną), a wyjściem, jeśli inaczej podpisany marmur podjęcia.

MPłyta zwalnia również marmur, jaką posiada w dół zamiast w lewo raz ostatni znak ze standardowego wejścia jest naciągane.

MPłyta jest używana w płycie głównej, aby zapisać minmod wszystkich sprawdzanych wartości w danym momencie, gdyż zwalnia wartość do zapisanego w lewo, który jest następnie odchylony widok.

Trashbins ( \/) zostały umieszczone tylko w synchronizatorach, które w innym przypadku wydrukowałyby na STDIN.

Wejścia / wyjścia używają STDIN / STDOUT. Oba dotyczą wartości 8-bitowych (jeśli chcesz przekazać + 0x30 i + 0x38, umieść08 w STDIN).

Wymagane są biblioteki i płytki cylindryczne. Zalecane jest wyświetlanie wyniku w postaci liczb dziesiętnych (zwróć uwagę, że wyświetla on niepodpisaną wartość wyniku minmod).

Sprawdź to tutaj.

Uwaga: Aby uzyskać więcej ludzi przyjaznych wejścia / wyjścia, dodać Dppod ostatnim wierszu płycie głównej (przed :M), wymienić ]]z Rd, i dodaj następujący u dołu:

:Rd
}0}0}0
]]]]]]{>
-O-O-O
-O-O-O
*A
Plus
\\*A
..Plus
..{0
:*A
}0}0
<<<<
<<
<<
Plus
{0

To po prostu zmienia wynik na 3 cyfry dziesiętne. Podobnie wprowadzenie tych zmian wymaga oddzielonej spacjami listy 3 cyfr dziesiętnych na liczbę.

Wersja do odczytu:

Haskell, 83 40 39 bajtów

To prawdopodobnie nie jest najkrótsze możliwe rozwiązanie Haskell (i na pewno nie pokona innych tutaj), ale to początek. EDYCJA: Teraz o ponad 50% krótsza! EDIT2: Jeden bajt mniej ...

a#b|a*b<0=0|a*a<b*b=a|1<2=b
m=foldr1(#)

To tylko proste krotnie (lub zmniejszyć, ponieważ niektóre języki nazwać) przez operatora binarnego #, który oblicza medianę a, ba 0. Mimo że reguły pozwoliłyby mi teraz sortować małe listy, wymaga to importu w Haskell i skutkuje większą liczbą bajtów ( 49 bajtów, ale 31 bez importu):

import Data.List
a#b=sort[a,b,0]!!1
m=foldr1(#)

TIS-100, 696 526 bajtów

@1
MOV UP ACC
SAV
ADD 999
JEZ A
SWP
MOV 1 ANY
MOV ACC ANY
JRO -7
A:MOV 12 ANY
@5
S:JRO UP
MOV UP ACC
JLZ A
JEZ B
MOV 1 DOWN
JMP B
A:MOV 7 DOWN
NEG
B:MOV 1 RIGHT
MOV ACC RIGHT
MOV ACC RIGHT
JMP S
MOV 14 DOWN
MOV 9 RIGHT
@6
MOV 999 ACC
L:JRO LEFT
SAV
SUB ANY
JGZ A
MOV ANY NIL
SWP
JMP L
A:MOV ANY ACC
JMP L
MOV ACC ANY
@9
S:JRO UP
JEZ A
SUB 1
JEZ A
JMP X
A:MOV 1 ACC
JMP S
JEZ B
SUB 2
JEZ B
X:MOV 6 ACC
JMP S
B:MOV 2 ACC
JMP S
MOV ACC ANY
@10
MOV LEFT ACC
ADD 1
JRO ACC
JRO 6
MOV UP ANY
MOV UP ACC
NEG
MOV ACC ANY
!NOP
MOV 0 ANY

Oczekuje, że sekwencja zostanie zakończona przez -999 . TIS-100 jest nowszy od tego pytania, ale i tak nie ma to tutaj znaczenia.

Węzeł 9 śledzi, czy wszyscy jesteśmy pozytywni, wszyscy negatywni czy mieszani. Węzły 5 i 6 pracują, aby znaleźć minimum bezwzględnej wartości wszystkich liczb wejściowych. Węzeł 10 następnie wybiera minimum, minimum negowane lub 0 w zależności od stanu węzła 9.

CJam, 20 bajtów (lub 10 bajtów)

q~{]__~z\z<=\~*0>*}*

Stosując podejście @ xnor, zmniejsz obliczanie minmod 2 liczb na raz z tablicy.

Gdyby :zzadziałało, byłoby to 19 bajtów

Korzystanie z nowej zasady używania sortowania na krótkich tablicach:

q~{0]$1=}*

co jest dokładnie równoważne z odpowiedzią @ Peter

Poprzedni 26 bajtów asnwer:

q~_{g}%_|:+\(z\{za+_~>=}/*

Można to zagrać w golfa dalej ...

Dane wejściowe (przez STDIN) to tablica liczb całkowitych, takich jak:

[-4 -2 -3 -2]

a wyjściem jest minmod tablicy wejściowej

Wypróbuj tutaj

Jeśli tylko :gi :zdziałało, to byłby 4 bajty krótszy.

Java, 84 bajty

To jest Java w całej okazałości. Pokonuje GolfScript ponad nieco ponad 900%.

int f(int[]a){int b=a[0],c;for(int d:a)b=(c=d<0?-1:1)*b<0?0:d*c<b*c?d:b;return b;}

Owinięte w klasie:

public class MinModGolfed{

    public static void main(String[] args){
        int[] numbers = new int[args.length];
        for (int i = 0; i < args.length; i++){
            numbers[i] = Integer.parseInt(args[i]);
        }
        System.out.println(new MinModGolfed().f(numbers));
    }

    int f(int[]a){int b=a[0],c;for(int d:a)b=(c=d<0?-1:1)*b<0?0:d*c<b*c?d:b;return b;}

}

Rozszerzony o komentarze:

public class MinModExpandedGolfed{

    public static void main(String[] args){
        int[] numbers = new int[args.length];
        for (int i = 0; i < args.length; i++){
            numbers[i] = Integer.parseInt(args[i]);
        }
        System.out.println(new MinModExpandedGolfed().f(numbers));
    }

    int f(int[]a){                  //a is the input numbers
        int b=a[0],c;             //b is the best number found so far.
        for(int d:a)               //Iterate over a with current element as d.
            b=(c=d<0?-1:1)         //c is equal to the sign of d.
                    *b<0?
                        0:          //If b has opposite sign of d, b = 0.
                        d*c<b*c?d:b;//If the absolute value of d is less than b, b = d. 
        return b;
    }

}

Uwaga: Można to poprawić za pomocą Java 8.

Uwaga: Próba ulepszenia w Javie 8 nie powiodła się.

J, 20 12 bajtów

Funkcja przyjmuje listę jako argument. Skradzione z Golfscript / CJam / cokolwiek.

(1{0/:~@,,)/

Minmod xi yjest medianą (sortuj /:~i bierz środek 1{) z listy trzech przedmiotów 0,x,y. Zmniejsz listę ( składając w języku J), biorąc ten minmod między sąsiednie elementy.

W użyciu na REPL. (J literuje swój znak ujemny _.)

   (1{0/:~@,,)/ _4 _2 _3 _2
_2
   f =: (1{0/:~@,,)/    NB. give it a name
   f 1 1 2
1
   f 0 1 2
0
   f _1 1 2
0

Stare śmieci, zanim zauważyłem, że dozwolone są krótkie sortowania: 0:`<.`>.@.(*@]*0<*))/minmod xi ywynosi 0 ( 0:), jeśli 0 jest większe lub równe iloczynowi, xa w przeciwnym razie yjest to min ( <.) lub max ( >.) pomiędzy xi yzależnie od znaku . Zwiń to na całej liście.

TI-BASIC, 19 bajtów

Zakłada wejście w formacie {-2,4,3} .

Działa podobnie do odpowiedzi xnor:

Input L₁              get user input into the L1 array
dim(L₁)2-1→dim(L₁     get the length of the array; multiply by 2 and subtract 1
                      make this the new length (new elements always default to 0)
median(L₁             calculate and return (since it's the last line) median of new array

Python 2, 82 79 71 69 61 bajtów

lambda l:reduce(lambda G,H:[H,G][(G>H)^(G>0)]*(G*H>0),l,l[0])

Jest to oparte na mojej odpowiedzi pyth, która została zainspirowana odpowiedzią Mig .

Stara odpowiedź:

l=input()
m=l[0]
k=1-2*(m<0)
for i in l:m=[m,i][m>i*k]
print(k*m>0)*m

To bardzo długa odpowiedź. Mam wrażenie, że posiadanie 2 zmiennych to strata ...? Miałem rację...? ish? ; p

KDB / Q, 43 znaki do definicji treści funkcji

Dzięki świetnym pomysłom z poprzednich postów:

f:{$[all 1_0<(*':)x;{$[<[x*x;y*y];x;y]}/[x];0]}

Wprowadź pojedynczy numer, używając rejestrowania

f[enlist 2]
f[enlist 0]
f[enlist -2]
f[2 4 1]
f[0 1 2]
f[1 0 2]
f[-1 1 2]
f[-4 -2 -3 -2]
f[-5 0 -1]
f[-5 -0 -1]
f[1 0 -1]

Jestem pewien, że jakiś guru Q może wymyślić krótszych.

Pyth, 25 22 20 12

uhtS[0GH)QhQ

Prawdopodobnie nie nowość, ale oryginalność: P

Wstępne sortowanie dozwolone

u*?Gx>GH>G0H>*GHZQhQ

Pyt

Wypróbuj online.

Pomysł użycia reducei wyrażeń potrójnych został bezwstydnie skradziony z odpowiedzi Mig , ale nie mam pojęcia, czy algorytmy te są w przeciwnym razie nawet podobne, ponieważ nie mogę odczytać oświadczeń potrójnych.

Wyjaśnienie:

Q=eval(input)         : implicit
u                QhQ  : print reduce(lambda G,H: ..., Q, Q[0])
 *          >*GHZ     : ... * (G*H>0)
  ?G       H          : G if ... else H
    x>GH>G0           : G>H xor G>0

C #, 101 bajtów

Moja pierwsza próba gry w golfa kodem w dość nieprzyjaznym języku golfowym. W oparciu o redukcję ( Aggregatew LINQ) i bardzo podobny do odpowiedzi JavaScript przez Mig . Można uruchomić jak (new System.Linq.M()).m(new[] {1, 2, 3}). Przechodzi wszystkie przypadki testowe, ale nie obsługuje pustych tablic wejściowych.

namespace System.Linq{class M{public int m(int[]i){return i.Aggregate((a,b)=>a*b>0?a*a<b*b?a:b:0);}}}

J, 12 bajtów

   (=&**>&|{,)/

Funkcja zmniejsza listę (zwaną folding ( /) w J) za pomocą wyrażenia:

(signum(x) == signum(y)) * [x,y][abs(x)>abs(y)] gdzie

[x,y][abs(x)>abs(y)]jest, yjeśli abs(x) > abs(y)jeszcze x.

Przykład:

   (=&**>&|{,)/ 5 2 6
2

Wypróbuj online tutaj.

Game Maker Language, 489 bajtów

Informacje o języku Game Maker

Riffles tablicę (dodawane są zera) i zwraca medianę (podobnie do mojej innej odpowiedzi)

i=0a=argument0
while(variable_local_array_get(a,i))i++
for(j=0;j++;j<i-1)a[j+i]=0var i,j,d,m=0d=ds_list_create()if variable_local_exists(a){if variable_local_array_get(a,0){for(i=0;i<32000;i++){if variable_local_array_get(a,i)=0break
ds_list_add(d,variable_local_array_get(a,i))}ds_list_sort(d,0)i=ds_list_find_value(d,ds_list_size(d) div 2)j=ds_list_find_value(d,(ds_list_size(d) div 2)-1)m=ds_list_find_value(ds,ds_list_size(d) mod 2)ds_list_destroy(d)}if m return (i+j)/2return i
break}

Java, 353 304 124 bajty

Złóż najgorszy język do gry w golfa z najgorszym golfistą na świecie, a otrzymasz ...

int m(int[]a){int m=a[0];if(m<0)for(int i:a){m=(i>m)?i:m;m=(i>0)?0:m;}else for(int i:a){m=(i<m)?i:m;m=(i<0)?0:m;}return m;}}

Ungolf to, a otrzymasz:

int m(int[] a) {
    int m = a[0];
    if (m < 0) {
        for (int i : a) {
            m = (i > m) ? i : m;
            m = (i > 0) ? 0 : m;
        }
    } else {
        for (int i : a) {
            m = (i < m) ? i : m;
            m = (i < 0) ? 0 : m;
        }
    }
    return m;
}

Jest to funkcja (jeśli to nie było całkiem oczywiste), która odbiera tablicę liczb i przetwarza jej wartości, zwracając wartość minmod.

Uwzględniono również mój stary dobrodziejstwo złudzenia, które jak zwykle stanowi cały program.

class M{public static void main(String[]a){java.util.Scanner s=new java.util.Scanner(System.in);int n,m=0;try{m=s.nextInt();if(m<0)while(true){n=s.nextInt();m=(n>m)?n:m;m=(n>0)?0:m;}else while(true){n=s.nextInt();m=(n<m)?n:m;m=(n<0)?0:m;}}catch(java.util.InputMismatchException e){System.out.print(m);}}}

Ungolf to, a otrzymasz:

class M {

    public static void main(String[] a) {
        java.util.Scanner s = new java.util.Scanner(System.in);
        int n = 0, m = 0;
        try {
            m = s.nextInt();
            if (m < 0) {
                do {
                    n = s.nextInt();
                    m = (n > m) ? n : m;
                    m = (n > 0) ? 0 : m;
                } while (true);
            } else {
                do {
                    n = s.nextInt();
                    m = (n < m) ? n : m;
                    m = (n < 0) ? 0 : m;
                } while (true);
            }
        } catch (java.util.InputMismatchException e) {
            System.out.print(m);
        }
    }
}

Otrzymuje nieskończone liczby, zatrzymuje się po wprowadzeniu wartości nieliczbowej, prezentując wartość Minmon.

R, 20 znaków

R zwykle nie jest dobry dla codegolfa, ale używam go do mojej pracy, więc chciałem spróbować. Zanim spróbowałem, nie wiedziałem, że R jest skłonny zaakceptować taką brudną składnię! :-) 52 znaki :

if((q=summary(x))[6]<0)q[6]else if(q[1]>0)q[1]else 0

Potem przejrzałem inne odpowiedzi, które wypróbowałem genialną medianą @ xnor, co jest świetne!

median(c(x-x,x)[-1])

Python, 52

Nadal nie mogłem się oprzeć wrażeniu, że źle jest mieć dwa lambdas. Ta funkcja pobiera listę, a następnie zwraca listę jednoelementową zawierającą wynik.

f=lambda a:a[1:]and[sorted([a.pop(),0]+f(a))[1]]or a

Miejmy nadzieję, że nie spowoduje to ogromnej przestępstwa, aby wynik w postaci listy składającej się z jednego elementu.

Matlab / Octave, 26

Jest to po prostu tłumaczenie odpowiedzi Mathematica autorstwa xnor. Działa poprzez dodanie jednego zera mniejszego niż długość wektora wejściowego. Pamiętaj, że dołączenie jeszcze jednego nie zadziałałoby, ponieważ wówczas wynik wynosiłby cały czas 0. Podziękowania dla MartinBüttner za -4 znaki tego rozwiązania =)

@(x)median([x,0*x(2:end)])

Python, 72 60 bajtów

To pierwsze rozwiązanie, o którym myślałem i jest dość naiwne. Druga połowa jest w zasadzie duplikatem pierwszej połowy kodu, ale nie byłam pewna, jak ją wyszczuplić. Zastanawiam się, czy można to skrócić za pomocą eval...

Edycja: Zmieniono lambdas na zrozumienie.

Wypróbuj je tutaj

lambda l:min(l)*all(x>0for x in l)+max(l)*all(x<0for x in l)

To tylko 4 znaki dłużej, ale nadal warto na nie spojrzeć, korzystając z PORADY Sp3000 .

lambda l:eval("+m%s%s(l)*all(x%s0for x in l)"*2%tuple("ax<in>"))

JavaScript, 63

a=>a.reduce((p,c)=>p<0?c<0?Math.max(p,c):0:c>0?Math.min(p,c):0)

Bardziej czytelna wersja:

function (arr) {
    return arr.reduce(function (p, c) {
        if (p < 0) {
            if (c < 0) {
                return Math.max(p, c);
            } else {
                return 0;
            }
        } else {
            if (c > 0) {
                return Math.min(p, c);
            } else {
                return 0;
            }
        }
    });
}