チャレンジ

空でない実数のリストが与えられたら、その中央値を計算します。

定義

中央値は次のように計算されます：最初にリストをソートし、

• エントリの数が奇数の場合、中央値はソートされたリストの中央の値です。
• それ以外の場合、中央値は、ソートされたリストの中心に最も近い2つの値の算術平均です。

例

[1,2,3,4,5,6,7,8,9] -> 5
[1,4,3,2] -> 2.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5

Python 2、48バイト

結果を返す名前のない関数。xnorのおかげで-1バイト。

lambda l:l.sort()or(l[len(l)/2]+l[~len(l)/2])/2.

最初のステップは、明らかにを使用して配列をソートすることl.sort()です。ただし、ラムダに含めることができるステートメントは1つだけなので、sort関数が-をNone追加することで戻るという事実を利用します。orNone

ソートされたリストができたので、真ん中または真ん中の2つの値を見つける必要があります。

長さのパリティがあまりにも冗長になりますチェックするために、条件を使用して、その代わりに我々は、インデックスを取得するlen(l)/2と~len(l)/2：

• 最初はfloor（length / 2）で、長さが奇数の場合は中央の要素を取得し、長さが偶数の場合は中央のペアの左の項目を取得します。
• 2番目はリストの長さのバイナリ反転で、-1-floor（length / 2）に評価されます。Pythonのネガティブインデックスにより、これは基本的に最初のインデックスと同じですが、配列の末尾から逆方向になります。

リストの長さが奇数の場合、これらのインデックスは同じ値を指します。長さが偶数の場合、中央の2つのアイテムを指します。

これらの2つのインデックスができたので、リストでこれらの値を見つけ、それらを合計し、2で/2.除算します。

これはラムダ関数であるため、結果は暗黙的に返されます。

オンラインでお試しください！

python3 - 31の 30バイト

@Dennisのおかげで1バイト節約できました！

私は組み込みの答えを計画していませんでしたが、このモジュールを見つけて、本当にクールだと思いました。

from statistics import*;median

こちらからオンラインでお試しください。

実際には、1バイト

║

オンラインでお試しください！

ゼリー、9バイト

L‘HịṢµ÷LS

オンラインでお試しください！

説明

私はまだJellyのコツを取得しています...リストの中央値または平均値の組み込みを見つけることができませんでしたが、Jellyがリストに非整数インデックスを許可することはこの課題にとって非常に便利です。この場合、2つの最も近い値のペアを返します。つまり、入力長の半分をインデックスとして使用し、平均化する必要があるときに値のペアを取得できます。

L          Get the length of the input.
 ‘         Increment it.
  H        Halve it. This gives us the index of the median for an odd-length list
           (Jelly uses 1-based indexing), and a half-integer between the two indices
           we need to average for even-length lists.
   ịṢ      Use this as an index into the sorted input. As explained above this will
           either give us the median (in case of an odd-length list) or a pair of
           values we'll now need to average.
     µ     Starts a monadic chain which is then applied to this median or pair...
      ÷L     Divide by the length. L treats atomic values like singleton lists.
        S    Sum. This also treats atomic values like singleton lists. Hence this
             monadic chain leaves a single value unchanged but will return the
             mean of a pair.

Brain-Flak、914 + 1 = 915バイト

([]){({}[()]<(([])<{({}[()]<([([({}<(({})<>)<>>)<><({}<>)>]{}<(())>)](<>)){({}())<>}{}({}<><{}{}>){{}<>(<({}<({}<>)<>>)<>({}<>)>)}{}({}<>)<>>)}{}<>{}>[()]){({}[()]<({}<>)<>>)}{}<>>)}{}([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>){((<{}{}([[]]()){({}()()<{}>)}{}(({}){}<([]){{}{}([])}{}>)>))}{}{(<{}([[]]()()){({}()()<{}>)}{}({}{}<([]){{}{}([])}{}>)>)}{}([(({}<((((((()()()){}){}){}()){})[()()()])>)<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({}<>)<{(<{}([{}])>)}{}{(({})<((()()()()()){})>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})({}<({}<>)<>>((((()()()){}){}){}){})((()()()()()){})<>({}<>)(()()){({}[()]<([([({})](<()>))](<>())){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({})<>)<>{(<{}([{}])>)}{}({}<>)<>({}<><({}<>)>)>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)<>(({}{}[(())])){{}{}(((<{}>)))}{}{}{(<{}<>([{}])><>)}{}<>}{}>){(<{}(((((()()()()())){}{})){}{})>)}{}

-A実行するにはフラグが必要です。

オンラインでお試しください！

説明

このアルゴリズムのバックボーンは、少し前に書いたバブルソートです。

([]){({}[()]<(([])<{({}[()]<([([({}<(({})<>)<>>)<><({}<>)>]{}<(())>)](<>)){({}())<>}{}({}<><{}{}>){{}<>(<({}<({}<>)<>>)<>({}<>)>)}{}({}<>)<>>)}{}<>{}>[()]){({}[()]<({}<>)<>>)}{}<>>)}{}

これがどのように機能するか覚えていないので、私に尋ねないでください。しかし、私はそれがスタックをソートし、ネガでも動作することを知っています

すべてがソートされた後、次のチャンクで中央値の2倍を見つけます

([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>)  #Stack height modulo 2
{((<{}{}          #If odd
 ([[]]())         #Push negative stack height +1
 {                #Until zero 
  ({}()()<{}>)    #add 2 to the stack height and pop one
 }{}              #Get rid of garbage
 (({}){}<         #Pickup and double the top value
 ([]){{}{}([])}{} #Remove everything on the stack
 >)               #Put it back down
>))}{}            #End if
{(<{}                     #If even
  ([[]]()())              #Push -sh + 2
  {({}()()<{}>)}{}        #Remove one value for every 2 in that value
  ({}{}<([]){{}{}([])}{}>)#Add the top two and remove everything under them
>)}{}                     #End if

あとは、ASCIIに変換するだけです。

([(({}<((((((()()()){}){}){}()){})[()()()])>)<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({}<>)<
{(<{}([{}])>)}{}  #Absolute value (put "/2" beneath everything)

{                 #Until the residue is zero 
(({})<            #|Convert to base 10
((()()()()()){})  #|
>)                #|...
({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})
({}<({}<>)<>>((((()()()){}){}){}){})((()()()()()){})<>({}<>)
                  #|
(()()){({}[()]<([([({})](<()>))](<>())){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({})<>)<>{(<{}([{}])>)}{}({}<>)<>({}<><({}<>)>)>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)<>(({}{}[(())])){{}{}(((<{}>)))}{}{}{(<{}<>([{}])><>)}{}<>
}{}               #|
>)
{(<{}(((((()()()()())){}{})){}{})>)}{}  #If it was negative put a minus sign

R、6バイト

median

統計プログラミング言語であるRにこの組み込み機能があることは驚くことではありません。

MATL、4バイト

.5Xq

これは、中央値である0.5分位数を見つけます。

オンラインでお試しください！

Pyth-11バイト

前後両方の中間のアイテムの平均を求めます。

.O@R/lQ2_BS

テストスイート。

オクターブ、38バイト

@(x)mean(([1;1]*sort(x))(end/2+[0 1]))

これは、匿名関数を定義します。入力は行ベクトルです。

オンラインでお試しください！

説明

            sort(x)                 % Sort input x, of length k
      [1;1]*                        % Matrix-multiply by column vector of two ones
                                    % This vertically concatenates the sort(x) with 
                                    % itself. In column-major order, this effectively 
                                    % repeats each entry of sort(x)
     (             )(end/2+[0 1])   % Select the entry at position end/2 and the next.
                                    % Entries are indexed in column-major order. Since
                                    % the array has 2*k elements, this picks the k-th 
                                    % and (k+1)-th. Because entries were repeated, for
                                    % odd k this takes the original (k+1)/2-th entry
                                    % (1-based indexing) twice. For even k this takes
                                    % the original (k/2)-th and (k/2+1)-th entries
mean(                            )  % Mean of the two selected entries

JavaScript、57 52バイト

v=>(v.sort((a,b)=>a-b)[(x=v.length)>>1]+v[--x>>1])/2

配列を数値順に並べ替えます。配列の長さが偶数の場合、2つの中央の数字を見つけて平均します。配列が奇数の場合、中央の数値を2回見つけて2で除算します。

Matlab / Octave、6バイト

退屈なビルトイン：

median

オンラインでお試しください！

Mathematica、6バイト

Median

Mthmtcaを見つけたらすぐに、解決策を投稿します。

Perl 6、31バイト

*.sort[{($/=$_/2),$/-.5}].sum/2

それを試してみてください

拡張：

*\     # WhateverCode lambda ( this is the parameter )

.sort\ # sort it

[{     # index into the sorted list using a code ref to calculate the positions

  (
    $/ = $_ / 2 # the count of elements divided by 2 stored in ｢$/｣
  ),            # that was the first index

  $/ - .5       # subtract 1/2 to get the second index

                # indexing operations round down to nearest Int
                # so both are effectively the same index if given
                # an odd length array

}]\

.sum / 2        # get the average of the two values

APL（Dyalog Unicode）、14バイト

≢⊃2+/2/⊂∘⍋⌷÷∘2

オンラインでお試しください！

これは電車です。元のdfnは{(2+/2/⍵[⍋⍵])[≢⍵]÷2}です。

列車は次のように構成されています

┌─┼───┐
≢ ⊃ ┌─┼───┐
    2 / ┌─┼───┐
    ┌─┘ 2 / ┌─┼─┐
    +       ∘ ⌷ ∘
           ┌┴┐ ┌┴┐
           ⊂ ⍋ ÷ 2

⊢ は正しい引数を示します。

⌷ インデックス

• ⊂∘⍋ソートされた⊢結果にインデックス付けされたインデックス⊢

• ÷∘2⊢2で割った値

2/そう、これを2回複製1 5 7 8なりました1 1 5 5 7 7 8 8

2+/ ペアワイズ和を取る、これは (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ このピックから

• ≢ の長さと等しいインデックスを持つ要素 ⊢

以前のソリューション

{.5×+/(⍵[⍋⍵])[(⌈,⌊).5×1+≢⍵]}
{+/(2/⍵[⍋⍵]÷2)[0 1+≢⍵]}
{+/¯2↑(1-≢⍵)↓2/⍵[⍋⍵]÷2}
{(2+/2/⍵[⍋⍵])[≢⍵]÷2}
{(≢⍵)⊃2+/2/⍵[⍋⍵]÷2}
≢⊃2+/2/2÷⍨⊂∘⍋⌷⊢
≢⊃2+/2/⊂∘⍋⌷÷∘2

Common Lisp、89

(lambda(s &aux(m(1-(length s)))(s(sort s'<)))(/(+(nth(floor m 2)s)(nth(ceiling m 2)s))2))

Iは、位置要素の平均を計算(floor middle)し、(ceiling middle)ここで、middleソートされたリストの中央要素の0から始まるインデックスです。ことが可能であるmiddleように、整数であること1などのサイズ3の入力リストの(10 20 30)、または同様の要素、の偶数番号のリストのための分画3/2のために(10 20 30 40)。どちらの場合も、予想される中央値を計算します。

(lambda (list &aux
             (m (1-(length list)))
             (list (sort list #'<)))
  (/ (+ (nth (floor m 2) list)
        (nth (ceiling m 2) list))
     2))

Vim、62バイト

私はもともとVで最後までテキスト操作のみを使用してこれを行いましたが、[X]と[X、Y]の処理に不満を感じていたので、簡単なバージョンを紹介します。それらはほぼ同じ長さです。

c$:let m=sort(")[(len(")-1)/2:len(")/2]
=(m[0]+m[-1])/2.0

オンラインでお試しください！

印刷できないもの：

c$^O:let m=sort(^R")[(len(^R")-1)/2:len(^R")/2]
^R=(m[0]+m[-1])/2.0

名誉ある言及：

• ^O 1つのコマンド（letコマンド）の挿入モードを終了します。
• ^R" ヤンクされたテキスト（この場合はリスト）を挿入します

TI-Basic、2バイト

median(Ans

とても簡単です。

C＃、126バイト

using System.Linq;float m(float[] a){var x=a.Length;return a.OrderBy(g=>g).Skip(x/2-(x%2==0?1:0)).Take(x%2==0?2:1).Average();}

ここでは、LINQを使用して値を並べ替え、リストの半分をスキップし、偶数/奇数に応じて1つまたは2つの値を取得し、それらを平均化する非常に簡単です。

C ++ 112バイト

バイトを節約してくれた@ original.leginに感謝します。

#include<vector>
#include<algorithm>
float a(float*b,int s){std::sort(b,b+s);return(b[s/2-(s&1^1)]+b[s/2])/2;}

使用法：

    int main()
    {
        int n = 4;
        float e[4] = {1,4,3,2};
        std::cout<<a(e,n); /// Prints 2.5

        n = 9;
        float e1[9] = {1,2,3,4,5,6,7,8,9};
        std::cout<<a(e1,n); /// Prints 5

        n = 13;
        float e2[13] = {1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4};
        std::cout<<a(e2,n); /// Prints 1.5

        return 0;
    }

J、₁₆ 14バイト

2%~#{2#/:~+\:~

オンラインでお試しください！

加えて、BMOの配列の複製トリック、私たちは二つの方向でソート配列全体を追加することができることを見出しました。その後、私は2つのステップが逆転させることができることに気づいた、すなわち、二つの配列を追加し、その後それらを複製し、取るn番目の要素を。

使い方

2%~#{2#/:~+\:~
                Input: array of length n
       /:~      Sort ascending
           \:~  Sort descending
          +     Add the two element-wise
     2#         Duplicate each element
   #{           Take n-th element
2%~             Halve

以前の回答

statsアドオン付きJ、18バイト

load'stats'
median

オンラインでお試しください！

ライブラリ関数FTW。

medianの実装は次のようになります。

J、31バイト

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)

オンラインでお試しください！

使い方

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)
         (<.,>.)@(-:@<:@#)       Find center indices:
                  -:@<:@#          Compute half of given array's length - 1
          <.,>.                    Form 2-element array of its floor and ceiling
                          {/:~   Extract elements at those indices from sorted array
-:@(+/)                          Sum and half

少しのゴルフはこれを与えます：

J、28バイト

2%~[:+/(<.,>.)@(-:@<:@#){/:~

オンラインでお試しください！

J、19バイト

<.@-:@#{(/:-:@+\:)~

説明：

        (        )~   apply monadic argument twice to dyadic function 
         /:           /:~ = sort the list upwards
               \:     \:~ = sort the list downwards
           -:@+       half of sum of both lists, element-wise
<.@-:@#               floor of half of length of list
       {              get that element from the list of sums

JavaScript、273バイト

function m(l){a=(function(){i=l;o=[];while(i.length){p1=i[0];p2=0;for(a=0;a<i.length;a++)if(i[a]<p1){p1=i[a];p2=a}o.push(p1);i[p2]=i[i.length-1];i.pop()}return o})();return a.length%2==1?l[Math.round(l.length/2)-1]:(l[Math.round(l.length/2)-1]+l[Math.round(l.length/2)])/2}

Java 7、99バイト

ゴルフ：

float m(Float[]a){java.util.Arrays.sort(a);int l=a.length;return l%2>0?a[l/2]:(a[l/2-1]+a[l/2])/2;}

ゴルフをしていない：

float m(Float[] a)
{
    java.util.Arrays.sort(a);
    int l = a.length;
    return l % 2 > 0 ? a[l / 2] : (a[l / 2 - 1] + a[l / 2]) / 2;
}

オンラインで試す

パリ/ GP-37 39バイト

してみましょう値を含むrowvectorこと。

b=vecsort(a);n=#b+1;(b[n\2]+b[n-n\2])/2  \\ 39 byte              

n=1+#b=vecsort(a);(b[n\2]+b[n-n\2])/2    \\ obfuscated but only 37 byte

Pari / GPはインタラクティブなので、結果を表示するために追加のコマンドは必要ありません。

a=vector(8,r,random(999))           
n=1+#b=vecsort(a);w=(b[n\2]+b[n-n\2])/2      
print(a);print(b);print(w)       

オンラインでお試しください！

Japt、20バイト

n gV=0|½*Ul)+Ug~V)/2

オンラインでテストしてください！Japtには、この課題に対する非常に短い答えを作成するために必要な組み込み機能がまったくありません...

説明

n gV=0|½*Ul)+Ug~V)/2  // Implicit: U = input list
n                     // Sort U.
   V=0|½*Ul)          // Set variable V to floor(U.length / 2).
  g                   // Get the item at index V in U.
            +Ug~V     // Add to that the item at index -V - 1 in U.
                 )/2  // Divide by 2 to give the median.
                      // Implicit: output result of last expression

Java 8、71バイト

パリティは楽しいです！からdouble[]までのラムダDoubleです。

l->{java.util.Arrays.sort(l);int s=l.length;return(l[s/2]+l[--s/2])/2;}

ここでは複雑すぎることはありません。配列がソートされ、配列から2つの数値の平均を取得します。次の2つの場合があります。

• 長さが偶数の場合、最初の数値は配列の中央の直前から取得され、2番目の数値は整数除算によってその前の位置から取得されます。これらの数値の平均は、入力の中央値です。
• 長さが奇数で、場合sとs-1中間要素のインデックスの両方に分割します。数値はそれ自体に加算され、結果は2で除算され、元の値が得られます。

オンラインで試す

SmileBASIC、45バイト

DEF M A
L=LEN(A)/2SORT A?(A[L-.5]+A[L])/2
END

floor（length / 2）とfloor（length / 2-0.5）の要素の平均を取得しますが、非常に単純ですが、物事を移動することで1バイト節約できました。

DEF M A
SORT A    <- extra line break
L=LEN(A)/2?(A[L-.5]+A[L])/2
END

殻、10バイト

½ΣF~e→←½OD

オンラインでお試しください！

説明

$[a_1 \dots a_N]$$[a_1 \; a_1 \dots a_N \; a_N]$

½ΣF~e→←½OD  -- example input: [2,3,4,1]
         D  -- duplicate: [2,3,4,1,2,3,4,1]
        O   -- sort: [1,1,2,2,3,3,4,4]
       ½    -- halve: [[1,1,2,2],[3,3,4,4]]
  F         -- fold the following
   ~        -- | compose the arguments ..
     →      -- | | last element: 2
      ←     -- | | first element: 3
    e       -- | .. and create list: [2,3]
            -- : [2,3]
 Σ          -- sum: 5
½           -- halve: 5/2

_{残念ながら½、リストには型が[a] -> [[a]]あり、最初の引数として型の関数が必要なので、[a] -> ([a],[a])許可されF~+→←ていません。foldl1a -> a -> ae}

組み込みを使用しないRmedian、51バイト

function(x,n=sum(x|1)+1)mean(sort(x)[n/2+0:1*n%%2])

オンラインでお試しください！

GolfScript、27 25 20 17バイト

~..+$\,(>2<~+"/2"

入力を標準入力の整数の配列として受け取ります。非還元分数として出力します。オンラインでお試しください！

説明

$l$$l-1$$l$

~                  Evaluate input (converting string -> array)
 ..                Duplicate twice
   +               Concatenate two of the copies
    $              Sort the doubled array
     \,            Swap with the non-doubled array and get its length: l
       (           Decrement: l-1
        >          Array slice: all elements at index (l-1) and greater
         2<        Array slice: first two elements (originally at indices l-1 and l)
           ~       Dump array elements to stack
            +      Add
             "/2"  Push that string
                   Output all items on stack without separator

出力は次のようになり10/2ます。