最短Minmod関数

24

minmod関数は馴染みの変異体である分の偏微分方程式の傾きを制限する高解像度スキームに表示され、。多数の斜面が与えられると、斜面間の相対的な兆候に注意しながら、最も平坦な斜面を選び出します。

この関数は、任意の数のパラメーターを取ります。次に、minmod（x 1、x 2、...、x n）は次のように定義されます。

  • min（x 1、x 2、...、x n）、すべてのx iが厳密に正の場合
  • max（x 1、x 2、...、x n）、すべてのx iが厳密に負の場合
  • それ以外の場合は0。

整数入力のみを考慮します。これは実装に実際には影響せず、一部の（難解な）言語ではより包括的である必要があるためです。

STDIN、ARGV、または関数引数（可変引数関数よりも便利な場合は配列を使用できます）を介してn 個の符号付き整数（n> 0の場合）を取り、結果を返すか（STDOUTに）出力するプログラムまたは関数を作成しますminmod（A、B）。

組み込みのminまたはmax関数を使用してはなりません（実際にそれを見つけることができる場合は、組み込みのminmodも使用しないでください）。また、組み込みの並べ替え関数を使用しないでください。ただし、少数固定アイテム（5未満）。

言語に符号付きの型がない場合は、符号なしの型を使用して、2の補数として解釈できます。例えばあなたの言語のみ符号なしバイトを使用している場合、あなたが使用できる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

リーダーボード

次のStack Snippetは、通常のリーダーボードと言語ごとの勝者の概要の両方を生成します。たとえあなたの選択した言語があなたが挑戦全体に勝つことを許さないとしても、なぜ2番目のリストのスポットをひったくってみませんか？

回答が表示されるようにするには、次のマークダウンテンプレートを使用して、見出しから回答を開始してください。

# Language Name, N bytes

N提出物のサイズはどこですか。スコアを改善する場合、古いスコアを打つことで見出しに残すことができます。例えば：

# Ruby, <s>104</s> <s>101</s> 96 bytes

コードスニペットを表示

code-golf  math  restricted-source 
— マーティン・エンダー
ソース
1
多分、各言語にいくつの答えがあるかについてのコラムを追加してください
— 誇りに思ってhaskeller 14
1
@proudhaskellerうーん、スニペットを全画面表示せずに、現在2つのテーブルが隣り合っているのが気に入っています。別の列を追加すると、少しぎこちなくなると思います。あなたのコメントが私のコメントよりもかなり多くの賛成票を獲得した場合、私は何ができるか見ていきます。;）
— マーティン・エンダー14
1
@Optimizerルールの以前のバージョンは、私が意図していたよりも、人々の答えの創造性により大きな害を及ぼしていると判断しました。さらに、ルールが変更される前に行われていた回答に対して賞金を授与する予定だったので、担当者の面でも害はないと思います。（はい、ルールの変更はそれほど良い考えではないことに同意しますが、この場合はそれが価値があると思いました。）
— マーティン・エンダー
1
@MartinBüttner-現在、新しい回答には創造性が見られません。それはすべてペアワイズminmodに還元することになりました。創造性は、他の多くの答えが影響を受けるxnorの答えまたはMigのアプローチにありました。
— オプティマイザー14
2
@Optimizer、新しい回答が似ている古い回答とまったく同じくらい創造的であるかどうか、または想像を絶するポートであるかどうかを常に判断できるとは限りません。
— ピーターテイラー

回答:

13

GolfScript、10 9バイト

~{0]$1=}*

次の形式でstdinからの入力を想定しています [-4 -2 -3 -2]

これは組み込みのsort関数を使用しますが、$呼び出されるたびに3つの要素の配列上にあり、許可されています。

オンラインデモ

— ピーター・テイラー
ソース
クールで、私たちの答えは1秒未満しか離れていません。つまり、私の答えはかつては最短でした。;）
— Timtech 14
1
+1、これは私のソリューションよりもはるかに短くスマートです。（Ps。誰もがそれを疑う場合、はい、この解決策は正しいです。そして、帰納法によって証明するのはかなり簡単です。ピーターのコードは、前のminmod値、次の入力値、ゼロの中央値を繰り返し計算します可能なケースは、これが実際に新しいminmod値をもたらすことを示しています。）
— イルマリカロネン14
— えーと、ええと、たくさん
24

Mathematica、19バイト

Median[#~Riffle~0]&

コードとゴルフはMartinBüttnerに感謝します。

これは、整数のリストを入力として受け取る名前のない純粋な関数です。のように呼び出す

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

または同様に変数に保存されます。

コードは、最初に入力リストの2つの要素ごとにゼロをリフリングし、その間にn-1ゼロを挿入しますnます。次に、答えを生成するには中央値が必要です。

各ケースを処理するため、これによりmin-modが得られます。

  1. すべての数値は正であり、その場合、ゼロはそれらの下にあり、中央値は最小の正の数値です。

  2. すべての数値は負です。その場合、ゼロはそれらの上にあり、中央値は最小の負の数値です。

  3. 正数と負数の両方があるため、中央の要素はゼロです。

Mathematicaが線形時間選択アルゴリズムを使用して中央値を実装する場合、これもO（n）です。

— xnor
ソース
11

Haskell、62 61 39 38 37バイト

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

@Zgarbのanswer *から借用した比較マジック、つまりを使用しx*x<=x*yます。

x*x<=x*yxとyが同じ符号で、yの絶対値が大きい場合にのみtrue です。そのノートxであります0いつそれが常に真でことに。

xがに含まれる場合は結果であると判断しs、すべての場合は絶対値が同じyでs xあり、y絶対値が小さいと判断します。sこの定義を満たす値がない場合0は、結果になります。

f次にs、これを満たす要素を検索することで機能し0、デフォルトとして使用します。

*彼は私がそれを使用している理由でそれを使用しなかったが、彼は実際にそれを実際に取り除いた

— 誇り高いハスケラー
ソース
Haskellがこのゴルフ可能な（そして皮肉にも、まだ読みやすい）ことはまれです。大好きです。
— イサイアメドウズ14
10

JavaScript（ES6）、39バイト

a=>a.reduce((p,c)=>p*c>0?p*p>c*c?c:p:0)
— マイケル・M
ソース
1
これが大好き。ES6の素晴らしい使用法。
— Qix 14
6

Python 2、53

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

その考え方はreduce、2入力のmin-modファインダーをn-input ファインダーに変えることです。私はそれを使用する他の答えとは別にそれを思いつきました。Python 2のみがサポートされますreduce。

2入力ソリューションは、単純に2つの数値とゼロの中央値を見つけます。私を見て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()し、printPythonの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])
— xnor
ソース
うーん、その間、その副作用に気づきましたが、今それを修正するには遅すぎるように感じます。Medianただし、Mathematicaには組み込み機能があります。
— マーティンエンダー14
後者のアプローチも有効になりました。
— マーティンエンダー14
6

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

ここでは3つのボードが使用されています。

|（ボードAb（Marbelous内のすべての算術符号なしであるように、渡された大理石またはゼロマイナス渡さ大理石を返すことのいずれかによって）可読バージョンでは）大理石の絶対値をとります。

M（ボードMinabs可読バージョンで）のいずれか左第一又は第二大理石渡される検索し出力（絶対値が小さい方）、および異なる符号付き大理石が渡された場合出ます。

Mボードはまた、STDINからの最後の文字が取得されたら、それは代わりに左方向への下向きの保持大理石を解放します。

の M基板は、次にバックに偏向される左方向に保存される値を、放出するように、任意の時点で、すべてのチェック値のminmodを記憶するためにメインボードで使用されています。

ごみ箱（\/）は、STDINに出力されるシンクロナイザーの下にのみ配置されました。

入出力はSTDIN / STDOUTを使用します。どちらも8ビット値を処理します（+ 0x30および+ 0x38を渡したい場合は、08STDIN に配置します）。

ライブラリと円筒形のボードの両方が必要です。出力を10進数として表示することをお勧めします（これにより、minmodの結果の符号なしの値が表示されることに注意してください）。

ここでテストしてください。

注：より人間に優しい入出力を行うにDpは、メインボードの最後の行（の前:M）の下に追加]]しRd、に置き換えて、下部に次を追加します。

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

これにより、出力が10進数の3桁に変更されます。同様に、これらの変更を伴う入力には、数字ごとに3桁の10進数のスペース区切りリストが必要です。

読み取り可能なバージョン：

Board Picture

— es1024
ソース
5

Haskell、83 40 39バイト

これはおそらく最短のHaskellソリューションではありません（ここで他のソリューションに勝るものはありません）が、それは始まりです。編集： 50％以上短縮されました！EDIT2： 1バイト少ない...

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(#)
— ズガルブ
ソース
\a-> (signum a,a)signum>>=(,)関数モナドインスタンスを使用するのと同じです。（「ハスケルでのゴルフのヒント」の私の投稿を参照してください）
— 誇りに思っているハスケ14
先端をありがとう、しかし今では意味がありません。:)
— ズガルブ14
@Zgarbああ大丈夫。
— オプティマイザー14
5

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は、ノード9の状態に応じて、最小、最小の否定、または0を選択します。

enter image description here

— Sp3000
ソース
TIO用のTISエミュレータを実装したので、オンラインで試してみることができます！
— プラックス
4

CJam、20バイト（または10バイト）

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

@xnorのアプローチを使用して、配列から一度に2つの数値のminmodの計算を減らします。

:z働いていれば、これは19バイトだったでしょう

短い配列でソートを使用する新しいルールを使用します。

q~{0]$1=}*

@Peterの答えとまったく同じです

前の26バイトの結果：

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

これはさらにゴルフすることができます...

入力（STDIN経由）は、次のような整数配列です。

[-4 -2 -3 -2]

出力は入力配列のminmodです

ここで試してみてください

唯一の場合:gと:z働いていた、これは4バイト短くされていると思います。

— オプティマイザ
ソース
25バイト：q~_{g}%_|:+\{z\za+_~>=}**。
— jimmy23013 14
単一のint配列では失敗します。私も試してみました:)
— オプティマイザー14
そこに26バイトのソリューションがありますが。それをありがとう:)
— オプティマイザー14
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の改善努力は失敗しました。

— ナンバーワン
ソース
私はまだ多くを学ぶ必要があります。+1。
— ロドルフォディアス14
4

J、20 12バイト

リストを引数として取る関数。Golfscript / CJam /その他から盗まれた。

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

xand のminmodは、3つのアイテムリストyの中央値（ソートして中央/:~を取る1{）です0,x,y。このminmodを隣接する要素間で取得することにより、リストを縮小します（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

古いゴミ、短いソートが許可されることに気付く前に：and 0:`<.`>.@.(*@]*0<*))/のminmodはx、0がand の積以上の場合yは0（0:）でxありy、それ以外の場合は符号の間で符号に応じてmin（<.）またはmax（>.）です。リスト全体でこれを折ります。xy

— アルゴリズムサメ
ソース
4

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
— Timtech
ソース
3
Interesting way of counting code size...
— Ypnypn
3
— Martin Ender
My code, as well as median(augment(Ans,0ΔList(Ans at only eight bytes, fails on lists of dimension one. If variance(Ans:augment(Ans,0ΔList(Ans:median(Ans is longer than yours. If only TI-BASIC supported empty lists...
— lirtosiast
You are right. It looks like that bumps my code size from 12 to 15 bytes.
— Timtech
I guess you're right. +4 bytes there.
— Timtech
3

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

This is based off of my pyth answer, which was inspired by Mig's answer.

Old answer:

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

This is a very long answer. I feel like having 2 variables is a waste...? I was right...? ish? ;p

— FryAmTheEggman
ソース
3

KDB/Q, 43 characters for function body definition

Thanks to great ideas from previous posts:

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

Enter single number using 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]

I'm sure some Q guru can come up with shorter ones.

— space889
ソース
Perhaps something like {asc[0,x,y]1}/?
— algorithmshark
3

Pyth, 25 22 20 12

uhtS[0GH)QhQ

Probably not novel, but original :P

Pre-sorting allowed

u*?Gx>GH>G0H>*GHZQhQ

Pyth

Try it online.

The idea to use reduce and ternary statements was shamelessly stolen from Mig's answer, but I have no idea if these algorithms are otherwise even similar, as I can't read ternary statements.

Explanation:

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
— FryAmTheEggman
ソース
No need of tQ. Q will also work
— Optimizer
Quite right! I also think I can remove one of the ? for a *...
— FryAmTheEggman
3

C#, 101 bytes

My first try at code golfing and in a pretty golfing hostile language. Based on reduce (Aggregate in LINQ) and very similar to the JavaScript answer by Mig. Can be run like (new System.Linq.M()).m(new[] {1, 2, 3}). Passes all test cases, but doesn't handle empty input arrays.

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);}}}
— Jacob Bundgaard
ソース
1
There's no need to handle empty input, as I didn't even define the function for that case.
— Martin Ender
3

J, 12 bytes

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

The function reduces the list (called folding (/) in J) with the expression:

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

[x,y][abs(x)>abs(y)] is y if abs(x) > abs(y) else x.

Example:

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

Try it online here.

— randomra
ソース
2

Game Maker Language, 489 bytes

About Game Maker Language

Riffles the array (zeros are appended) and returns the median (similar to my other answer)

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}
— Timtech
ソース
@MartinBüttner The first 2.5 lines perform the riffle, and the rest finds the median. The 32000 is the maximum size of the array as limited by the software.
— Timtech
@MartinBüttner Yes, within the median part, the whole list is not sorted.
— Timtech
@MartinBüttner it is sorted every iteration... so 3
— Timtech
Ohhh, I see. That code is surprisingly hard to read for such a wordy language. ^^
— Martin Ender
@MartinBüttner It's pretty good for golfing (very loose syntax) but it does not contain many standard built-in functions (it is oriented towards game design).
— Timtech
2

Java, 353 304 124 bytes

Put together the worst language for code golf with the world's worst golfer and you get... 

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 it and you get:

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

This is a function (if it wasn't pretty damn obvious) that receives an array of numbers and processes its values, returning the minmod value.

My old benemoth of a sollution is also included, which is a whole program - as always.

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 it and you get:

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

Receives infinite numbers, stops when a non-number value is entered, presenting the Minmon value.

— Rodolfo Dias
ソース
Your code seems to discard the first value, so it will give incorrect answers for e.g. 1 2 3. You also seem to be overlooking that you can write a function which processes its arguments rather than a program which reads from stdin.
— Peter Taylor
@PeterTaylor Foolishly, my first instinct is always to write a full program even if it's stated that it can be a function. About that bug, apparently I didn't tested it enough, rats. Will try to correct it now - and make a function-only version as well...
— Rodolfo Dias
2

R, 20 chars

R is usually not good for codegolf, but I use it for my work so I wanted to try. Before I tried, I didn't know that R is willing to accept such a dirty syntax! :-) 52 chars:

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

Then I looked the other answers I tried @xnor's genial median trick, which is great!

median(c(x-x,x)[-1])
— Tomas
ソース
How does your first version work? What does summary do? Are q[1] and q[6] min and max, respectively? In that case, that's not valid, because you can't use built-in min/max.
— Martin Ender
@MartinBüttner it basicly provides a vector of quantiles and a mean. 1 and 6 are 0 and 1 quantiles. I have not used built-in min/max function, as per your rules.
— Tomas
2

Python, 52

I still couldn't help feeling that it's bad to have two lambdas. This function takes in a list and then returns a one-element list containing the result.

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

Hopefully, it will not cause an enormous amount of offense to have the result in a one-element list.

— feersum
ソース
1

Matlab/Octave, 26

This is basically just a translation of the Mathematica answer by xnor. It works by appending one zeros less than the length of the input vector. Note that appending one more would not work, since then the result would be 0 all the time. Thanks to MartinBüttner for the -4 chars of this solution=)

@(x)median([x,0*x(2:end)])
— flawr
ソース
@MartinBüttner You are absolutely right. I now altered it: The program will only append one zero less than the input. This way it is ensured that we have always an odd number of elements and the median takes care fo the rest.
— flawr
or pop the last 0 from your previous solution.
— Optimizer
@MartinBüttner Thanks, of course thats way better. @ Optimizer How would you do that?
— flawr
I have no idea. I thought there must be a way to simply pop off the last element, something like @(x)median([0*x,x](2:end)) . Although it seems like that its the same bytes as now.
— Optimizer
@Optimizer I already thought I missed an important feature of Matlab=) It is too bad that the notation you suggested does not work, it would be really handy sometimes!
— flawr
1

Python, 72 60 bytes

This is the first solution I thought of, and it's quite naive. The second half is basically a duplicate of the first half of the code, but I wasn't sure how to slim it. I wonder if it can be shortened using eval...

Edit: Changed lambdas to comprehensions.

Try them here

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

This is only 4 chars longer, but still worth looking at, using Sp3000's TIP.

lambda l:eval("+m%s%s(l)*all(x%s0for x in l)"*2%tuple("ax<in>"))
— mbomb007
ソース
1

Javascript, 63

a=>a.reduce((p,c)=>p<0?c<0?Math.max(p,c):0:c>0?Math.min(p,c):0)

A more readable 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;
            }
        }
    });
}
— Afonso Matos
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.