Die minmod- Funktion ist eine Variante der bekannten min , die in hangbegrenzenden hochauflösenden Schemata für partielle Differentialgleichungen vorkommt. Bei einer bestimmten Anzahl von Pisten wird die flachste Piste ausgewählt, wobei auf die relativen Zeichen zwischen den Pisten geachtet wird.

Die Funktion akzeptiert eine beliebige Anzahl von Parametern. Dann ist minmod (x ₁ , x ₂ , ..., x _n ) definiert als:

• min (x ₁ , x ₂ , ..., x _n ) , wenn alle x _i streng positiv sind
• max (x ₁ , x ₂ , ..., x _n ) , wenn alle x _i streng negativ sind
• 0 , sonst.

Wir werden nur Integer-Eingaben berücksichtigen, da dies die Implementierung nicht wirklich beeinflusst und für einige (esoterische) Sprachen umfassender sein sollte.

Schreiben Sie ein Programm oder eine Funktion, die n vorzeichenbehaftete Ganzzahlen (für n> 0 ) über STDIN, ARGV oder Funktionsargument (Sie können ein Array verwenden, wenn dies praktischer als eine variable Funktion ist) akzeptiert und das Ergebnis zurückgibt oder ausgibt (an STDOUT) von minmod (a, b) .

Sie müssen nicht eingebaut in Gebrauch min oder max - Funktionen (und offensichtlich keine eingebaute in minmod entweder, wenn man das tatsächlich finden kann). Darüber hinaus dürfen Sie keine integrierten Sortierfunktionen verwenden, außer zum Sortieren einer festgelegten kleinen Anzahl von Elementen (weniger als 5).

Wenn Ihre Sprache keine vorzeichenbehafteten Typen hat, können Sie einen vorzeichenlosen Typ verwenden und ihn als Zweierkomplement interpretieren . Wenn Ihre Sprache beispielsweise nur vorzeichenlose Bytes verwendet, können Sie 255für -1und 128für -128usw. einstehen .

Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes).

Testfälle

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

Bestenlisten

Das folgende Stack-Snippet generiert sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache. Also, auch wenn Sie mit Ihrer Sprache nicht die gesamte Herausforderung gewinnen können, warum nicht versuchen, einen Platz auf der zweiten Liste zu ergattern?

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

# 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 Bytes

~{0]$1=}*

Übernimmt die Eingabe von stdin im Format [-4 -2 -3 -2]

Dies verwendet die eingebaute Sortierfunktion $, aber jedes Mal, wenn es aufgerufen wird, ist es auf einem Array von 3 Elementen, was erlaubt ist.

Online-Demo

Mathematica, 19 Bytes

Median[#~Riffle~0]&

Code und Golfen dank Martin Büttner.

Dies ist eine unbenannte reine Funktion, die eine Liste von Ganzzahlen als Eingabe aufnimmt. Rufe es so auf

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

oder in ähnlicher Weise als Variable gespeichert.

Der Code riffelt zuerst alle zwei Elemente der Eingabeliste mit einer Null, wodurch n-1Nullen zwischen den nElementen eingefügt werden. Dann wird der Median benötigt, um die Antwort zu erhalten.

Dies gibt min-mod, weil es jeden Fall behandelt:

1. Alle Zahlen sind positiv, in diesem Fall liegen die Nullen darunter und der Median ist die niedrigste positive Zahl.

2. Alle Zahlen sind negativ. In diesem Fall liegen die Nullen darüber und der Median ist die am wenigsten negative Zahl.

3. Es gibt sowohl eine positive als auch eine negative Zahl, und daher ist das mittlere Element eine Null.

Wenn Mathematica seinen Median mit dem linearen Zeitauswahlalgorithmus implementiert , ist dies auch O (n).

Haskell, 62 61 39 38 37 Bytes

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

unter Verwendung von Vergleichszauber, der aus @ Zgarbs Antwort * entlehnt wurde, nämlich x*x<=x*y.

x*x<=x*yist nur wahr, wenn xund yhaben das gleiche Vorzeichen und yder absolute Wert ist größer. beachten Sie, dass , wenn xist 0es immer wahr ist.

Wir stellen fest, dass dies xdas Ergebnis ist, wenn es in enthalten ist s, und dass für alle yin s xdasselbe Vorzeichen wie yund im absoluten Wert kleiner ist. Wenn kein Wert sdiese Definition erfüllt, 0ist das Ergebnis.

fDann wird nach seinem Element gesucht , um dies zu erfüllen, und es wird 0als Standard verwendet.

_{* obwohl er es aus den Gründen, aus denen ich es benutze, nicht benutzt hat und es mittlerweile tatsächlich losgeworden ist}

JavaScript (ES6), 39 Byte

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

Die Idee ist, reduceden Min-Mod-Finder mit zwei Eingängen in einen n-Eingangs -Finder zu verwandeln. Ich habe es unabhängig von den anderen Antworten gefunden, die es verwenden. Nur Python 2 unterstützt reduce.

Die Lösung mit zwei Eingängen ermittelt einfach den Median der beiden Zahlen und Null. In meiner Mathematica-Antwort finden Sie eine direktere Möglichkeit, den Median zu verwenden.

Weniger golfen:

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

Ein hypothetisches Amalgam von Python 2 und Python 3 wäre ein Zeichen kürzer, mit dem mit Stern gekennzeichneten Zuordnung von Python und 3 sein input()und printaus Python 2.

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

Alter Code ohne Sortierung:

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

Marbelous, 210 Bytes

@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
\/

Hier werden drei Boards verwendet.

Die |Tafel ( Abin der lesbaren Version) nimmt den absoluten Wert einer Murmel (entweder durch Rückgabe der übergebenen Murmel oder Null minus der übergebenen Murmel, da alle Arithmetik in Marbelous ohne Vorzeichen ist).

Die MTafel ( Minabsin der lesbaren Version) findet den ersten oder den zweiten übergebenen Marmor und gibt ihn links aus (je nachdem, welcher Wert einen geringeren absoluten Wert hat).

Das MBoard gibt auch die Murmel frei, die es nach unten statt nach links hält, sobald das letzte Zeichen von STDIN abgerufen wurde.

Die MKarte wird auf der Hauptkarte verwendet, um die minmod aller überprüften Werte zu einem bestimmten Zeitpunkt zu speichern, da sie den zu speichernden Wert nach links freigibt, der dann wieder in die Karte umgelenkt wird.

Mülleimer ( \/) wurden nur unter Synchronisierern platziert, die andernfalls zu STDIN drucken würden.

Eingabe / Ausgabe verwendet STDIN / STDOUT. Beide behandeln 8-Bit-Werte (wenn Sie + 0x30 und + 0x38 übergeben wollten, platzieren Sie diese 08in STDIN).

Bibliotheken und zylindrische Tafeln sind erforderlich. Es wird empfohlen, die Ausgabe als Dezimalzahl anzuzeigen (beachten Sie, dass der vorzeichenlose Wert des minmod-Ergebnisses angezeigt wird).

Teste es hier.

Hinweis: Für weitere menschenfreundliche Eingabe / Ausgabe, fügen Sie Dpunter der letzten Zeile der Hauptplatine (vor :M), ersetzen Sie ]]mit Rdund fügen Sie die folgende an der Unterseite:

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

Dies ändert einfach die Ausgabe auf 3 Dezimalstellen. Ebenso erfordert die Eingabe mit diesen Änderungen eine durch Leerzeichen getrennte Liste mit 3 Dezimalstellen pro Zahl.

Lesbare Version:

Haskell, 83 40 39 Bytes

Dies ist wahrscheinlich nicht die kürzest mögliche Haskell-Lösung (und wird die anderen hier sicherlich nicht schlagen), aber es ist ein Anfang. EDIT: Jetzt über 50% kürzer! EDIT2: Ein Byte weniger ...

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

Dies ist nur eine einfache Falte (oder zu reduzieren, da einige Sprachen es nennen) durch den binären Operator #, der den Median berechnet a, bund 0. Obwohl die Regeln es mir jetzt erlauben würden, kleine Listen zu sortieren, erfordert dies einen Import in Haskell und führt zu einer höheren Byteanzahl ( 49 Bytes, aber 31 ohne den Import):

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

TIS-100, 696 526 Bytes

@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

Erwartet, dass die Sequenz von beendet wird -999. TIS-100 ist neuer als diese Frage, aber das ist hier sowieso nicht wichtig.

Knoten 9 verfolgt, ob wir alle positiv, alle negativ oder gemischt sind. Die Knoten 5 und 6 ermitteln das Minimum des Absolutwerts aller eingegebenen Zahlen. Der Knoten 10 wählt dann das Minimum, das Minimum negiert oder 0, abhängig vom Zustand des Knotens 9.

CJam, 20 Bytes (oder 10 Bytes)

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

Reduzieren Sie bei Verwendung des @ xnor-Ansatzes die Berechnung von minmod von 2 Zahlen gleichzeitig aus dem Array.

Dies wären 19 Bytes gewesen, wenn :zgearbeitet hätte

Verwenden der neuen Regel zur Verwendung von Sortierungen für kurze Arrays:

q~{0]$1=}*

Das entspricht genau der Antwort von @ Peter

Vorherige 26 Bytes als Antwort:

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

Dies kann weiter golfen werden ...

Eingabe (über STDIN) ist das Integer-Array wie folgt:

[-4 -2 -3 -2]

und output ist das minmod des input-Arrays

Probieren Sie es hier aus

Wenn nur :gund :zfunktioniert hätte, wäre dies 4 Bytes kürzer gewesen.

Java, 84 Bytes

Das ist Java in seiner ganzen Pracht. Schlägt GolfScript um etwas mehr als 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;}

In der Klasse eingewickelt:

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

}

Mit Kommentaren erweitert:

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

}

Hinweis: Dies kann mit Java 8 verbessert werden.

Hinweis: Die Verbesserung in Java 8 ist fehlgeschlagen.

J, 20 12 Bytes

Funktion, die die Liste als Argument verwendet. Aus dem Golfscript / CJam / was auch immer gestohlen.

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

Das minmod von xund yist der Median (sortiere /:~und nimm die Mitte 1{) der Liste der drei Elemente 0,x,y. Reduzieren Sie die Liste ( Folding in J-Sprache), indem Sie dieses Minmod zwischen benachbarten Elementen nehmen.

Im Einsatz bei der REPL. (J buchstabiert sein negatives Vorzeichen _.)

   (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

Alter Müll, bevor ich bemerkte, dass kurze Sortierungen erlaubt sind: 0:`<.`>.@.(*@]*0<*))/Das minmod von xund yist 0 ( 0:), wenn 0 größer oder gleich dem Produkt von xund ist y, sonst ist es das min ( <.) oder das max ( >.) zwischen xund yabhängig vom Vorzeichen . Falten Sie dies über die gesamte Liste.

TI-BASIC, 19 Bytes

Übernimmt die Eingabe im Format {-2,4,3}.

Funktioniert ähnlich wie die Antwort von 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 Bytes

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

Dieses basiert weg von meiner pyth Antwort, die inspiriert wurde Migs Antwort.

Alte Antwort:

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

Das ist eine sehr lange Antwort. Ich habe das Gefühl, 2 Variablen zu haben, ist eine Verschwendung ...? Ich lag richtig...? ish? ; p

KDB / Q, 43 Zeichen für die Definition des Funktionskörpers

Dank großartiger Ideen aus früheren Beiträgen:

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

Geben Sie eine einzelne Nummer mit Enlist ein

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]

Ich bin sicher, dass einige Q-Guru mit kürzeren kommen können.

Pyth, 25, 22, 20, 12

uhtS[0GH)QhQ

Wahrscheinlich nicht neu, aber original: P

Vorsortierung erlaubt

u*?Gx>GH>G0H>*GHZQhQ

Pyth

Probieren Sie es online aus.

Die Idee, reduceternäre Aussagen zu verwenden, wurde Migs Antwort schamlos gestohlen , aber ich habe keine Ahnung, ob diese Algorithmen ansonsten sogar ähnlich sind, da ich ternäre Aussagen nicht lesen kann.

Erläuterung:

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 Bytes

Mein erster Versuch, Code-Golf zu spielen und in einer ziemlich golffeindlichen Sprache. Basiert auf Reduce ( Aggregatein LINQ) und ist der JavaScript-Antwort von Mig sehr ähnlich . Kann wie gelaufen werden (new System.Linq.M()).m(new[] {1, 2, 3}). Besteht alle Testfälle, verarbeitet jedoch keine leeren Eingabearrays.

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 Bytes

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

Die Funktion reduziert die Liste (genannt folding ( /) in J) mit dem Ausdruck:

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

[x,y][abs(x)>abs(y)]ist ywenn abs(x) > abs(y)sonst x.

Beispiel:

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

Probieren Sie es hier online aus.

Game Maker Language, 489 Byte

Über Game Maker Language

Riffelt das Array (Nullen werden angehängt) und gibt den Median zurück (ähnlich wie bei meiner anderen Antwort)

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 Bytes

Stellen Sie die schlechteste Sprache für Codegolf mit dem schlechtesten Golfer der Welt zusammen und Sie erhalten ...

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 es und du bekommst:

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

Dies ist eine Funktion (wenn es nicht ganz offensichtlich war), die ein Array von Zahlen empfängt, deren Werte verarbeitet und den minmod-Wert zurückgibt.

Mein alter Benemoth von einer Sollution ist auch dabei, was - wie immer - ein ganzes Programm ist.

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 es und du bekommst:

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

Erhält unendlich viele Zahlen, stoppt, wenn ein Wert eingegeben wird, der keine Zahl ist, und zeigt den Minmon-Wert an.

R, 20 Zeichen

R ist normalerweise nicht gut für Codegolf, aber ich benutze es für meine Arbeit, also wollte ich es versuchen. Bevor ich es versuchte, wusste ich nicht, dass R bereit ist, solch eine unsaubere Syntax zu akzeptieren! :-) 52 Zeichen :

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

Dann habe ich mir die anderen Antworten angesehen, die ich bei xnors genialem Median-Trick ausprobiert habe, was großartig ist!

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

Python, 52

Ich konnte immer noch nicht anders, als das Gefühl zu haben, dass es schlecht ist, zwei zu haben lambda. Diese Funktion nimmt eine Liste auf und gibt dann eine Liste mit einem Element zurück, die das Ergebnis enthält.

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

Es wird hoffentlich keine enorme Beleidigung hervorrufen, das Ergebnis in einer Liste mit einem Element zu haben.

Matlab / Octave, 26

Dies ist im Grunde nur eine Übersetzung der Mathematica-Antwort von xnor. Es funktioniert, indem eine Null weniger als die Länge des Eingabevektors angehängt wird. Beachten Sie, dass das Anhängen eines weiteren nicht funktioniert, da das Ergebnis die ganze Zeit 0 ist. Danke an MartinBüttner für die -4 Zeichen dieser Lösung =)

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

Python, 72-60 Bytes

Dies ist die erste Lösung, an die ich gedacht habe, und sie ist ziemlich naiv. Die zweite Hälfte ist im Grunde ein Duplikat der ersten Hälfte des Codes, aber ich war mir nicht sicher, wie ich ihn verkleinern sollte. Ich frage mich, ob es gekürzt werden kann mit eval...

Edit: Lambdas zu Verständnis geändert.

Probieren Sie sie hier aus

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

Dies ist nur 4 Zeichen länger, aber mit dem TIP von Sp3000 immer noch einen Blick wert .

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)

Eine lesbarere Version:

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