Функция 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

Leaderboards

Следующий фрагмент стека генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам. Поэтому, даже если ваш предпочтительный язык не позволяет вам выиграть весь вызов, почему бы не попытаться занять место во втором списке?

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# 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=}*

Предполагается ввод со стандартного ввода в формате [-4 -2 -3 -2]

При этом используется встроенная функция сортировки $, но каждый раз, когда она вызывается, она находится в массиве из 3 элементов, что разрешено.

Онлайн демо

Mathematica, 19 байт

Median[#~Riffle~0]&

Код и гольф благодаря Мартину Бюттнеру.

Это безымянная чистая функция, которая принимает в качестве входных данных список целых чисел. Вызвать его как

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

или аналогичным образом сохраняется в переменной.

Код сначала выдает ноль между каждыми двумя элементами списка ввода, который вставляет n-1нули между nэлементами. Затем требуется медиана, чтобы получить ответ.

Это дает минимальный мод, потому что он обрабатывает каждый случай:

1. Все числа положительны, и в этом случае нули находятся ниже них, а медиана является наименьшим положительным числом.

2. Все числа отрицательны, и в этом случае нули находятся над ними, а медиана является наименьшим отрицательным числом.

3. Там есть и положительное и отрицательное число, и поэтому средний элемент равен нулю.

Если Mathematica реализует свою медиану, используя алгоритм выбора линейного времени , то это также O (n).

Haskell, 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)

Python 2, 53

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

Идея состоит в том, reduceчтобы превратить min-mod finder с двумя входами в n-input. Я придумал это независимо от других ответов, которые его используют. Только 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
\/

Здесь используются три доски.

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

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

MСовет также выпускает мрамор он держит вниз вместо влево после того , как последний символ из STDIN забирается.

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 (и, конечно, здесь оно не побьет других), но это только начало. РЕДАКТИРОВАТЬ: Теперь более чем на 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), поместив этот minmod между смежными элементами.

Используется в 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 of xи yравно 0 ( 0:), если 0 больше или равно произведению xи y, в противном случае это min ( <.) или max ( >.) между 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

Python 2, 82 79 71 69 61 байт

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

Это основано на моем пит-ответе, который был вдохновлен ответом Мига .

Старый ответ:

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

Введите один номер, используя 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]

Я уверен, что некоторые Q-гуру могут придумать более короткие.

Pyth, 25 22 20 12

uhtS[0GH)QhQ

Наверное, не роман, а оригинал: P

Предварительная сортировка разрешена

u*?Gx>GH>G0H>*GHZQhQ

Pyth

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

Идея использовать 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

Попробуйте это онлайн здесь.

Game Maker Language, 489 байтов

О Game Maker Язык

Разбрасывает массив (добавляются нули) и возвращает медиану (аналогично моему другому ответу)

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

Соедините худший язык для гольф-кода с худшим в мире гольфистом, и вы получите ...

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

Разгоняй это и получаешь:

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

Разгоняй это и получаешь:

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 обычно не подходит для Codegolf, но я использую его для своей работы, поэтому я хотел попробовать. До того, как я попробовал, я не знал, что 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])

Python, 52

Я до сих пор не мог не чувствовать, что плохо иметь два lambdaс. Эта функция принимает список, а затем возвращает одноэлементный список, содержащий результат.

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

Надеемся, что это не приведет к огромному количеству оскорблений, если результат будет представлен в списке из одного элемента.

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

Это в основном просто перевод ответа Mathematica от xnor. Это работает, добавляя один ноль меньше длины входного вектора. Обратите внимание, что добавление еще одного не будет работать, так как тогда результат будет все время 0. Спасибо MartinBüttner за -4 символа этого решения =)

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

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