ท้าทาย

รับรายการของจำนวนจริงที่ไม่มีข้อ จำกัด คำนวณค่ามัธยฐาน

คำนิยาม

คำนวณค่ามัธยฐานดังนี้: เรียงลำดับรายการก่อน

• ถ้าจำนวนรายการเป็นเลขคี่ค่ามัธยฐานคือค่าที่อยู่ตรงกลางของรายการที่เรียงลำดับ
• มิฉะนั้นค่ามัธยฐานคือค่าเฉลี่ยเลขคณิตของสองค่าที่อยู่ใกล้กับศูนย์กลางของรายการที่เรียง

ตัวอย่าง

[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 ไบต์

ฟังก์ชันที่ไม่มีชื่อซึ่งจะส่งคืนผลลัพธ์ -1 ไบต์ต้องขอบคุณ xnor

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

l.sort()ขั้นตอนแรกจะเห็นได้ชัดในการจัดเรียงอาร์เรย์ที่ใช้ อย่างไรก็ตามเราสามารถมีหนึ่งคำสั่งในแลมบ์ดาดังนั้นเราจึงใช้ประโยชน์จากความจริงที่ว่าฟังก์ชั่นการจัดเรียงส่งกลับNoneโดยการเพิ่มor- ตามที่Noneเป็นเท็จใน Python นี้บอกให้ประเมินและส่งกลับส่วนถัดไปของคำสั่ง

ตอนนี้เรามีรายการที่เรียงลำดับแล้วเราจำเป็นต้องค้นหาค่ากลางหรือค่ากลางสองค่า

การใช้เงื่อนไขเพื่อตรวจสอบความเท่าเทียมกันของความยาวนั้นจะละเอียดเกินไปดังนั้นเราจะได้รับดัชนีlen(l)/2และ~len(l)/2:

• อันแรกคือชั้น (ความยาว / 2)ซึ่งได้รับองค์ประกอบกลางหากความยาวเป็นคี่หรือรายการด้านซ้ายในคู่กลางถ้าความยาวเท่ากัน
• ประการที่สองคือการผกผันไบนารีของความยาวรายการประเมินเพื่อ-1 - ชั้น (ความยาว / 2) เนื่องจากการจัดทำดัชนีเชิงลบของงูใหญ่สิ่งนี้ทำเช่นเดียวกับดัชนีแรก แต่ย้อนกลับจากจุดสิ้นสุดของอาร์เรย์

หากรายการมีความยาวคี่ดัชนีเหล่านี้จะชี้ไปที่ค่าเดียวกัน หากมีความยาวเท่ากันพวกเขาจะชี้ไปที่กลางสองรายการ

ตอนนี้เรามีดัชนีสองตัวนี้เราจะพบค่าเหล่านี้ในรายการรวมพวกมันแล้วหารด้วย 2 ตำแหน่งทศนิยมต่อท้ายใน/2.ทำให้แน่ใจว่ามันเป็นส่วนทศนิยมแทนการหารจำนวนเต็ม

ผลลัพธ์จะถูกส่งกลับโดยปริยายเนื่องจากเป็นฟังก์ชันแลมบ์ดา

ลองออนไลน์!

Python3 - 31 30 ไบต์

บันทึกเป็นไบต์ด้วย @Dennis!

ฉันไม่ได้วางแผนสำหรับคำตอบในตัว แต่ฉันพบโมดูลนี้และคิดว่ามันยอดเยี่ยมเพราะฉันไม่รู้ว่ามันมีอยู่จริง

from statistics import*;median

ลองมันออนไลน์ได้ที่นี่

ที่จริงแล้ว 1 ไบต์

║

ลองออนไลน์!

เยลลี่ขนาด 9 ไบต์

L‘HịṢµ÷LS

ลองออนไลน์!

คำอธิบาย

ฉันยังคงได้รับเจลลี่ ... ฉันไม่สามารถหาบิวด์อินสำหรับค่ามัธยฐานหรือค่าเฉลี่ยของรายการ แต่มันสะดวกมากสำหรับความท้าทายนี้ที่เจลลี่อนุญาตให้ดัชนีที่ไม่ใช่จำนวนเต็มเข้าในรายการ ในกรณีนี้มันจะคืนค่าที่ใกล้เคียงที่สุดสองคู่ นั่นหมายความว่าเราสามารถทำงานกับความยาวอินพุตครึ่งหนึ่งเป็นดัชนีและรับค่าคู่เมื่อเราต้องการหาค่าเฉลี่ย

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-quantile ซึ่งเป็นค่ามัธยฐาน

ลองออนไลน์!

Pyth - 11 ไบต์

ค้นหาค่าเฉลี่ยของรายการกลางที่นำมาใช้ทั้งไปข้างหลังและไปข้างหน้า

.O@R/lQ2_BS

Test Suite

อ็อกเทฟ 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

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/ทำซ้ำสองครั้งดังนั้น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

เสียงกระเพื่อมสามัญ, 89

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

ฉันคำนวณค่าเฉลี่ยขององค์ประกอบที่ตำแหน่ง(floor middle)และ(ceiling middle)ซึ่งmiddleเป็นดัชนี zero-based สำหรับองค์ประกอบกลางของรายการที่เรียงลำดับ มันเป็นไปได้สำหรับ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))

เป็นกลุ่ม 62 ไบต์

ฉันทำสิ่งนี้ใน V โดยใช้การจัดการข้อความอย่างเดียวจนกระทั่งสิ้นสุด แต่รู้สึกผิดหวังกับการจัดการ [X] และ [X, Y] ดังนั้นนี่เป็นเวอร์ชั่นที่ง่าย พวกมันมีความยาวเท่ากัน

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

ลองออนไลน์!

Unprintables:

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

รางวัลชมเชย:

• ^O นำคุณออกจากโหมดแทรกสำหรับคำสั่งเดียว (คำสั่ง 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 เพื่อสั่งซื้อค่าข้ามรายการครึ่งหนึ่งรับหนึ่งหรือสองค่าขึ้นอยู่กับคู่ / คี่และค่าเฉลี่ย

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ฉันพบว่าเราสามารถเพิ่มทั้งอาร์เรย์ที่เรียงลำดับในสองทิศทาง จากนั้นฉันก็รู้ว่าสองขั้นตอนสามารถย้อนกลับได้นั่นคือเพิ่มสองอาร์เรย์จากนั้นทำซ้ำพวกเขาและนำ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

คำตอบก่อนหน้า

Jกับstatsaddon, 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;}

Ungolfed:

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

ลองออนไลน์

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

ไม่มีอะไรซับซ้อนเกินไปเกิดขึ้นที่นี่ อาร์เรย์ได้รับการจัดเรียงแล้วฉันหาค่าเฉลี่ยของตัวเลขสองตัวจากอาร์เรย์ มีสองกรณี:

• หากความยาวเป็นเลขคู่หมายเลขนั้นจะถูกนำมาจากด้านหน้าของแถวกลางและจำนวนที่สองจะถูกนำมาจากตำแหน่งก่อนหน้านั้นด้วยการหารจำนวนเต็ม ค่าเฉลี่ยของตัวเลขเหล่านี้คือค่ามัธยฐานของอินพุต
• หากความยาวเป็นเลขคี่sและs-1ทั้งคู่หารดัชนีขององค์ประกอบกลาง ตัวเลขจะถูกเพิ่มเข้าไปในตัวมันเองและผลลัพธ์จะถูกหารด้วยสองทำให้ได้ค่าเดิม

ลองใช้ออนไลน์

SmileBASIC ขนาด 45 ไบต์

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

รับค่าเฉลี่ยขององค์ประกอบที่พื้น (ความยาว / 2) และชั้น (ความยาว / 2-0.5) ง่ายมาก แต่ฉันสามารถบันทึก 1 ไบต์โดยการย้ายสิ่งต่าง ๆ รอบ ๆ :

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

Huskขนาด 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~+→←ตั้งแต่foldl1ความต้องการฟังก์ชั่นของชนิดเป็นอาร์กิวเมนต์แรกบังคับให้ฉันใช้a -> a -> ae}

R โดยไม่ต้องใช้medianบิวด์อินขนาด 51 ไบต์

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

ลองออนไลน์!

GolfScript , 27 25 20 17 ไบต์

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

รับอินพุตเป็นอาร์เรย์ของจำนวนเต็มบน stdin ส่งออกเป็นเศษส่วนที่ไม่ได้ลดลง ลองออนไลน์!

คำอธิบาย

$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การส่งออกจะเป็นสิ่งที่ชอบ