La funzione minmod è una variante del familiare min , che appare negli schemi ad alta risoluzione che limitano la pendenza per equazioni differenziali parziali. Dato un certo numero di pendenze, rileva la pendenza più piatta, mentre si prende cura dei segni relativi tra le pendenze.

La funzione accetta un numero arbitrario di parametri. Quindi minmod (x ₁ , x ₂ , ..., x _n ) è definito come:

• min (x ₁ , x ₂ , ..., x _n ) , se tutti x _i sono strettamente positivi
• max (x ₁ , x ₂ , ..., x _n ) , se tutti x _i sono strettamente negativi
• 0 , altrimenti.

Prenderemo in considerazione solo input di numeri interi, poiché ciò non influisce realmente sull'implementazione e dovrebbe essere più inclusivo per alcune lingue (esoteriche).

Scrivi un programma o una funzione, che accetta n numeri interi con segno (per n> 0 ) tramite STDIN, ARGV o argomento di funzione (puoi usare un array se è più conveniente di una funzione variadica) e restituisce o stampa (su STDOUT) il risultato di minmod (a, b) .

Non è necessario utilizzare le funzioni min o max incorporate (e ovviamente nemmeno minmod incorporato , se è possibile trovarlo). Inoltre, non è necessario utilizzare alcuna funzione di ordinamento integrata, ad eccezione di un numero limitato di elementi fisso (inferiore a 5).

Se la tua lingua non ha tipi con segno, puoi usare un tipo senza segno e interpretarlo come complemento a due. Ad esempio, se la tua lingua utilizza solo byte senza segno, puoi utilizzare 255per sostituire -1e 128sostituire -128, ecc.

Questo è il golf del codice, quindi vince la risposta più breve (in byte).

Casi test

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

Classifiche

Il seguente frammento di stack genera sia una classifica regolare che una panoramica dei vincitori per lingua. Quindi, anche se la tua lingua preferita non ti consente di vincere l'intera sfida, perché non provare a prendere un posto nella seconda lista?

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

~{0]$1=}*

Presuppone l'input di stdin nel formato [-4 -2 -3 -2]

Questo utilizza la funzione di ordinamento integrata $, ma ogni volta che viene invocato si trova su un array di 3 elementi, che è consentito.

Demo online

Mathematica, 19 byte

Median[#~Riffle~0]&

Codice e golf grazie a Martin Büttner.

Questa è una funzione pura senza nome che accetta come input un elenco di numeri interi. Invocalo come

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

o similmente salvato in variabile.

Il codice cerca inizialmente uno zero tra ogni due elementi dell'elenco di input, che inserisce n-1zero tra gli nelementi. Quindi, ci vuole la mediana per produrre la risposta.

Questo dà min-mod perché gestisce ogni caso:

1. Tutti i numeri sono positivi, nel qual caso gli zero sono sotto di essi e la mediana è il numero positivo più basso.

2. Tutti i numeri sono negativi, nel qual caso gli zero sono sopra di essi e la mediana è il numero meno negativo.

3. C'è sia un numero positivo che negativo, quindi l'elemento centrale è uno zero.

Se Mathematica implementa la sua mediana usando l' algoritmo di selezione del tempo lineare , anche questo è O (n).

Haskell, 62 61 39 38 37 byte

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

usando un po 'di magia comparativa mutuata dalla risposta di @ Zgarb *, vale a dire x*x<=x*y.

x*x<=x*yè vero solo quando xe yha lo stesso segno e yil valore assoluto è maggiore. notare che quando xè 0si è sempre vero.

determiniamo che xè il risultato se è contenuto in s, e che per tutti yin s xha lo stesso segno yed è più piccolo in valore assoluto. se nessun valore ssoddisfa questa definizione, allora 0è il risultato.

fquindi funziona cercando sun elemento per soddisfarlo e lo utilizza 0come predefinito.

_{* sebbene non l'abbia usato per i motivi per cui lo sto usando, e in realtà se ne è liberato ormai}

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

L'idea è di usare reduceper trasformare il cercatore min-mod a due ingressi in uno di ingresso n. L'ho inventato indipendentemente dalle altre risposte che lo usano. Supporta solo Python 2 reduce.

La soluzione a due input trova semplicemente la mediana dei due numeri e zero. Vedi la mia risposta Mathematica per un modo più diretto di usare la mediana.

Meno golf:

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

Un ipotetico amalgama di Python 2 e Python 3 sarebbe un personaggio più breve, con l'assegnazione stellata da Python 3 input()e printda Python 2.

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

Vecchio codice, senza ordinamento:

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

Marbelous, 210 byte

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

Ci sono tre schede utilizzate qui.

Il |tabellone ( Abnella versione leggibile) assume il valore assoluto di un marmo (restituendo il marmo passato o zero meno il marmo passato, poiché tutta l'aritmetica in Marbelous non è firmata).

La Mscheda ( Minabsnella versione leggibile) trova ed emette a sinistra il primo o il secondo marmo passato (qualunque abbia un valore assoluto più piccolo), ed esce se viene passato un altro marmo firmato.

La Mscheda inoltre rilascia il marmo che tiene verso il basso anziché verso sinistra una volta che l'ultimo personaggio di STDIN è stato preso.

La Mscheda viene utilizzata nella scheda principale per memorizzare il minmod di tutti i valori controllati in qualsiasi momento, in quanto rilascia il valore da salvare a sinistra, che viene quindi deviato nuovamente dentro.

I cestino ( \/) venivano posizionati solo sotto sincronizzatori che altrimenti sarebbero stati stampati su STDIN.

Input / Output utilizza STDIN / STDOUT. Entrambi hanno a che fare con valori a 8 bit (se si desidera passare + 0x30 e + 0x38, inserire 08in STDIN).

Sono necessarie librerie e schede cilindriche. Si consiglia di visualizzare l'output come numeri decimali (si noti che questo visualizza il valore senza segno del risultato minmod).

Provalo qui.

Nota: per input / output più umani, aggiungere Dpsotto l'ultima riga della scheda principale (prima :M), sostituire ]]con Rde aggiungere quanto segue in basso:

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

Questo cambia semplicemente l'output in 3 cifre decimali. Allo stesso modo, l'input con queste modifiche richiede un elenco separato da spazi di 3 cifre decimali per numero.

Versione leggibile:

Haskell, 83 40 39 byte

Questa probabilmente non è la soluzione Haskell più breve possibile (e certamente non batterà gli altri qui), ma è un inizio. EDIT: ora più del 50% in meno! EDIT2: un byte in meno ...

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

Questa è solo una piega semplice (o ridotta, come alcune lingue lo chiamano) da parte dell'operatore binario #, che calcola la mediana di a, be 0. Anche se ora le regole mi permettono di ordinare piccoli elenchi, ciò richiede un'importazione in Haskell e comporta un conteggio di byte più elevato ( 49 byte, ma 31 senza l'importazione):

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

TIS-100, 696 526 byte

@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

Si aspetta che la sequenza venga terminata da -999. TIS-100 è più recente di questa domanda, ma non è comunque importante qui.

Il nodo 9 tiene traccia del fatto che siamo tutti positivi, tutti negativi o misti. I nodi 5 e 6 lavorano per trovare il minimo del valore assoluto di tutti i numeri di input. Il nodo 10 seleziona quindi il minimo, il minimo negato o 0 a seconda dello stato del nodo 9.

CJam, 20 byte (o 10 byte)

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

Usando l'approccio di @ xnor, riduci il calcolo di minmod di 2 numeri alla volta dall'array.

Sarebbe stato di 19 byte se :zfunzionasse

Utilizzo della nuova regola di utilizzo degli ordinamenti su array brevi:

q~{0]$1=}*

che è esattamente equivalente alla risposta di @ Peter

Risposta precedente 26 byte:

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

Questo può essere golfato ulteriormente ...

L'input (tramite STDIN) è l'array intero come:

[-4 -2 -3 -2]

e output è il minmod dell'array di input

Provalo qui

Se solo :ge :zlavorato, questo sarebbe stato più breve di 4 byte.

Java, 84 byte

Questo è Java in tutto il suo splendore. Batte GolfScript di un fattore leggermente superiore al 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;}

Avvolto in classe:

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

}

Ampliato con commenti:

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

}

Nota: questo può essere migliorato usando Java 8.

Nota: lo sforzo per migliorare in Java 8 non è riuscito.

J, 20 12 byte

Funzione che prende l'elenco come argomento. Rubato dal Golfscript / CJam / qualunque cosa.

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

Il minmod di xed yè la mediana (ordina /:~e prendi il centro 1{) dell'elenco dei tre elementi 0,x,y. Ridurre l'elenco ( pieghevole in J parlance) prendendo questo minmod tra elementi adiacenti.

In uso presso il REPL. (J scrive il suo segno negativo _.)

   (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

Vecchia spazzatura, prima ho notato che sono consentiti tipi brevi: 0:`<.`>.@.(*@]*0<*))/Il minmod di xe yè 0 ( 0:) se 0 è maggiore o uguale al prodotto di xe y, altrimenti è il min ( <.) o il max ( >.) tra xe in ybase al segno . Piegalo su tutto l'elenco.

TI-BASIC, 19 byte

Presuppone l'input nel formato {-2,4,3}.

Funziona in modo simile alla risposta di 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 byte

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

Questo si basa sulla mia risposta Pyth, che è stata ispirata dalla risposta di Mig .

Vecchia risposta:

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

Questa è una risposta molto lunga Sento che avere 2 variabili sia uno spreco ...? Avevo ragione...? ish? ; p

KDB / Q, 43 caratteri per la definizione del corpo della funzione

Grazie alle grandi idee dei post precedenti:

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

Immettere un numero singolo usando enlist

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]

Sono sicuro che alcuni Q guru possono inventarne di più brevi.

Pyth, 25 22 20 12

uhtS[0GH)QhQ

Probabilmente non romanzo, ma originale: P

Preordinamento consentito

u*?Gx>GH>G0H>*GHZQhQ

Pyth

Provalo online.

L'idea da usare reducee le dichiarazioni ternarie è stata sottratta senza vergogna alla risposta di Mig , ma non ho idea se questi algoritmi siano altrimenti simili, poiché non riesco a leggere le dichiarazioni ternarie.

Spiegazione:

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 byte

Il mio primo tentativo di giocare a golf a codice e in un linguaggio ostile al golf. Basato su ridurre ( Aggregatein LINQ) e molto simile alla risposta JavaScript di Mig . Può essere eseguito come (new System.Linq.M()).m(new[] {1, 2, 3}). Supera tutti i casi di test, ma non gestisce array di input vuoti.

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 byte

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

La funzione riduce l'elenco (chiamato pieghevole ( /) in J) con l'espressione:

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

[x,y][abs(x)>abs(y)]è yse abs(x) > abs(y)altrox .

Esempio:

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

Provalo online qui.

Lingua di Game Maker, 489 byte

Informazioni sulla lingua di Game Maker

Riflette l'array (vengono aggiunti degli zeri) e restituisce la mediana (simile alla mia altra risposta)

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 byte

Metti insieme la lingua peggiore per il golf del codice con il peggior golfista del mondo e otterrai ...

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

Scollegalo e otterrai:

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

Questa è una funzione (se non fosse dannatamente ovvia) che riceve una matrice di numeri ed elabora i suoi valori, restituendo il valore minmod.

È inclusa anche la mia vecchia benemoth di un sollution, che è un intero programma - come sempre.

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

Scollegalo e otterrai:

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

Riceve numeri infiniti, si ferma quando viene inserito un valore non numerico, presentando il valore Minmon.

R, 20 caratteri

R di solito non è buono per codegolf, ma lo uso per il mio lavoro, quindi volevo provare. Prima di provare, non sapevo che R fosse disposto ad accettare una sintassi così sporca! :-) 52 caratteri :

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

Poi ho cercato le altre risposte che ho provato con il trucco geniale mediano di @ xnor, che è fantastico!

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

Python, 52

Non potevo ancora fare a meno di sentire che è male avere due lambdasecondi. Questa funzione accetta un elenco e quindi restituisce un elenco di un elemento contenente il risultato.

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

Si spera che non provochi un'enorme quantità di reato in un elenco di un elemento.

Matlab / Octave, 26

Questa è fondamentalmente solo una traduzione della risposta di Mathematica da parte di xnor. Funziona aggiungendo uno zero in meno della lunghezza del vettore di input. Si noti che aggiungerne uno in più non funzionerebbe, da allora il risultato sarebbe sempre 0. Grazie a MartinBüttner per i -4 caratteri di questa soluzione =)

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

Python, 72 60 byte

Questa è la prima soluzione a cui ho pensato ed è abbastanza ingenua. La seconda metà è sostanzialmente un duplicato della prima metà del codice, ma non ero sicuro di come snellirlo. Mi chiedo se può essere abbreviato usando eval...

Modifica: Lambdas modificato a comprensioni.

Provali qui

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

Questo è solo 4 caratteri più a lungo, ma vale comunque la pena guardarlo, usando il TIP di 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)

Una versione più leggibile:

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