La fonction minmod est une variante du min familier , qui apparaît dans les schémas haute résolution limitant la pente pour les équations différentielles partielles. Étant donné un certain nombre de pentes, il sélectionne la pente la plus plate, tout en prenant soin des signes relatifs entre les pentes.

La fonction prend un nombre arbitraire de paramètres. Alors minmod (x ₁ , x ₂ , ..., x _n ) est défini comme:

• min (x ₁ , x ₂ , ..., x _n ) , si tous les x _i sont strictement positifs
• max (x ₁ , x ₂ , ..., x _n ) , si tous les x _i sont strictement négatifs
• 0 sinon.

Nous ne considérerons que les entrées entières, car cela n'affecte pas vraiment l'implémentation et devrait être plus inclusif pour certaines langues (ésotériques).

Écrire un programme ou une fonction, qui prend n entiers signés (pour n> 0 ) via STDIN, ARGV ou argument de fonction (vous pouvez utiliser un tableau si cela est plus pratique qu'une fonction variadique), et retourne ou imprime (à STDOUT) le résultat de minmod (a, b) .

Vous ne devez pas utiliser les fonctions min ou max intégrées (et évidemment, pas de minmod intégré non plus, si vous pouvez réellement le trouver). De plus, vous ne devez utiliser aucune fonction de tri intégrée, sauf pour trier un petit nombre fixe d'éléments (moins de 5).

Si votre langue n'a pas de types signés, vous pouvez utiliser un type non signé et l' interpréter comme un complément à deux. Par exemple, si votre langue n'utilise que des octets non signés, vous pouvez utiliser 255pour remplacer -1et 128pour remplacer -128, etc.

Il s'agit du code golf, donc la réponse la plus courte (en octets) l'emporte.

Cas de 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

Classements

L'extrait de pile suivant génère à la fois un classement régulier et un aperçu des gagnants par langue. Donc, même si la langue de votre choix ne vous permet pas de remporter l'intégralité du défi, pourquoi ne pas essayer de vous arracher une place sur la deuxième liste?

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. Par exemple:

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

~{0]$1=}*

Suppose l'entrée de stdin au format [-4 -2 -3 -2]

Cela utilise la fonction de tri intégrée $, mais chaque fois qu'il est invoqué, c'est sur un tableau de 3 éléments, ce qui est autorisé.

Démo en ligne

Mathematica, 19 octets

Median[#~Riffle~0]&

Code et golf grâce à Martin Büttner.

Il s'agit d'une fonction pure sans nom qui prend en entrée une liste d'entiers. Invoquez-le comme

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

ou enregistré de manière similaire dans une variable.

Le code diffuse d'abord un zéro entre tous les deux éléments de la liste d'entrée, ce qui insère des n-1zéros entre les néléments. Ensuite, il faut la médiane pour produire la réponse.

Cela donne min-mod car il gère chaque cas:

1. Tous les nombres sont positifs, auquel cas les zéros sont en dessous d'eux et la médiane est le nombre positif le plus bas.

2. Tous les nombres sont négatifs, auquel cas les zéros sont au-dessus d'eux et la médiane est le nombre le moins négatif.

3. Il y a à la fois un nombre positif et négatif, et donc l'élément du milieu est un zéro.

Si Mathematica implémente sa médiane en utilisant l' algorithme de sélection en temps linéaire , alors c'est aussi O (n).

Haskell, 62 61 39 38 37 octets

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

en utilisant la magie de comparaison empruntée @ réponse Zgarb de *, à savoir x*x<=x*y.

x*x<=x*yn'est vrai que lorsque xet yont le même signe et que yla valeur absolue est plus grande. noter que quand xest 0il est toujours vrai.

nous estimons que xest le résultat IFF est contenu dans s, et que pour tous yen s xa le même signe que yet est plus petite en valeur absolue. si aucune valeur ne ssatisfait à cette définition, alors 0le résultat est.

ffonctionne ensuite en recherchant sun élément pour y répondre et l'utilise 0par défaut.

_{* bien qu'il ne l'ait pas utilisé pour les raisons pour lesquelles je l'utilise, et il s'en est déjà débarrassé}

JavaScript (ES6), 39 octets

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'idée est d'utiliser reducepour transformer le chercheur de min-mod à deux entrées en un chercheur à n-entrée. Je l'ai trouvé indépendamment des autres réponses qui l'utilisent. Seul Python 2 prend en charge reduce.

La solution à deux entrées trouve simplement la médiane des deux nombres et zéro. Voir mon réponse Mathematica pour une façon plus directe d'utiliser la médiane.

Moins golfé:

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

Un amalgame hypothétique de Python 2 et Python 3 serait un caractère plus court, avec l'affectation étoilée de Python 3 input()et printde Python 2.

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

Ancien code, sans tri:

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

Marbelous, 210 octets

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

Il y a trois planches utilisées ici.

Le |conseil d'administration (Ab dans la version lisible) prend la valeur absolue d'un marbre (soit en retournant le marbre passé, soit zéro moins le marbre passé, car toute l'arithmétique de Marbelous n'est pas signée).

Le Mconseil d'administration (Minabs dans la version lisible) trouve et sort à gauche la première ou la seconde bille passée (selon celle qui a une valeur absolue la plus petite), et se ferme si une bille signée différente est passée.

Le Mplateau libère également la bille qu'il tient vers le bas au lieu de la gauche une fois que le dernier personnage de STDIN est récupéré.

La Mcarte est utilisée dans la carte principale pour stocker le minmod de toutes les valeurs vérifiées à un moment donné, car elle libère la valeur à enregistrer vers la gauche, qui est ensuite renvoyée.

Les poubelles ( \/) ont été placées uniquement sous des synchroniseurs qui autrement s'imprimeraient sur STDIN.

L'entrée / sortie utilise STDIN / STDOUT. Les deux traitent des valeurs 8 bits (si vous voulez passer + 0x30 et + 0x38, placez-les 08dans STDIN).

Des bibliothèques et des planches cylindriques sont nécessaires. Il est recommandé de visualiser la sortie sous forme de nombres décimaux (notez que cela affiche la valeur non signée du résultat minmod).

Testez-le ici.

Remarque: pour une entrée / sortie plus conviviale, ajoutez Dpsous la dernière ligne de la carte principale (avant :M), remplacez ]]par Rdet ajoutez ce qui suit en bas:

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

Cela change simplement la sortie à 3 chiffres décimaux. De même, la saisie avec ces modifications nécessite une liste séparée par des espaces de 3 chiffres décimaux par numéro.

Version lisible:

Haskell, 83 40 39 octets

Ce n'est probablement pas la solution Haskell la plus courte possible (et ne battra certainement pas les autres ici), mais c'est un début. EDIT: Maintenant plus de 50% plus court! EDIT2: Un octet de moins ...

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

C'est juste un pli simple (ou réduit, comme certains langages l'appellent) par l'opérateur binaire #, qui calcule la médiane de a, bet 0. Même si les règles me permettraient désormais de trier de petites listes, cela nécessite une importation dans Haskell et entraîne un nombre d'octets plus élevé ( 49 octets, mais 31 sans l'importation):

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

TIS-100, 696 526 octets

@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

Attend que la séquence soit terminée par -999 . TIS-100 est plus récent que cette question, mais ce n'est pas comme si cela importait de toute façon.

Le nœud 9 permet de savoir si nous sommes tous positifs, tous négatifs ou mélangés. Les nœuds 5 et 6 fonctionnent pour trouver le minimum de la valeur absolue de tous les nombres d'entrée. Le nœud 10 sélectionne ensuite le minimum, le minimum annulé ou 0 selon l'état du nœud 9.

CJam, 20 octets (ou 10 octets)

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

En utilisant l'approche @ xnor, réduisez le calcul du minmod de 2 nombres à la fois à partir du tableau.

Cela aurait été de 19 octets si :ztravaillé

Utilisation de la nouvelle règle d'utilisation des tris sur des tableaux courts:

q~{0]$1=}*

ce qui est exactement équivalent à la réponse de @ Peter

Réponse précédente de 26 octets:

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

Cela peut être joué plus loin ...

L'entrée (via STDIN) est le tableau entier comme:

[-4 -2 -3 -2]

et la sortie est le minmod du tableau d'entrée

Essayez-le ici

Si seulement :get :zfonctionnait, cela aurait été de 4 octets plus court.

Java, 84 octets

C'est Java dans toute sa splendeur. Beats GolfScript d'un facteur légèrement supérieur à 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;}

Enveloppé en 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;}

}

Développé avec des commentaires:

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

}

Remarque: Cela peut être amélioré à l'aide de Java 8.

Remarque: les efforts d'amélioration dans Java 8 ont échoué.

J, 20 12 octets

Fonction prenant la liste en argument. Volé au Golfscript / CJam / peu importe.

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

Le minmod de xet yest la médiane (trier /:~et prendre le milieu 1{) de la liste des trois éléments 0,x,y. Réduisez la liste ( pliage en J) en prenant ce minmod entre les éléments adjacents.

Utilisé au REPL. (J épelle son signe négatif _.)

   (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

Les vieilles ordures, avant de remarquer que les tris courts sont autorisés: 0:`<.`>.@.(*@]*0<*))/Le minmod de xet yest 0 ( 0:) si 0 est supérieur ou égal au produit de xet y, sinon c'est le min ( <.) ou le max ( >.) entre xet yselon le signe . Pliez cela sur toute la liste.

TI-BASIC, 19 octets

Suppose une entrée au format {-2,4,3}.

Fonctionne de manière similaire à la réponse de 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 octets

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

Ceci est basé sur ma réponse pyth, qui a été inspirée par la réponse de Mig .

Ancienne réponse:

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

C'est une réponse très longue. J'ai l'impression que 2 variables sont un gaspillage ...? J'avais raison...? hein? ; p

KDB / Q, 43 caractères pour la définition du corps de la fonction

Merci aux bonnes idées des articles précédents:

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

Entrez un numéro unique à l'aide de l'enrôlement

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]

Je suis sûr que certains gourous Q peuvent en proposer de plus courts.

Pyth, 25 22 20 12

uhtS[0GH)QhQ

Probablement pas nouveau, mais original: P

Pré-tri autorisé

u*?Gx>GH>G0H>*GHZQhQ

Pyth

Essayez-le en ligne.

L'idée d'utiliser reduceet des déclarations ternaires a été impudemment volée dans la réponse de Mig , mais je n'ai aucune idée si ces algorithmes sont par ailleurs même similaires, car je ne peux pas lire les déclarations ternaires.

Explication:

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 octets

Mon premier essai au golf à code et dans un joli langage hostile au golf. Basé sur réduire ( Aggregatedans LINQ) et très similaire à la réponse JavaScript de Mig . Peut être exécuté comme (new System.Linq.M()).m(new[] {1, 2, 3}). Réussit tous les cas de test, mais ne gère pas les tableaux d'entrée vides.

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 octets

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

La fonction réduit la liste (appelée pliage ( /) en J) avec l'expression:

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

[x,y][abs(x)>abs(y)]est ysi abs(x) > abs(y)autre x.

Exemple:

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

Essayez-le en ligne ici.

Langue de Game Maker, 489 octets

À propos de la langue de Game Maker

Riffle le tableau (des zéros sont ajoutés) et renvoie la médiane (similaire à mon autre réponse)

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 octets

Rassemblez le pire langage pour le golf de code avec le pire golfeur du monde et vous obtenez ...

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

Dégagez-le et vous obtenez:

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

C'est une fonction (si ce n'était pas sacrément évident) qui reçoit un tableau de nombres et traite ses valeurs, renvoyant la valeur minmod.

Mon vieux benemoth d'une sollution est également inclus, ce qui est un programme entier - comme toujours.

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

Dégagez-le et vous obtenez:

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

Reçoit des nombres infinis, s'arrête lorsqu'une valeur non numérique est entrée, présentant la valeur Minmon.

R, 20 caractères

R n'est généralement pas bon pour codegolf, mais je l'utilise pour mon travail, donc je voulais essayer. Avant d'essayer, je ne savais pas que R acceptait une syntaxe aussi sale! :-) 52 caractères :

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

Ensuite, j'ai regardé les autres réponses que j'ai essayées.

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

Python, 52

Je ne pouvais toujours pas m'empêcher de penser que c'était mauvais d'avoir deux lambdas. Cette fonction prend une liste, puis retourne une liste à un élément contenant le résultat.

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

Espérons que cela n'entraînera pas une énorme quantité d'infractions ayant pour résultat une liste à un élément.

Matlab / Octave, 26

Il s'agit essentiellement d'une traduction de la réponse Mathematica par xnor. Il fonctionne en ajoutant un zéro de moins que la longueur du vecteur d'entrée. Notez que l'ajout d'un autre ne fonctionnerait pas, car le résultat serait toujours 0. Merci à MartinBüttner pour les -4 caractères de cette solution =)

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

Python, 72 60 octets

C'est la première solution à laquelle j'ai pensé, et c'est assez naïf. La seconde moitié est essentiellement un double de la première moitié du code, mais je ne savais pas comment l'amincir. Je me demande si cela peut être raccourci en utilisant eval...

Edit: changé les lambdas en compréhensions.

Essayez-les ici

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

Cela ne fait que 4 caractères de plus, mais vaut la peine d'être examiné, en utilisant le TIP du 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)

Une version plus lisible:

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