Compute the Median

Question

Challenge

Given a nonempty list of real numbers, compute its median.

Definitions

The median is computed as follows: First sort the list,

• if the number of entries is odd, the median is the value in the center of the sorted list,
• otherwise the median is the arithmetic mean of the two values closest to the center of the sorted list.

Examples

[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

Answer 1

SmileBASIC, 45 bytes

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

Gets the average of the elements at floor(length/2) and floor(length/2-0.5) Very simple, but I was able to save 1 byte by moving things around:

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

Answer 2

R without using the median builtin, 51 bytes

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

Try it online!

Answer 3

GolfScript, 27 25 20 17 bytes

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

Takes input as an array of integers on stdin. Outputs as an unreduced fraction. Try it online!

Explanation

The median of the array, as BMO's Husk answer explains, is equal to the median of an array twice as long where each element is repeated twice. So we concatenate the array to itself, sort, and take the mean of the middle two elements. If the length of the original array is \$l\$, the middle two elements of the doubled array are at indices \$l-1\$ and \$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

The output will be something like 10/2.

Answer 4

Python 3, 59 bytes

f=lambda l:l.sort()or(len(l)<3)*(l[0]+l[-1])/2or f(l[1:-1])

Try it online!

This is a recursive version:

• the list is sorted
• if there are 1 or 2 elements left, we output the median since 0 and -1 are both first and last with a single or atwo element list
• if not, we remove first and last elements and call f.

Answer 5

Vyxal, 6 bytes

s∆ṁwfṁ

Try it Online!

sort the input, get the ∆ṁiddle item(s), wrap in a list, flatten and get the ṁean of that. (wf is needed to handle cases where the list is of odd length)

Or, without a trivial built-in

Vyxal, 11 bytes

L‹½₍⌈⌊$s$İṁ

Try it Online!

Explained

L‹½₍⌈⌊$s$İṁ
L‹         # Length of the input - 1 (this accounts for 0 indexing)
  ½        # halved
   ₍⌈⌊      # a list of the ceiling and floor of that number
     $s    # the input list sorted
       $İ  # indexed at the positions in the ceil,floor list
         ṁ # take the average of that

Answer 6

Racket 113 bytes

(let*((L(sort L >))(n(length L))(r list-ref))(if(odd? n)(r L(floor(/ n 2)))(/(+(r L(-(/ n 2)1))(r L(/ n 2)))2)))

Ungolfed:

(define (median L)
  (let* ((L (sort L >))
         (n (length L))
         (lr list-ref))
    (if (odd? n)
        (lr L (floor (/ n 2)))
        (/(+ (lr L (sub1(/ n 2)))
             (lr L (/ n 2)))
          2))))

Testing:

(median '(1 2 3))
(median '(1 2 3 4))

Output:

2
2 1/2

Answer 7

Clojure, 65 bytes

#(/(apply +(take 2(drop(-(count %)1)(sort(for[c % i[0 1]]c)))))2)

An other approach I tried:

#(apply +(map *(for[i(range)](get{-2 0.5 -1 1 0 0.5}(-(* i 2)(count %))0))(sort %)))

Answer 8

Haxe, 104 bytes

Not amazing, what with the function keywords and a mandatory sorting function …

function f(l,?a)return(l[(a={l[0]+=.0;l.sort(function(x,y)return x>y?1:-1);l.length;})>>1]+l[a-1>>1])/2;

With some whitespace:

function f(l, ?a)
  return (
      l[(a = {
          l[0] += .0;
          l.sort(
               function(x, y) return x > y ? 1 : -1
             );
          l.length;
        }) >> 1]
      + l[a - 1 >> 1]
    ) / 2;

I used l[0]+=.0; to let Haxe know the type of l. The alternative would be l:Array<Float> in the arguments. Then l is sorted, its length is stored in a, and then we basically do (l[a / 2] + l[(a - 1) / 2]) / 2.

Answer 9

Swift, 93 bytes

let m:([Double])->Double={{c,s in c%2==0 ?(s[c/2-1]+s[c/2])/2:s[c/2]}($0.count,$0.sorted())}

This takes about 10 seconds to compile on my machine but it works. It declares the constant m of type [Double] -> Double.

Answer 10

T-SQL, 101 67

DECLARE @ table(i real)
INSERT @ values(1),(3),(20),(4)

SELECT top 1PERCENTILE_CONT(.5)WITHIN GROUP(ORDER BY i)OVER()FROM @

Try it out

Answer 11

C#, 75 bytes

a=>{Array.Sort(a);int m=a.Length;return m%2>0?a[m/2]:(a[m/2-1]+a[m/2])/2;};

An anonymous function which computes the median.

Full program with ungolfed method and test cases:

using System;

public class Program
{
    public static void Main()
    {
        Func<double[],double> f =
        a =>
        {
            Array.Sort(a);  // built-in sort function for arrays
            int m = a.Length;   // stores the number of elements from the array
            return m % 2 > 0 ? a[m/2] : ( a[m/2-1] + a[m/2] ) / 2;
            // if the array has an odd number of elements, the central number will be returned
            // otherwise, the average of the two central elements
        };

        // test cases:
        Console.WriteLine(f(new double[]{1,2,3,4,5,6,7,8,9}));  // 5
        Console.WriteLine(f(new double[]{1,4,3,2}));    // 2.5
        Console.WriteLine(f(new double[]{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
    }
}

Answer 12

CJAM - 21

q~]$__,2/=\_,(2/=+2d/

• q~] reads input to array
• $__ sorts it and makes 2 copies
• , gets length of array
• 2/ divides that by 2 rounded down
• = finds the number at that index
• /_ puts original array at top of stack and copies it
• ,( gets length of array - 1
• 2/ divides that by 2 rounded down
• = finds the number at that index
• + adds the two array elements extracted 2d/ divides them by 2 as a double (so no rounding)

If the number of array elements N is odd, floor(N/2) = floor((N-1)/2). If N is even the two center elements are selected and the mean is found.

Longer but working alternative strategies:

q~]$__,2/)<_,@W%<&_:+\,d/
q~]$:A,2/_(A,2%$A=@A=+2d/\;
q~]$_Vf*_,2/.5t_W%.+.*:+

Answer 13

Ruby 50 48 Bytes

-2 bytes thanks to @Conor O'Brien

->(l){l.sort!;e=l.length;(l[~-e/2]+l[e/2])/2.0}

Answer 14

Racket, 95 bytes

Using the trusty old match syntax. The pattern (list _ m ... _) matches the middle of a list (that is, it omits the first and last element).

(λ(l)(let f([l(sort l <)])(match l[(list x)x][(list x y)(/(+ x y)2)][(list _ m ... _)(f m)])))

Ungolfed

(λ (l)
  (let f ([l (sort l <)])
    (match l
      [(list x) x]
      [(list x y) (/ (+ x y) 2)]
      [(list _ m ... _) (f m)])))

Answer 15

8th, 108 105 93 bytes

: m ' n:cmp a:sort a:len 2 n:/mod swap not if n:1- 2 a:slice a:open n:+ 2 n:/ else a:@ then ;

SED (Stack Effect Diagram) is a -- a n

Test

[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] m .

Output

1.50000

Ungolfed version (with comments)

\ Median
: m \ a -- a n
    ' n:cmp a:sort \ Sort array
    a:len          \ Get array length
    2 n:/mod       \ Remainder and quotient
    swap           \ Remainder on TOS
    not if         
        \ Array contains an even number of items
        \ Get arithmetic mean of the two values closest to the center of the sorted list
        n:1- 2 a:slice a:open n:+ 2 n:/
    else
        \ Array contains an odd number of items
        \ Get the central value           
        a:@        
    then ;

Answer 16

Perl 5, 58 + 2 (-ap) = 60 bytes

$_=(@F=sort{$a<=>$b}@F)%2?@F[@F/2]:@F[@F/2]/2+@F[@F/2-1]/2

Try it online!

Input is split into the @F array by the '-a' flag. @F gets sorted. Then, its length is checked to see if it is odd or even. If odd, result is the middle element. If even, result is half of the element to the left of middle plus half of the element to the right of the middle.

Answer 17

Julia 0.6.0 (9 bytes) (6 bytes)

median(a)

median

where a is an array. It's not a very exciting answer but it's cool that Julia has a built in function for the median.

edit: I didn't know I could just write median!

Answer 18

APL, 26 bytes

{3>≢⍵:(+/÷≢)⍵⋄∇1↓¯1↓⍵[⍋⍵]}

Try it online!

How?

• 3>≢⍵:(+/÷≢)⍵ - if the length of the array is less then 3, return the average
• ⋄ - otherwise
• ∇1↓¯1↓⍵[⍋⍵] - return the sorted array with the first and last elements removed.

Answer 19

GolfScript, 44 bytes

~$.,:l;~l 2%{l 2/$}{{l 2/$}2*+'/2'+}if{\;}l*

Try it online!

Explanation

~$.,:l;~l 2%{l.2/-}{{l 2/$}2*+'/2'+}if{\;}l*   |
~                                              Create array from input string
 $                                             Sort array
  .                                            Duplicate array
   ,                                           Pop and count the top array
    :l                                         Assign variable l
      ;                                        Pop
       ~                                       Convert array into individual integers
        l                                      Push variable l onto stack
          2%                                   Push 2 and perform mod
            {l 2/$}                            If block
            {l 2/                              push variable l and divide by 2
                 $}                            Copy/push value at index (push(stack[pop()]))
                   {{l 2/$}2*+'/2'+}           Else block
                    {l 2/                      Push l/2
                         $}                    Copy
                           2*                  Perform block {} twice
                             +                 Add top two of stack (result of copies)
                              '/2'+}if         Push and add '/2'. End if
                                      {\;}     New block. Swap top two elements then pop
                                          l*   Perform previous block l times

Answer 20

k, 23 bytes

Basically a slightly golfed version of q's canonical med in k.

{avg x(<x)@_.5*-1 0+#x}

Answer 21

PHP, 70 77 bytes

Not exactly optimal but works.

Requires that the values are passed over GET.

<?sort($_GET);die(($C=count($G=$_GET))&1?$G[~-$C/2]:($G[$C/2]+$G[$C/2-1])/2);

The result will be displayed in the browser and as the return code.

---

Thanks to Titus for fixing it, at the cost of 7 bytes.

Answer 22

Haskell 1.2 (Gofer), 44 bytes

f[x]=x
f[x,y]=(x+y)/2.0
f(x:y)=f.init$sort y

Try it online!

Answer 23

05AB1E, 2 bytes

Åm

Try it online or verify all test cases.

No need for an explanation, since Åm is a builtin which will:

Median. Sorts the list, then returns either the middle element or the average of the middle elements depending on the parity of the length of the list.

Answer 24

Lua, 64 63 bytes

function f(t)table.sort(t)h=#t//2return(t[h+1]+t[h+#t%2])/2 end

Try it online!

Sort table, get the position halfway through the table by integer-dividing table length by two, return average of element at half position plus one and element at half position if table length is even, else at half position plus one.

This solution is only valid in Lua 5.3 and onwards where there is integer division, // (and where integers can be squished right next to the keyword return). In Lua 5.1, the equivalent is math.floor(a/b), which would add several bytes.

Answer 25

Tcl, 100 bytes

proc M L {expr ([lindex [set S [lsort -r $L]] [set h [expr [llength $L]/2]]]+[lindex $S end-$h])/2.}

Try it online!

---

Tcl, 97 bytes

proc M L {expr ([lindex [set S [lsort $L]] [set h [expr [llength $L]/2]]]+[lindex $S end-$h])/2.}

Try it online!

Tcl, 123 bytes

proc M L {set I [lindex [set S [lsort $L]] [expr [set n [llength $L]]/2]]
expr {$n%2?$I:($I+[lindex $S [expr $n/2-1]])/2.}}

Try it online!

Tcl, 124 bytes

proc M L {set n [llength [set S [lsort $L]]]
set I [lindex $S [expr $n/2]]
expr {$n%2?$I:($I+[lindex $S [expr $n/2-1]])/2.}}

Try it online!

Tcl, 133 bytes

proc M L {proc G L\ i {lindex $L [expr $i]}
expr {[set n [llength [set S [lsort $L]]]]%2?[G $S $n/2]:([G $S $n/2]+[G $S $n/2-1])/2.}}

Try it online!

Tcl, 135 bytes

proc M L {expr {[set n [llength [set S [lsort $L]]]]%2?[lindex $S [expr $n/2]]:([lindex $S [expr $n/2]]+[lindex $S [expr $n/2-1]])/2.}}

Try it online!

Still very ungolfed, my first minimum viable product!

Answer 26

Arn, 13 12 bytes

Version: 1.1.5

Iõå)n├┼U■¨Mõ

Explained

Unpacked: z&:}+\$.:<:_&:-

z&               Zip array with itself, bind to the following
  :_             Flatten
    :<           Sort ascending
      $.         Split in half
        :}+\     Fold with `:}+`.
            &:-  Bind the half symbol to the expression

How :}+\ works: Takes the last element of the first array and adds to the second array, which is casted to the first element of that array automatically (finally, that feature actually is useful!).

Where a symbol needs to take a value but none is provided, _ is inserted, the implied variable. Ungolfed this looks like

( _ z _ ) & ( :}+\ ( $. ( :< ( _ :_ ) ) ) ) & ( :- _ )

Arn, the boring way, 3 bytes

med

Built in function, can't be compressed.

Answer 27

Pip, 16 bytes

SN:g(CHg+Rgoi)/2

Try It Online!

Explanation

SN:g(CHg+Rgoi)/2
   g              List of command-line arguments
SN:               Sort it (using numeric comparison) in-place
       g          Take that sorted list
        +         Add it (element-wise) with
         Rg       Its reverse
     CH           Chop into two halves (if odd length, second half is longer)
    (      oi)    Select the item at index 0 of the sublist at index 1 (o=1, i=0)
              /2  Divide it by 2

Answer 28

Thunno 2, 1 byte

ṁ

Attempt This Online!

Built-in.

Thunno 2, 11 bytes

l⁻½çṃN$Ṡsim

Attempt This Online!

Non built-in.

Explanation

l⁻½çṃN$Ṡsim  # Implicit input
l⁻           # Length of input, decremented
  ½          # Halve this number
   ç         # Parallelly apply:
    ṃ        #  Ceiling
     N       #  Floor
      $Ṡ     # Input list sorted
        si   # Index into this list
          m  # Mean of this list
             # Implicit output

Answer 29

Python 3.8 (pre-release), 49 44 bytes

-5 Inspired by Luis Mendos Octave answer.

lambda x:sum(sorted(x+x)[(n:=~len(x)):-n])/2

Try it online!

Answer 30

APL(NARS), 31 chars, 62 bytes

{2÷⍨x[⌊k]+(⌈k←2÷⍨1+≢⍵)⌷x←⍵[⍋⍵]}

test

  t←{2÷⍨x[⌊k]+(⌈k←2÷⍨1+≢⍵)⌷x←⍵[⍋⍵]}
  t 5 4 3 2 1     
3
  t 4 3 2 1     
2.5
  t 5 40 30 2 1     
5
  t 5 40 30 2     
17.5
  35÷2
17.5
   t ,80
80
  t 9 3 4 8 7 6
6.5