Функція minmod - це варіант знайомого min , який з'являється в обмежуючих нахилі схемах високої роздільної здатності для часткових диференціальних рівнянь. Враховуючи ряд схилів, він вибирає найрівніший схил, доглядаючи за відносними знаками між схилами.

Функція приймає довільну кількість параметрів. Тоді minmod (x ₁ , x ₂ , ..., x _n ) визначається як:

• min (x ₁ , x ₂ , ..., x _n ) , якщо всі x _i суворо додатні
• max (x ₁ , x ₂ , ..., x _n ) , якщо всі x _i суворо негативні
• 0 , інакше.

Ми розглянемо лише цілі введення даних, оскільки це насправді не впливає на реалізацію і повинно бути більш інклюзивним для деяких (езотеричних) мов.

Напишіть програму або функцію, яка приймає n підписаних цілих чисел (для n> 0 ) через STDIN, ARGV або аргумент функції (ви можете використовувати масив, якщо це зручніше варіативної функції), і повертає або друкує (STDOUT) результат з minmod (а, б) .

Ви не повинні використовувати вбудовані min або max функції (і, очевидно, також немає вбудованого minmod , якщо ви дійсно можете це знайти). Крім того, ви не повинні використовувати жодних вбудованих функцій сортування, за винятком сортування фіксованої невеликої кількості елементів (менше 5).

Якщо у вашій мові немає підписаних типів, ви можете використовувати неподписаний тип та інтерпретувати його як доповнення двох. Наприклад, якщо у вашій мові використовуються лише непідписані байти, ви можете використовувати, 255щоб стояти за -1та 128виступати за -128тощо.

Це кодовий гольф, тому найкоротша відповідь (у байтах) виграє.

Випробування

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

Табло лідерів

Наступний фрагмент стека створює як звичайний таблицю лідерів, так і огляд переможців за мовою. Тож навіть якщо ваша обрана мова не дозволяє вам перемогти у всьому виклику, чому б не спробувати вирвати місце у другому списку?

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

# Language Name, N bytes

де Nрозмір вашого подання. Якщо ви покращите свій рахунок, ви можете зберегти старі бали у заголовку, прокресливши їх. Наприклад:

# 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 байт

~{0]$1=}*

Передбачає введення від stdin у форматі [-4 -2 -3 -2]

При цьому використовується вбудована функція сортування $, але щоразу, коли вона викликається, це масив із 3-х елементів, що дозволено.

Демонстрація в Інтернеті

Математика, 19 байт

Median[#~Riffle~0]&

Код та гольф завдяки Мартіну Бюттнеру.

Це неназвана чиста функція, яка приймає в якості списку цілі числа. Викликайте це як

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

або аналогічно збережено у змінній.

Код спочатку встановлює нуль між кожні два елементи вхідного списку, який вставляє n-1нулі серед nелементів. Тоді для отримання відповіді потрібна медіана.

Це дає min-mod, оскільки він обробляє кожен випадок:

1. Усі числа є додатними, в цьому випадку нулі знаходяться нижче них, а медіана - найнижче додатне число.

2. Усі числа від’ємні, у цьому випадку нулі вище їх, а медіана - найменше від’ємне число.

3. Існує і позитивне, і негативне число, і тому середній елемент дорівнює нулю.

Якщо Mathematica реалізує свою медіану, використовуючи алгоритм вибору лінійного часу , то це також O (n).

Хаскелл, 62 61 39 38 37 байт

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

використовуючи деякі порівняння магії запозичені з @ Zgarb у відповідь *, а саме x*x<=x*y.

x*x<=x*yсправедливо лише тоді, коли xі yмають однаковий знак, і yабсолютна величина більше. зверніть увагу , що , коли xце 0завжди вірно.

ми визначаємо, що xце результат, якщо він міститься s, і що для всіх yв s xмає той самий знак, що yі менший за абсолютною величиною. якщо жодне значення не sзадовольняє це визначення, то 0це результат.

fпотім працює, шукаючи sелемент, щоб задовольнити це, і використовує 0як за замовчуванням.

_{* хоча він не використовував його з тих причин, якими я користуюсь, і він насправді позбувся цього}

JavaScript (ES6), 39 байт

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

Пітон 2, 53

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

Ідея полягає в тому, reduceщоб перетворити міні-мондер з двома входами в n-вхідний. Я придумав це незалежно від інших відповідей, які його використовують. Підтримується лише Python 2 reduce.

Рішення з двома входами просто знаходить медіану двох чисел і нуль. Дивіться мою відповідь Mathematica щодо більш прямого способу використання медіани.

Менше гольфу:

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

Гіпотетична амальгама з Python 2 та Python 3 була б символом коротшою, із призначенням зірки з Python 3 input()та printз Python 2.

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

Старий код, без сортування:

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

Marbelous, 210 байт

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

Тут використовуються три дошки.

The |Плата ( Abв читається варіанті) має абсолютне значення мармуру (або повернення переданого мармуру або нуля мінус переданий мармур, так як всі арифметичні операції в Marbelous беззнакові).

The MДошка ( Minabsв машиночитаемой версії) знахідки і виходах вліво першого або другого мармур пройшов ( в залежності від того має меншу абсолютну величину), і вихід , якщо передаються іншій підписаний мармур.

The MРада також випускає мармур він тримає вниз замість вліво після того , як останній символ з STDIN забирається.

The MПлата використовується в основній платі , щоб зберегти minmod усіх перевірених значень в будь-який момент часу, оскільки він звільняє значення , яке буде збережено вліво, який потім відхиляється назад.

Кошики для сміття (\/ ) розміщувалися лише під синхронізаторами, які в іншому випадку друкувалимуться на STDIN.

Для вводу / виводу використовується STDIN / STDOUT. Обидва мають справу з 8-бітовими значеннями (якщо ви хочете передати + 0x30 та + 0x38, розмістіть08 у STDIN).

Бібліотеки та циліндричні дошки обов'язково потрібні. Перегляд результатів у вигляді десяткових чисел рекомендується (зауважте, що це відображає непідписане значення результату minmod).

Перевірте це тут.

Примітка: Для більш зрозумілого введення / виведення, додайте Dpпо останньому рядку на головній платі (до :M), замініть ]]з Rd, і додати наступне в нижній частині :

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

Це просто змінює вихід на 3 знаки після коми. Аналогічно, для введення цих змін потрібен пробіл, розділений з 3 десяткових цифр на число.

Читаема версія:

Haskell, 83 40 39 байт

Це, мабуть, не найкоротше рішення Haskell (і, звичайно, тут не обійдуть інших), але це початок. EDIT: Тепер на 50% коротше! EDIT2: На один байт менше ...

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

Це просто просто скласти (або зменшити, так як деякі мови називають) бінарним оператором #, який обчислює медіану a, bі 0. Навіть незважаючи на те, що тепер правила дозволять мені сортувати невеликі списки, для цього потрібно імпортувати в Haskell і призводити до більшого числа байтів ( 49 байт, але 31 без імпорту):

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

TIS-100, 696 526 байт

@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

Очікує, що послідовність буде припинена -999 . TIS-100 є новішим, ніж це питання, але це все одно не має значення.

Вузол 9 відстежує, чи всі ми позитивні, чи всі негативні чи змішані. Вузли 5 і 6 працюють, щоб знайти мінімум абсолютного значення всіх вхідних чисел. Тоді вузол 10 вибирає мінімальний, мінімальний заперечений або 0 залежно від стану вузла 9.

CJam, 20 байт (або 10 байт)

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

Використовуючи підхід @ xnor, зменшіть обчислення minmod з 2 чисел одночасно з масиву.

Це було б 19 байт, якби вони :zпрацювали

Використання нового правила використання сортування на коротких масивах:

q~{0]$1=}*

що рівнозначно відповіді @ Петра

Попередні 26 байт:

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

Це можна пограти в гольф далі ...

Вхід (через STDIN) - цілий масив типу:

[-4 -2 -3 -2]

а вихід - minmod вхідного масиву

Спробуйте тут

Якби :gі :zпрацював, це було б на 4 байти коротше.

Java, 84 байти

Це Java у всій красі. Перемагає GolfScript в коефіцієнті трохи більше 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;}

Загорнутий у клас:

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

}

Розгорнуто коментарями:

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

}

Примітка. Це можна покращити за допомогою Java 8.

Примітка: Не вдалося вдосконалити роботу Java 8.

J, 20 12 байт

Функція, що приймає список як аргумент. Викрадено з Golfscript / CJam / що завгодно.

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

Мінімум xі yє медіаною (сортуйте /:~та візьміть середину 1{) списку трьох предметів 0,x,y. Скоротіть список ( складання в J-мові), перенісши цей мінімум між сусідніми елементами.

У користуванні на REPL. (J вимовляє свій негативний знак _.)

   (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

Старий сміття, перш ніж я помітив короткі сорти допускаються: 0:`<.`>.@.(*@]*0<*))/minmod з xі yє 0 ( 0:) , якщо 0 більше або дорівнює добутку xі y, інакше це мінімальне ( <.) або максимальне ( >.) між xі в yзалежності від знака . Складіть це по всьому списку.

TI-BASIC, 19 байт

Передбачає введення у форматі {-2,4,3} .

Діє подібно до відповіді 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

Пітон 2, 82 79 71 69 61 байт

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

Це засновано від мого pyth відповіді, який був натхненний Mig в відповідь.

Стара відповідь:

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

Це дуже довга відповідь. Я відчуваю, що мати 2 змінні - це марно ... Я був правий...? іш? ; стор

KDB / Q, 43 символи для визначення корпусу функції

Завдяки чудовим ідеям з попередніх дописів:

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

Введіть один номер, використовуючи список

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]

Я впевнений, що деякі гуру Q можуть придумати більш короткі.

Піта, 25 22 20 12

uhtS[0GH)QhQ

Напевно, не роман, але оригінальний: P

Дозволено попереднє сортування

u*?Gx>GH>G0H>*GHZQhQ

Піт

Спробуйте в Інтернеті.

Ідея використовувати reduceта потрійні заяви була безсоромно викрадена з відповіді Міга , але я не маю уявлення, чи ці алгоритми інакше навіть схожі, оскільки я не можу читати потрійні заяви.

Пояснення:

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 байт

Перша моя спроба в гольф-коді і досить ворожою мовою гольфу. На основі скорочення ( Aggregateв LINQ) і дуже схожого на відповідь JavaScript від Mig . Можна керувати так (new System.Linq.M()).m(new[] {1, 2, 3}). Проходить усі тестові випадки, але не обробляє порожні вхідні масиви.

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 байт

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

Функція зменшує список (називається складання (/ ) в J) з виразом:

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

[x,y][abs(x)>abs(y)]це yякщоabs(x) > abs(y) іншеx .

Приклад:

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

Спробуйте його онлайн тут.

Мова виробника ігор, 489 байт

Про мову виробника ігор

Розв'язує масив (нулі додаються) і повертає медіану (подібно до моєї іншої відповіді)

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}

Ява, 353 304 124 байт

Складіть найгіршу мову для кодового гольфу з найгіршим гольфістом у світі, і ви отримаєте ...

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 це і ви отримуєте:

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

Це функція (якщо це було не начебто очевидно), яка отримує масив чисел і обробляє його значення, повертаючи значення minmod.

Мій старий бенемот від заспокоєння також включений, що є цілою програмою - як завжди.

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 це і ви отримуєте:

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

Отримує нескінченні числа, зупиняється, коли вводиться нечислове значення, представляючи значення Minmon.

R, 20 символів

R зазвичай не підходить для кодегольфа, але я використовую його для своєї роботи, тому хотів спробувати. Перш ніж спробувати, я не знав, що R готовий прийняти такий брудний синтаксис! :-) 52 символи :

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

Тоді я подивився інші відповіді, які я спробував геніальну медіанську хитрість @ xnor, що чудово!

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

Пітона, 52

Я все ще не міг не відчути, що погано мати два lambdaс. Ця функція бере список, а потім повертає одноелементний список, що містить результат.

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

Сподіваємось, це не призведе до того, що величезна кількість правопорушень призведе до переліку одноелементів.

Матлаб / Октав, 26

Це в основному лише переклад відповіді Mathematica xnor. Він працює, додаючи на один нуль менше довжини вхідного вектора. Зауважте, що додавання ще одного не буде працювати, оскільки тоді результат буде весь час 0. Спасибі Мартін Бюттнер за -4 символи цього рішення =)

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

Пітон, 72 60 байт

Це перше рішення, яке я придумав, і це досить наївне. Друга половина, в основному, є дублікатом першої половини коду, але я не знав, як її зменшити. Цікаво, чи можна це скоротити за допомогоюeval ...

Редагувати: Змінено лямбда на розуміння.

Спробуйте їх тут

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

Це тільки 4 символів більше, але все ж варто подивитися, використовуючи Sp3000 в TIP .

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)

Більш прочитана версія:

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