=={{header|F Sharp|F#}}==
Median of Medians algorithm implementation

```fsharp

let rec splitToFives list =
    match list with
        | a::b::c::d::e::tail ->
            ([a;b;c;d;e])::(splitToFives tail)
        | [] -> []
        | _ ->
                let left = 5 - List.length (list)
                let last = List.append list (List.init left (fun _ -> System.Double.PositiveInfinity) )
                in [last]

let medianFromFives =
    List.map ( fun (i:float list) ->
        List.nth (List.sort i) 2 )

let start l =
    let rec magicFives list k =
        if List.length(list) <= 10 then
            List.nth (List.sort list) (k-1)
        else
            let s = splitToFives list
            let M = medianFromFives s
            let m = magicFives M (int(System.Math.Ceiling((float(List.length M))/2.)))
            let (ll,lg) = List.partition ( fun i -> i < m ) list
            let (le,lg) = List.partition ( fun i -> i = m ) lg
            in
               if (List.length ll >= k) then
                    magicFives ll k
               else if (List.length ll + List.length le >= k ) then m
               else
                    magicFives lg (k-(List.length ll)-(List.length le))
    in
        let len = List.length l in
        if (len % 2 = 1) then
            magicFives l ((len+1)/2)
        else
            let a = magicFives l (len/2)
            let b = magicFives l ((len/2)+1)
            in (a+b)/2.


let z = [1.;5.;2.;8.;7.;2.]
start z
let z' = [1.;5.;2.;8.;7.]
start z'

Factor

The quicksort-style solution, with random pivoting. Takes the lesser of the two medians for even sequences.

USING: arrays kernel locals math math.functions random sequences ;
IN: median

: pivot ( seq -- pivot ) random ;

: split ( seq pivot -- {lt,eq,gt} )
  [ [ < ] curry partition ] keep
  [ = ] curry partition
  3array ;

DEFER: nth-in-order
:: nth-in-order-recur ( seq ind -- elt )
  seq dup pivot split
  dup [ length ] map  0 [ + ] accumulate nip
  dup [ ind <= [ 1 ] [ 0 ] if ] map sum 1 -
  [ swap nth ] curry bi@
  ind swap -
  nth-in-order ;

: nth-in-order ( seq ind -- elt )
  dup 0 =
  [ drop first ]
  [ nth-in-order-recur ]
  if ;

: median ( seq -- median )
  dup length 1 - 2 / floor nth-in-order ;

Usage:

( scratchpad ) 11 iota median .
5
( scratchpad ) 10 iota median .
4

Forth

This uses the O(n) algorithm derived from [[quicksort]].

-1 cells constant -cell
: cell-   -cell + ;

defer lessthan ( a@ b@ -- ? )   ' < is lessthan

: mid ( l r -- mid ) over - 2/ -cell and + ;

: exch ( addr1 addr2 -- ) dup @ >r over @ swap ! r> swap ! ;

: part ( l r -- l r r2 l2 )
  2dup mid @ >r ( r: pivot )
  2dup begin
    swap begin dup @  r@ lessthan while cell+ repeat
    swap begin r@ over @ lessthan while cell- repeat
    2dup <= if 2dup exch >r cell+ r> cell- then
  2dup > until  r> drop ;

0 value midpoint

: select ( l r -- )
  begin 2dup < while
    part
    dup  midpoint >= if nip nip ( l l2 ) else
    over midpoint <= if drop rot drop swap ( r2 r ) else
    2drop 2drop exit then then
  repeat 2drop ;

: median ( array len -- m )
  1- cells over +  2dup mid to midpoint
  select           midpoint @ ;

create test 4 , 2 , 1 , 3 , 5 ,

test 4 median .   \ 2
test 5 median .   \ 3

Fortran

{{works with|Fortran|90 and later}}

program Median_Test

  real            :: a(7) = (/ 4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2 /), &
                     b(6) = (/ 4.1, 7.2, 1.7, 9.3, 4.4, 3.2 /)

  print *, median(a)
  print *, median(b)

contains

  function median(a, found)
    real, dimension(:), intent(in) :: a
      ! the optional found argument can be used to check
      ! if the function returned a valid value; we need this
      ! just if we suspect our "vector" can be "empty"
    logical, optional, intent(out) :: found
    real :: median

    integer :: l
    real, dimension(size(a,1)) :: ac

    if ( size(a,1) < 1 ) then
       if ( present(found) ) found = .false.
    else
       ac = a
       ! this is not an intrinsic: peek a sort algo from
       ! Category:Sorting, fixing it to work with real if
       ! it uses integer instead.
       call sort(ac)

       l = size(a,1)
       if ( mod(l, 2) == 0 ) then
          median = (ac(l/2+1) + ac(l/2))/2.0
       else
          median = ac(l/2+1)
       end if

       if ( present(found) ) found = .true.
    end if

  end function median

end program Median_Test

If one refers to [[Quickselect_algorithm#Fortran]] which offers function FINDELEMENT(K,A,N) that returns the value of A(K) when the array of N elements has been rearranged if necessary so that A(K) is the K'th in order, then, supposing that a version is devised using the appropriate type for array A,

      K = N/2
      MEDIAN = FINDELEMENT(K + 1,A,N)
      IF (MOD(N,2).EQ.0) MEDIAN = (FINDELEMENT(K,A,N) + MEDIAN)/2

As well as returning a result, the function possibly re-arranges the elements of the array, which is not "pure" behaviour. Not to the degree of fully sorting them, merely that all elements before K are not larger than A(K) as it now is, and all elements after K are not smaller than A(K).

FreeBASIC

' FB 1.05.0 Win64

Sub quicksort(a() As Double, first As Integer, last As Integer)
  Dim As Integer length = last - first + 1
  If length < 2 Then Return
  Dim pivot As Double = a(first + length\ 2)
  Dim lft As Integer = first
  Dim rgt As Integer = last
  While lft <= rgt
    While a(lft) < pivot
      lft +=1
    Wend
    While a(rgt) > pivot
      rgt -= 1
    Wend
    If lft <= rgt Then
       Swap a(lft), a(rgt)
       lft += 1
       rgt -= 1
    End If
  Wend
  quicksort(a(), first, rgt)
  quicksort(a(), lft, last)
End Sub

Function median(a() As Double) As Double
  Dim lb As Integer = LBound(a)
  Dim ub As Integer = UBound(a)
  Dim length As Integer = ub - lb + 1
  If length = 0 Then Return 0.0/0.0 '' NaN
  If length = 1 Then Return a(ub)
  Dim mb As Integer = (lb + ub) \2
  If length Mod 2 = 1 Then Return a(mb)
  Return (a(mb) + a(mb + 1))/2.0
End Function

Dim a(0 To 9) As Double = {4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5}
quicksort(a(), 0, 9)
Print "Median for all 10 elements  : "; median(a())
' now get rid of final element
Dim b(0 To 8) As Double = {4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3}
quicksort(b(), 0, 8)
Print "Median for first 9 elements : "; median(b())
Print
Print "Press any key to quit"
Sleep

{{out}}

Median for all 10 elements  :  4.45
Median for first 9 elements :  4.4

GAP

Median := function(v)
  local n, w;
  w := SortedList(v);
  n := Length(v);
  return (w[QuoInt(n + 1, 2)] + w[QuoInt(n, 2) + 1]) / 2;
end;

a := [41, 56, 72, 17, 93, 44, 32];
b := [41, 72, 17, 93, 44, 32];

Median(a);
# 44
Median(b);
# 85/2

Go

Sort

Go built-in sort. O(n log n).

package main

import (
    "fmt"
    "sort"
)

func main() {
    fmt.Println(median([]float64{3, 1, 4, 1}))    // prints 2
    fmt.Println(median([]float64{3, 1, 4, 1, 5})) // prints 3
}

func median(a []float64) float64 {
    sort.Float64s(a)
    half := len(a) / 2
    m := a[half]
    if len(a)%2 == 0 {
        m = (m + a[half-1]) / 2
    }
    return m
}

Partial selection sort

The task description references the WP entry for "selection algorithm" which (as of this writing) gives just one pseudocode example, which is implemented here. As the WP article notes, it is O(kn). Unfortunately in the case of median, k is n/2 so the algorithm is O(n^2). Still, it gives the idea of median by selection. Note that the partial selection sort does leave the k smallest values sorted, so in the case of an even number of elements, the two elements to average are available after a single call to sel().

package main

import "fmt"

func main() {
    fmt.Println(median([]float64{3, 1, 4, 1}))    // prints 2
    fmt.Println(median([]float64{3, 1, 4, 1, 5})) // prints 3
}

func median(a []float64) float64 {
    half := len(a) / 2
    med := sel(a, half)
    if len(a)%2 == 0 {
        return (med + a[half-1]) / 2
    }
    return med
}

func sel(list []float64, k int) float64 {
    for i, minValue := range list[:k+1] {
        minIndex := i
        for j := i + 1; j < len(list); j++ {
            if list[j] < minValue {
                minIndex = j
                minValue = list[j]
                list[i], list[minIndex] = minValue, list[i]
            }
        }
    }
    return list[k]
}

Quickselect

It doesn't take too much more code to implement a quickselect with random pivoting, which should run in expected time O(n). The qsel function here permutes elements of its parameter "a" in place. It leaves the slice somewhat more ordered, but unlike the sort and partial sort examples above, does not guarantee that element k-1 is in place. For the case of an even number of elements then, median must make two separate qsel() calls.

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    fmt.Println(median([]float64{3, 1, 4, 1}))    // prints 2
    fmt.Println(median([]float64{3, 1, 4, 1, 5})) // prints 3
}

func median(list []float64) float64 {
    half := len(list) / 2
    med := qsel(list, half)
    if len(list)%2 == 0 {
        return (med + qsel(list, half-1)) / 2
    }
    return med
}

func qsel(a []float64, k int) float64 {
    for len(a) > 1 {
        px := rand.Intn(len(a))
        pv := a[px]
        last := len(a) - 1
        a[px], a[last] = a[last], pv
        px = 0
        for i, v := range a[:last] {
            if v < pv {
                a[px], a[i] = v, a[px]
                px++
            }
        }
        if px == k {
            return pv
        }
        if k < px {
            a = a[:px]
        } else {
            // swap elements.  simply assigning a[last] would be enough to
            // allow qsel to return the correct result but it would leave slice
            // "a" unusable for subsequent use.  we want this full swap so that
            // we can make two successive qsel calls in the case of median
            // of an even number of elements.
            a[px], a[last] = pv, a[px]
            a = a[px+1:]
            k -= px + 1
        }
    }
    return a[0]
}

Groovy

Solution (brute force sorting, with arithmetic averaging of dual midpoints (even sizes)):

def median(Iterable col) {
    def s = col as SortedSet
    if (s == null) return null
    if (s.empty) return 0
    def n = s.size()
    def m = n.intdiv(2)
    def l = s.collect { it }
    n%2 == 1 ? l[m] : (l[m] + l[m-1])/2
}

Test:

def a = [4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5]
def sz = a.size()

(0..sz).each {
    println """${median(a[0..<(sz-it)])} == median(${a[0..<(sz-it)]})
${median(a[it..<sz])} == median(${a[it..<sz]})"""
}

Output:

4.45 == median([4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5])
4.45 == median([4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5])
4.4 == median([4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3])
4.5 == median([2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5])
3.35 == median([4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2])
5.55 == median([-1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5])
2.3 == median([4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9])
6.6 == median([7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5])
3.35 == median([4.4, 2.3, -1.7, 7.5, 6.6, 0.0])
5.55 == median([6.6, 0.0, 1.9, 8.2, 9.3, 4.5])
4.4 == median([4.4, 2.3, -1.7, 7.5, 6.6])
4.5 == median([0.0, 1.9, 8.2, 9.3, 4.5])
3.35 == median([4.4, 2.3, -1.7, 7.5])
6.35 == median([1.9, 8.2, 9.3, 4.5])
2.3 == median([4.4, 2.3, -1.7])
8.2 == median([8.2, 9.3, 4.5])
3.35 == median([4.4, 2.3])
6.9 == median([9.3, 4.5])
4.4 == median([4.4])
4.5 == median([4.5])
0 == median([])
0 == median([])

Haskell

This uses a quick select algorithm and runs in expected O(n) time.

import Data.List (partition)

nth :: Ord t => [t] -> Int -> t
nth (x:xs) n
  | k == n = x
  | k > n = nth ys n
  | otherwise = nth zs $ n - k - 1
  where
    (ys, zs) = partition (< x) xs
    k = length ys

medianMay :: (Fractional a, Ord a) => [a] -> Maybe a
medianMay xs
  | n < 1 = Nothing
  | even n = Just ((nth xs (div n 2) + nth xs (div n 2 - 1)) / 2.0)
  | otherwise = Just (nth xs (div n 2))
  where
    n = length xs

main :: IO ()
main =
  mapM_
    (printMay . medianMay)
    [[], [7], [5, 3, 4], [5, 4, 2, 3], [3, 4, 1, -8.4, 7.2, 4, 1, 1.2]]
  where
    printMay = maybe (putStrLn "(not defined)") print

{{Out}}

(not defined)
7.0
4.0
3.5
2.1

Or {{libheader|hstats}}

 Math.Statistics.median [1,9,2,4]
3.0

HicEst

If the input has an even number of elements, median is the mean of the middle two values:

REAL :: n=10, vec(n)

vec = RAN(1)
SORT(Vector=vec, Sorted=vec) ! in-place Merge-Sort

IF( MOD(n,2) ) THEN  ! odd n
    median = vec( CEILING(n/2) )
ELSE
    median = ( vec(n/2) + vec(n/2 + 1) ) / 2
ENDIF

=={{header|Icon}} and {{header|Unicon}}== A quick and dirty solution: procedure main(args) write(median(args)) end

procedure median(A) A := sort(A) n := *A return if n % 2 = 1 then A[n/2+1] else (A[n/2]+A[n/2+1])/2.0 | 0 # 0 if empty list end

Sample outputs:

```txt
->am 3 1 4 1 5 9 7 6 3
4
->am 3 1 4 1 5 9 7 6
4.5
->

J

The verb median is available from the stats/base addon and returns the mean of the two middle values for an even number of elements:

  require 'stats/base'
  median 1 9 2 4
3

The definition given in the addon script is:

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

If, for an even number of elements, both values were desired when those two values are distinct, then the following implementation would suffice:

   median=: ~.@(<. , >.)@midpt { /:~
   median 1 9 2 4
2 4

Java

{{works with|Java|1.5+}}

Sorting:

// Note: this function modifies the input list
public static double median(List<Double> list) {
    Collections.sort(list);
    return (list.get(list.size() / 2) + list.get((list.size() - 1) / 2)) / 2;
}

{{works with|Java|1.5+}}

Using priority queue (which sorts under the hood):

public static double median2(List<Double> list) {
    PriorityQueue<Double> pq = new PriorityQueue<Double>(list);
    int n = list.size();
    for (int i = 0; i < (n - 1) / 2; i++)
        pq.poll(); // discard first half
    if (n % 2 != 0) // odd length
        return pq.poll();
    else
        return (pq.poll() + pq.poll()) / 2.0;
}

JavaScript

ES5

function median(ary) {
    if (ary.length == 0)
        return null;
    ary.sort(function (a,b){return a - b})
    var mid = Math.floor(ary.length / 2);
    if ((ary.length % 2) == 1)  // length is odd
        return ary[mid];
    else
        return (ary[mid - 1] + ary[mid]) / 2;
}

median([]);   // null
median([5,3,4]);  // 4
median([5,4,2,3]);  // 3.5
median([3,4,1,-8.4,7.2,4,1,1.2]);  // 2.1

ES6

Using a quick select algorithm {{Trans|Haskell}}

(() => {
    'use strict';

    // median :: [Num] -> Num
    function median(xs) {
        // nth :: [Num] -> Int -> Maybe Num
        let nth = (xxs, n) => {
                if (xxs.length > 0) {
                    let [x, xs] = uncons(xxs),
                        [ys, zs] = partition(y => y < x, xs),
                        k = ys.length;

                    return k === n ? x : (
                        k > n ? nth(ys, n) : nth(zs, n - k - 1)
                    );
                } else return undefined;
            },
            n = xs.length;

        return even(n) ? (
            (nth(xs, div(n, 2)) + nth(xs, div(n, 2) - 1)) / 2
        ) : nth(xs, div(n, 2));
    }



    // GENERIC

    // partition :: (a -> Bool) -> [a] -> ([a], [a])
    let partition = (p, xs) =>
        xs.reduce((a, x) =>
            p(x) ? [a[0].concat(x), a[1]] : [a[0], a[1].concat(x)], [
                [],
                []
            ]),

        // uncons :: [a] -> Maybe (a, [a])
        uncons = xs => xs.length ? [xs[0], xs.slice(1)] : undefined,

        // even :: Integral a => a -> Bool
        even = n => n % 2 === 0,

        // div :: Num -> Num -> Int
        div = (x, y) => Math.floor(x / y);

    return [
        [],
        [5, 3, 4],
        [5, 4, 2, 3],
        [3, 4, 1, -8.4, 7.2, 4, 1, 1.2]
    ].map(median);
})();

{{Out}}

[
  null,
  4,
  3.5,
  2.1
]

jq

def median:
  length as $length
  | sort as $s
  | if $length == 0 then null
    else ($length / 2 | floor) as $l2
      | if ($length % 2) == 0 then
          ($s[$l2 - 1] + $s[$l2]) / 2
        else $s[$l2]
        end
  end ;

This definition can be used in a jq program, but to illustrate how it can be used as a command line filter, suppose the definition and the program '''median''' are in a file named median.jq, and that the file in.dat contains a sequence of arrays, such as

[4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2]
[4.1, 7.2, 1.7, 9.3, 4.4, 3.2]

Then invoking the jq program yields a stream of values:

$ jq -f median.jq in.dat
4.4
4.25

Julia

Julia has a built-in median() function

using Statistics
function median2(n)
	s = sort(n)
	len = length(n)
	if len % 2 == 0
		return (s[floor(Int, len / 2) + 1] + s[floor(Int, len / 2)]) / 2
	else
		return  s[floor(Int, len / 2) + 1]
	end
end

a = [4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2]
b = [4.1, 7.2, 1.7, 9.3, 4.4, 3.2]

@show a b median2(a) median(a) median2(b) median(b)

{{out}}

a = [4.1,5.6,7.2,1.7,9.3,4.4,3.2]
b = [4.1,7.2,1.7,9.3,4.4,3.2]
median2(a) = 4.4
median(a) = 4.4
median2(b) = 4.25
median(b) = 4.25

K

  med:{a:x@<x; i:(#a)%2; :[(#a)!2; a@i; {(+/x)%#x} a@i,i-1]}
  v:10*6 _draw 0
  v
5.961475 2.025856 7.262835 1.814272 2.281911 4.854716
  med[v]
3.568313
  med[1_ v]
2.281911

An alternate solution which works in the oK implementation using the same dataset v from above and shows both numbers around the median point on even length datasets would be:

med:{a:x@<x; i:_(#a)%2
$[2!#a; a@i; |a@i,i-1]}
med[v]
2.2819 4.8547

Kotlin

{{works with|Kotlin|1.0+}}

fun median(l: List<Double>) = l.sorted().let { (it[it.size / 2] + it[(it.size - 1) / 2]) / 2 }

fun main(args: Array<String>) {
    median(listOf(5.0, 3.0, 4.0)).let { println(it) }  // 4
    median(listOf(5.0, 4.0, 2.0, 3.0)).let { println(it) }  // 3.5
    median(listOf(3.0, 4.0, 1.0, -8.4, 7.2, 4.0, 1.0, 1.2)).let { println(it) }  // 2.1
}

Lasso

can't use Lasso's built in median method because that takes 3 values, not an array of indeterminate length

Lasso's built in function is "median( value_1, value_2, value_3 )"

define median_ext(a::array) => {
	#a->sort

	if(#a->size % 2) => {
		// odd numbered element array, pick middle
		return #a->get(#a->size / 2 + 1)

	else
		// even number elements in array
		return (#a->get(#a->size / 2) + #a->get(#a->size / 2 + 1)) / 2.0
	}
}

median_ext(array(3,2,7,6)) // 4.5
median_ext(array(3,2,9,7,6)) // 6

Liberty BASIC

    dim a( 100), b( 100)    '   assumes we will not have vectors of more terms...

    a$ ="4.1,5.6,7.2,1.7,9.3,4.4,3.2"
    print "Median is "; median( a$)        '   4.4   7 terms
    print
    a$ ="4.1,7.2,1.7,9.3,4.4,3.2"
    print "Median  is "; median( a$)        '   4.25  6 terms
    print
    a$ ="4.1,4,1.2,6.235,7868.33"   '   4.1
    print "Median of "; a$; " is "; median( a$)
    print
    a$ ="1,5,3,2,4"             '   3
    print "Median of "; a$; " is "; median( a$)
    print
    a$ ="1,5,3,6,4,2"          '   3.5
    print "Median of "; a$; " is "; median( a$)
    print
    a$ ="4.4,2.3,-1.7,7.5,6.6,0.0,1.9,8.2,9.3,4.5" '   4.45
    print "Median of "; a$; " is "; median( a$)

    end

    function median( a$)
        i =1
        do
            v$     =word$( a$, i, ",")
            if v$ ="" then exit do
            print v$,
            a( i)  =val( v$)
            i      =i +1
        loop until 0
        print

        sort a(), 1, i -1

        for j =1 to i -1
            print a( j),
        next j
        print

        middle    =( i -1) /2
        intmiddle =int( middle)
        if middle <>intmiddle then median= a( 1 +intmiddle) else median =( a( intmiddle) +a( intmiddle +1)) /2
    end function

4.1 5.6 7.2 1.7 9.3 4.4 3.2
Median is 4.4

4.1 7.2 1.7 9.3 4.4 3.2
Median is 4.25

4.1 4 1.2 6.235 7868.33
Median of 4.1,4,1.2,6.235,7868.33 is 4.1

1 5 3 2 4
Median of 1,5,3,2,4 is 3

1 5 3 6 4 2
Median of 1,5,3,6,4,2 is 3.5

4.4 2.3 -1.7 7.5 6.6 0.0 1.9 8.2 9.3 4.5
Median of 4.4,2.3,-1.7,7.5,6.6,0.0,1.9,8.2,9.3,4.5 is 4.45

Lingo

on median (numlist)
    -- numlist = numlist.duplicate() -- if input list should not be altered
    numlist.sort()
    if numlist.count mod 2 then
        return numlist[numlist.count/2+1]
    else
        return (numlist[numlist.count/2]+numlist[numlist.count/2+1])/2.0
    end if
end

LiveCode

LC has median as a built-in function

put median("4.1,5.6,7.2,1.7,9.3,4.4,3.2") & "," & median("4.1,7.2,1.7,9.3,4.4,3.2")
returns 4.4, 4.25

To make our own, we need own own floor function first

function floor n
    if n < 0 then
        return (trunc(n) - 1)
    else
        return trunc(n)
    end if
end floor

function median2 x
    local n, m
    set itemdelimiter to comma
    sort items of x ascending numeric
    put the number of items of x into n
    put floor(n / 2) into m
    if n mod 2 is 0 then
        return (item m of x + item (m + 1) of x) / 2
    else
        return item (m + 1) of x
    end if
end median2

returns the same as the built-in median, viz.
put median2("4.1,5.6,7.2,1.7,9.3,4.4,3.2") & "," & median2("4.1,7.2,1.7,9.3,4.4,3.2")
4.4,4.25

LSL

integer MAX_ELEMENTS = 10;
integer MAX_VALUE = 100;
default {
    state_entry() {
        list lst = [];
        integer x = 0;
        for(x=0 ; x<MAX_ELEMENTS ; x++) {
            lst += llFrand(MAX_VALUE);
        }
        llOwnerSay("lst=["+llList2CSV(lst)+"]");
        llOwnerSay("Geometric Mean: "+(string)llListStatistics(LIST_STAT_GEOMETRIC_MEAN, lst));
        llOwnerSay("           Max: "+(string)llListStatistics(LIST_STAT_MAX, lst));
        llOwnerSay("          Mean: "+(string)llListStatistics(LIST_STAT_MEAN, lst));
        llOwnerSay("        Median: "+(string)llListStatistics(LIST_STAT_MEDIAN, lst));
        llOwnerSay("           Min: "+(string)llListStatistics(LIST_STAT_MIN, lst));
        llOwnerSay("     Num Count: "+(string)llListStatistics(LIST_STAT_NUM_COUNT, lst));
        llOwnerSay("         Range: "+(string)llListStatistics(LIST_STAT_RANGE, lst));
        llOwnerSay("       Std Dev: "+(string)llListStatistics(LIST_STAT_STD_DEV, lst));
        llOwnerSay("           Sum: "+(string)llListStatistics(LIST_STAT_SUM, lst));
        llOwnerSay("   Sum Squares: "+(string)llListStatistics(LIST_STAT_SUM_SQUARES, lst));
    }
}

Output:

lst=[23.815209, 85.890704, 10.811144, 31.522696, 54.619416, 12.211729, 42.964463, 87.367889, 7.106129, 18.711078]
Geometric Mean:    27.325070
           Max:    87.367889
          Mean:    37.502046
        Median:    27.668953
           Min:     7.106129
     Num Count:    10.000000
         Range:    80.261761
       Std Dev:    29.819840
           Sum:   375.020458
   Sum Squares: 22067.040048

Lua

function median (numlist)
    if type(numlist) ~= 'table' then return numlist end
    table.sort(numlist)
    if #numlist %2 == 0 then return (numlist[#numlist/2] + numlist[#numlist/2+1]) / 2 end
    return numlist[math.ceil(#numlist/2)]
end

print(median({4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2}))
print(median({4.1, 7.2, 1.7, 9.3, 4.4, 3.2}))

Maple

Builtin

This works for numeric lists or arrays, and is designed for large data sets.

> Statistics:-Median( [ 1, 5, 3, 2, 4 ] );
                                   3.

> Statistics:-Median( [ 1, 5, 3, 6, 2, 4 ] );
                            3.50000000000000

Using a sort

This solution can handle exact numeric inputs. Instead of inputting a container of some kind, it simply finds the median of its arguments.

median1 := proc()
        local L := sort( [ args ] );
        ( L[ iquo( 1 + nargs, 2 ) ] + L[ 1 + iquo( nargs, 2 ) ] ) / 2
end proc:

For example:

> median1( 1, 5, 3, 2, 4 ); # 3
                                   3

> median1( 1, 5, 3, 6, 4, 2 ); # 7/2
                                  7/2

=={{header|Mathematica}} / {{header|Wolfram Language}}== Built-in function:

Median[{1, 5, 3, 2, 4}]
Median[{1, 5, 3, 6, 4, 2}]

{{out}}

3
7/2

Custom function:

mymedian[x_List]:=Module[{t=Sort[x],L=Length[x]},
 If[Mod[L,2]==0,
  (t[[L/2]]+t[[L/2+1]])/2
 ,
  t[[(L+1)/2]]
 ]
]

Example of custom function:

mymedian[{1, 5, 3, 2, 4}]
mymedian[{1, 5, 3, 6, 4, 2}]

{{out}}

3
7/2

MATLAB

If the input has an even number of elements, function returns the mean of the middle two values:

function medianValue = findmedian(setOfValues)
   medianValue = median(setOfValues);
end

Maxima

/* built-in */
median([41, 56, 72, 17, 93, 44, 32]);  /* 44 */
median([41, 72, 17, 93, 44, 32]);      /* 85/2 */

MUMPS

MEDIAN(X)
 ;X is assumed to be a list of numbers separated by "^"
 ;I is a loop index
 ;L is the length of X
 ;Y is a new array
 QUIT:'$DATA(X) "No data"
 QUIT:X="" "Empty Set"
 NEW I,ODD,L,Y
 SET L=$LENGTH(X,"^"),ODD=L#2,I=1
 ;The values in the vector are used as indices for a new array Y, which sorts them
 FOR  QUIT:I>L  SET Y($PIECE(X,"^",I))=1,I=I+1
 ;Go to the median index, or the lesser of the middle if there is an even number of elements
 SET J="" FOR I=1:1:$SELECT(ODD:L\2+1,'ODD:L/2) SET J=$ORDER(Y(J))
 QUIT $SELECT(ODD:J,'ODD:(J+$ORDER(Y(J)))/2)

USER>W $$MEDIAN^ROSETTA("-1.3^2.43^3.14^17^2E-3")
3.14
USER>W $$MEDIAN^ROSETTA("-1.3^2.43^3.14^17^2E-3^4")
3.57
USER>W $$MEDIAN^ROSETTA("")
Empty Set
USER>W $$MEDIAN^ROSETTA
No data

NetRexx

{{trans|Java}}

/* NetRexx */
options replace format comments java crossref symbols nobinary

class RAvgMedian00 public

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method median(lvector = java.util.List) public static returns Rexx
    cvector = ArrayList(lvector) -- make a copy of input to ensure it's contents are preserved
    Collections.sort(cvector, RAvgMedian00.RexxComparator())
    kVal = ((Rexx cvector.get(cvector.size() % 2)) + (Rexx cvector.get((cvector.size() - 1) % 2))) / 2
    return kVal

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method median(rvector = Rexx[]) public static returns Rexx
    return median(ArrayList(Arrays.asList(rvector)))

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method show_median(lvector = java.util.List) public static returns Rexx
    mVal = median(lvector)
    say 'Meadian:' mVal.format(10, 6, 3, 6, 's')', Vector:' (Rexx lvector).space(0)
    return mVal

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method show_median(rvector = Rexx[]) public static returns Rexx
    return show_median(ArrayList(Arrays.asList(rvector)))

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method run_samples() public static
    show_median([Rexx 10.0])                                                   -- 10.0
    show_median([Rexx 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0])      -- 5.5
    show_median([Rexx 9, 8, 7, 6, 5, 4, 3, 2, 1])                              -- 5.0
    show_median([Rexx 1.0, 9, 2.0, 4.0])                                       -- 3.0
    show_median([Rexx 3.0, 1, 4, 1.0, 5.0, 9, 7.0, 6.0])                       -- 4.5
    show_median([Rexx 3, 4, 1, -8.4, 7.2, 4, 1, 1.2])                          -- 2.1
    show_median([Rexx -1.2345678e+99, 2.3e+700])                               -- 1.15e+700
    show_median([Rexx 4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2])                      -- 4.4
    show_median([Rexx 4.1, 7.2, 1.7, 9.3, 4.4, 3.2])                           -- 4.25
    show_median([Rexx 28.207, 74.916, 51.695, 72.486, 51.118, 3.241, 73.807])  -- 51.695
    show_median([Rexx 27.984, 89.172, 0.250, 66.316, 41.805, 60.043])          -- 50.924
    show_median([Rexx 5.1, 2.6, 6.2, 8.8, 4.6, 4.1])                           -- 4.85
    show_median([Rexx 5.1, 2.6, 8.8, 4.6, 4.1])                                -- 4.6
    show_median([Rexx 4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5])      -- 4.45
    show_median([Rexx 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0.11])        -- 3.0
    show_median([Rexx 10, 20, 30, 40, 50, -100, 4.7, -11e+2])                  -- 15.0
    show_median([Rexx 9.3, -2.0, 4.0, 7.3, 8.1, 4.1, -6.3, 4.2, -1.0, -8.4])   -- 4.05
    show_median([Rexx 8.3, -3.6, 5.7, 2.3, 9.3, 5.4, -2.3, 6.3, 9.9])          -- 5.7
    return

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method main(args = String[]) public static
    run_samples()
    return

--
### =======================================================================

class RAvgMedian00.RexxComparator implements Comparator

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method compare(i1=Object, i2=Object) public returns int
    i = Rexx i1
    j = Rexx i2

    if i < j then return -1
    if i > j then return +1
    else return 0

'''Output:'''

Meadian:         10.000000     , Vector: [10.0]
Meadian:          5.500000     , Vector: [10.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0,1.0]
Meadian:          5.000000     , Vector: [9,8,7,6,5,4,3,2,1]
Meadian:          3.000000     , Vector: [1.0,9,2.0,4.0]
Meadian:          4.500000     , Vector: [3.0,1,4,1.0,5.0,9,7.0,6.0]
Meadian:          2.100000     , Vector: [3,4,1,-8.4,7.2,4,1,1.2]
Meadian:          1.150000E+700, Vector: [-1.2345678E+99,2.3e+700]
Meadian:          4.400000     , Vector: [4.1,5.6,7.2,1.7,9.3,4.4,3.2]
Meadian:          4.250000     , Vector: [4.1,7.2,1.7,9.3,4.4,3.2]
Meadian:         51.695000     , Vector: [28.207,74.916,51.695,72.486,51.118,3.241,73.807]
Meadian:         50.924000     , Vector: [27.984,89.172,0.250,66.316,41.805,60.043]
Meadian:          4.850000     , Vector: [5.1,2.6,6.2,8.8,4.6,4.1]
Meadian:          4.600000     , Vector: [5.1,2.6,8.8,4.6,4.1]
Meadian:          4.450000     , Vector: [4.4,2.3,-1.7,7.5,6.6,0.0,1.9,8.2,9.3,4.5]
Meadian:          3.000000     , Vector: [10,9,8,7,6,5,4,3,2,1,0,0,0,0,0.11]
Meadian:         15.000000     , Vector: [10,20,30,40,50,-100,4.7,-1100]
Meadian:          4.050000     , Vector: [9.3,-2.0,4.0,7.3,8.1,4.1,-6.3,4.2,-1.0,-8.4]
Meadian:          5.700000     , Vector: [8.3,-3.6,5.7,2.3,9.3,5.4,-2.3,6.3,9.9]

NewLISP

; median.lsp
; oofoe 2012-01-25

(define (median lst)
  (sort lst) ; Sorts in place.
  (if (empty? lst)
      nil
    (letn ((n (length lst))
           (h (/ (- n 1) 2)))
          (if (zero? (mod n 2))
              (div (add (lst h) (lst (+ h 1))) 2)
            (lst h))
          )))


(define (test lst) (println lst " -> " (median lst)))

(test '())
(test '(5 3 4))
(test '(5 4 2 3))
(test '(3 4 1 -8.4 7.2 4 1 1.2))

(exit)

Sample output:

() -> nil
(5 3 4) -> 4
(5 4 2 3) -> 3.5
(3 4 1 -8.4 7.2 4 1 1.2) -> 2.1

Nim

{{trans|Python}}

import algorithm, strutils

proc median(xs: seq[float]): float =
  var ys = xs
  sort(ys, system.cmp[float])
  0.5 * (ys[ys.high div 2] + ys[ys.len div 2])

var a = @[4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2]
echo formatFloat(median(a), precision = 0)
a = @[4.1, 7.2, 1.7, 9.3, 4.4, 3.2]
echo formatFloat(median(a), precision = 0)

Example Output: 4.4 4.25

=={{header|Oberon-2}}== Oxford Oberon-2

MODULE Median;
IMPORT Out;
CONST
	MAXSIZE = 100;

PROCEDURE Partition(VAR a: ARRAY OF REAL; left, right: INTEGER): INTEGER;
VAR
	pValue,aux: REAL;
	store,i,pivot: INTEGER;
BEGIN
	pivot := right;
	pValue := a[pivot];
	aux := a[right];a[right] := a[pivot];a[pivot] := aux; (* a[pivot] <-> a[right] *)
	store := left;
	FOR i := left TO right -1 DO
		IF a[i] <= pValue THEN
			aux := a[store];a[store] := a[i];a[i]:=aux;
			INC(store)
		END
	END;
	aux := a[right];a[right] := a[store]; a[store] := aux;
	RETURN store
END Partition;

(* QuickSelect algorithm *)
PROCEDURE Select(a: ARRAY OF REAL; left,right,k: INTEGER;VAR r: REAL);
VAR
	pIndex, pDist : INTEGER;
BEGIN
	IF left = right THEN r := a[left]; RETURN END;
	pIndex := Partition(a,left,right);
	pDist := pIndex - left + 1;
	IF pDist = k THEN
		r := a[pIndex];RETURN
	ELSIF k < pDist THEN
		Select(a,left, pIndex - 1, k, r)
	ELSE
		Select(a,pIndex + 1, right, k - pDist, r)
	END
END Select;

PROCEDURE Median(a: ARRAY OF REAL;left,right: INTEGER): REAL;
VAR
	idx,len : INTEGER;
	r1,r2 : REAL;
BEGIN
	len := right - left + 1;
	idx := len DIV 2 + 1;
	r1 := 0.0;r2 := 0.0;
	Select(a,left,right,idx,r1);
	IF ODD(len) THEN RETURN r1 END;
	Select(a,left,right,idx - 1,r2);
	RETURN (r1 + r2) / 2;
END Median;


VAR
	ary: ARRAY MAXSIZE OF REAL;
	r: REAL;
BEGIN
	r := 0.0;
	Out.Fixed(Median(ary,0,0),4,2);Out.Ln;	(* empty *)
	ary[0] := 5;
	ary[1] := 3;
	ary[2] := 4;
	Out.Fixed(Median(ary,0,2),4,2);Out.Ln;
	ary[0] := 5;
	ary[1] := 4;
	ary[2] := 2;
	ary[3] := 3;
	Out.Fixed(Median(ary,0,3),4,2);Out.Ln;
	ary[0] := 3;
	ary[1] := 4;
	ary[2] := 1;
	ary[3] := -8.4;
	ary[4] := 7.2;
	ary[5] := 4;
	ary[6] := 1;
	ary[7] := 1.2;
	Out.Fixed(Median(ary,0,7),4,2);Out.Ln;
END Median.

Output:

0.00
4.00
3.50
2.10

Objeck

use Structure;

bundle Default {
  class Median {
    function : Main(args : String[]) ~ Nil {
      numbers := FloatVector->New([4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2]);
      DoMedian(numbers)->PrintLine();

      numbers := FloatVector->New([4.1, 7.2, 1.7, 9.3, 4.4, 3.2]);
      DoMedian(numbers)->PrintLine();
    }

    function : native : DoMedian(numbers : FloatVector) ~ Float {
      if(numbers->Size() = 0) {
        return 0.0;
      }
      else if(numbers->Size() = 1) {
        return numbers->Get(0);
      };

      numbers->Sort();

      i := numbers->Size() / 2;
      if(numbers->Size() % 2 = 0) {
        return (numbers->Get(i - 1) + numbers->Get(i)) / 2.0;
      };

      return numbers->Get(i);
    }
  }
}

OCaml

(* note: this modifies the input array *)
let median array =
  let len = Array.length array in
    Array.sort compare array;
    (array.((len-1)/2) +. array.(len/2)) /. 2.0;;

let a = [|4.1; 5.6; 7.2; 1.7; 9.3; 4.4; 3.2|];;
median a;;
let a = [|4.1; 7.2; 1.7; 9.3; 4.4; 3.2|];;
median a;;

Octave

Of course Octave has its own median function we can use to check our implementation. The Octave's median function, however, does not handle the case you pass in a void vector.

function y = median2(v)
  if (numel(v) < 1)
    y = NA;
  else
    sv = sort(v);
    l = numel(v);
    if ( mod(l, 2) == 0 )
      y = (sv(floor(l/2)+1) + sv(floor(l/2)))/2;
    else
      y = sv(floor(l/2)+1);
    endif
  endif
endfunction

a = [4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2];
b = [4.1, 7.2, 1.7, 9.3, 4.4, 3.2];

disp(median2(a))   % 4.4
disp(median(a))
disp(median2(b))   % 4.25
disp(median(b))

ooRexx

call testMedian .array~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
call testMedian .array~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11)
call testMedian .array~of(10, 20, 30, 40, 50, -100, 4.7, -11e2)
call testMedian .array~new

::routine testMedian
  use arg numbers
  say "numbers =" numbers~toString("l", ", ")
  say "median =" median(numbers)
  say

::routine median
  use arg numbers

  if numbers~isempty then return 0
  -- make a copy so the sort does not alter the
  -- original set.  This also means this will
  -- work with lists and queues as well
  numbers = numbers~makearray

  -- sort and return the middle element
  numbers~sortWith(.numbercomparator~new)
  size = numbers~items
  -- this handles the odd value too
  return numbers[size%2 + size//2]


-- a custom comparator that sorts strings as numeric values rather than
-- strings
::class numberComparator subclass comparator
::method compare
  use strict arg left, right
  -- perform the comparison on the names.  By subtracting
  -- the two and returning the sign, we give the expected
  -- results for the compares
  return (left - right)~sign

Oz

declare
  fun {Median Xs}
     Len = {Length Xs}
     Mid = Len div 2 + 1 %% 1-based index
     Sorted = {Sort Xs Value.'<'}
  in
     if {IsOdd Len} then {Nth Sorted Mid}
     else ({Nth Sorted Mid} + {Nth Sorted Mid-1}) / 2.0
     end
  end
in
  {Show {Median [4.1 5.6 7.2 1.7 9.3 4.4 3.2]}}
  {Show {Median [4.1 7.2 1.7 9.3 4.4 3.2]}}

PARI/GP

Sorting solution.

median(v)={
  vecsort(v)[#v\2]
};

Linear-time solution, mostly proof-of-concept but perhaps suitable for large lists.

BFPRT(v,k=#v\2)={
	if(#v<15, return(vecsort(v)[k]));
	my(u=List(),pivot,left=List(),right=List());
	forstep(i=1,#v-4,5,
		listput(u,BFPRT([v[i],v[i+1],v[i+2],v[i+3],v[i+4]]))
	);
	pivot=BFPRT(Vec(u));
	u=0;
	for(i=1,#v,
		if(v[i]<pivot,
			listput(left,v[i])
		,
			listput(right,v[i])
		)
	);
	if(k>#left,
		BFPRT(right, k-#left)
	,
		BFPRT(left, k)
	)
};

Pascal

{{works with|Free_Pascal}}

Program AveragesMedian(output);

type
  TDoubleArray = array of double;

procedure bubbleSort(var list: TDoubleArray);
var
  i, j, n: integer;
  t: double;
begin
  n := length(list);
  for i := n downto 2 do
    for j := 0 to i - 1 do
      if list[j] > list[j + 1] then
      begin
        t := list[j];
        list[j] := list[j + 1];
        list[j + 1] := t;
      end;
end;

function Median(aArray: TDoubleArray): double;
var
  lMiddleIndex: integer;
begin
  bubbleSort(aArray);
  lMiddleIndex := (high(aArray) - low(aArray)) div 2;
  if Odd(Length(aArray)) then
    Median := aArray[lMiddleIndex + 1]
  else
    Median := (aArray[lMiddleIndex + 1] + aArray[lMiddleIndex]) / 2;
end;

var
  A: TDoubleArray;
  i: integer;

begin
  randomize;
  setlength(A, 7);
  for i := low(A) to high(A) do
  begin
    A[i] := 100 * random;
    write (A[i]:7:3, ' ');
  end;
  writeln;
  writeln('Median: ', Median(A):7:3);

  setlength(A, 6);
  for i := low(A) to high(A) do
  begin
    A[i] := 100 * random;
    write (A[i]:7:3, ' ');
  end;
  writeln;
  writeln('Median: ', Median(A):7:3);
end.

Output:

% ./Median
 28.207  74.916  51.695  72.486  51.118   3.241  73.807
Median:  51.695
 27.984  89.172   0.250  66.316  41.805  60.043
Median:  50.924

Perl

{{trans|Python}}

sub median {
  my @a = sort {$a <=> $b} @_;
  return ($a[$#a/2] + $a[@a/2]) / 2;
}

Perl 6

{{works with|Rakudo|2016.08}}

sub median {
  my @a = sort @_;
  return (@a[(*-1) div 2] + @a[* div 2]) / 2;
}

Notes:

• The div operator does integer division. The / operator (rational number division) would work too, since the array subscript automatically coerces to Int, but using div is more explicit (i.e. clearer to readers) as well as faster, and thus recommended in cases like this.
• The * inside the subscript stands for the array's length ([https://docs.perl6.org/language/subscripts.html#From_the_end see documentation]).

In a slightly more compact way:

sub median { @_.sort[(*-1)/2, */2].sum / 2 }

Phix

The obvious simple way:

function median(sequence s)
atom res=0
integer l = length(s), k = floor((l+1)/2)
    if l then
        s = sort(s)
        res = s[k]
        if remainder(l,2)=0 then
            res = (res+s[k+1])/2
        end if
    end if
    return res
end function

It is also possible to use the [[Quickselect_algorithm#Phix|quick_select]] routine for a small (20%) performance improvement, which as suggested below may with luck be magnified by retaining any partially sorted results.

function medianq(sequence s)
atom res=0, tmp
integer l = length(s), k = floor((l+1)/2)
    if l then
        {s,res} = quick_select(s,k)
        if remainder(l,2)=0 then
            {s,tmp} = quick_select(s,k+1)
            res = (res+tmp)/2
        end if
    end if
    return res  -- (or perhaps return {s,res})
end function

PHP

This solution uses the sorting method of finding the median.

function median($arr)
{
    sort($arr);
    $count = count($arr); //count the number of values in array
    $middleval = floor(($count-1)/2); // find the middle value, or the lowest middle value
    if ($count % 2) { // odd number, middle is the median
        $median = $arr[$middleval];
    } else { // even number, calculate avg of 2 medians
        $low = $arr[$middleval];
        $high = $arr[$middleval+1];
        $median = (($low+$high)/2);
    }
    return $median;
}

echo median(array(4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2)) . "\n";  // 4.4
echo median(array(4.1, 7.2, 1.7, 9.3, 4.4, 3.2)) . "\n";       // 4.25

PicoLisp

(de median (Lst)
   (let N (length Lst)
      (if (bit? 1 N)
         (get (sort Lst) (/ (inc N) 2))
         (setq Lst (nth (sort Lst) (/ N 2)))
         (/ (+ (car Lst) (cadr Lst)) 2) ) ) )

(scl 2)
(prinl (round (median (1.0 2.0 3.0))))
(prinl (round (median (1.0 2.0 3.0 4.0))))
(prinl (round (median (5.1 2.6 6.2 8.8 4.6 4.1))))
(prinl (round (median (5.1 2.6 8.8 4.6 4.1))))

Output:

2.00
2.50
4.85
4.60

PL/I

call sort(A);
n = dimension(A,1);
if iand(n,1) = 1 then /* an odd number of elements */
   median = A(n/2);
else                  /* an even number of elements */
   median = (a(n/2) + a(trunc(n/2)+1) )/2;

PowerShell

This function returns an object containing the minimal amount of statistical data, including Median, and could be modified to take input directly from the pipeline.

All statistical properties could easily be added to the output object.

function Measure-Data
{
    [CmdletBinding()]
    [OutputType([PSCustomObject])]
    Param
    (
        [Parameter(Mandatory=$true,
                   Position=0)]
        [double[]]
        $Data
    )

    Begin
    {
        function Get-Mode ([double[]]$Data)
        {
            if ($Data.Count -gt ($Data | Select-Object -Unique).Count)
            {
                $groups = $Data | Group-Object | Sort-Object -Property Count -Descending

                return ($groups | Where-Object {[double]$_.Count -eq [double]$groups[0].Count}).Name | ForEach-Object {[double]$_}
            }
            else
            {
                return $null
            }
        }

        function Get-StandardDeviation ([double[]]$Data)
        {
            $variance = 0
            $average  = $Data | Measure-Object -Average | Select-Object -Property Count, Average

            foreach ($number in $Data)
            {
                $variance +=  [Math]::Pow(($number - $average.Average),2)
            }

            return [Math]::Sqrt($variance / ($average.Count-1))
        }

        function Get-Median ([double[]]$Data)
        {
            if ($Data.Count % 2)
            {
                return $Data[[Math]::Floor($Data.Count/2)]
            }
            else
            {
                return ($Data[$Data.Count/2], $Data[$Data.Count/2-1] | Measure-Object -Average).Average
            }
        }
    }
    Process
    {
        $Data = $Data | Sort-Object

        $Data | Measure-Object -Maximum -Minimum -Sum -Average |
                Select-Object -Property Count,
                                        Sum,
                                        Minimum,
                                        Maximum,
                                        @{Name='Range'; Expression={$_.Maximum - $_.Minimum}},
                                        @{Name='Mean' ; Expression={$_.Average}} |
                Add-Member -MemberType NoteProperty -Name Median            -Value (Get-Median $Data)            -PassThru |
                Add-Member -MemberType NoteProperty -Name StandardDeviation -Value (Get-StandardDeviation $Data) -PassThru |
                Add-Member -MemberType NoteProperty -Name Mode              -Value (Get-Mode $Data)              -PassThru
    }
}

$statistics = Measure-Data 4, 5, 6, 7, 7, 7, 8, 1, 1, 1, 2, 3
$statistics

{{Out}}

Count             : 12
Sum               : 52
Minimum           : 1
Maximum           : 8
Range             : 7
Mean              : 4.33333333333333
Median            : 4.5
StandardDeviation : 2.67423169368609
Mode              : {1, 7}

Median only:

$statistics.Median

{{Out}}

4.5

Prolog

median(L, Z) :-
    length(L, Length),
    I is Length div 2,
    Rem is Length rem 2,
    msort(L, S),
    maplist(sumlist, [[I, Rem], [I, 1]], Mid),
    maplist(nth1, Mid, [S, S], X),
    sumlist(X, Y),
    Z is Y/2.

Pure

Inspired by the Haskell version.

median x = (/(2-rem)) $ foldl1 (+) $ take (2-rem) $ drop (mid-(1-rem)) $ sort (<=) x
    when len = # x;
         mid = len div 2;
         rem = len mod 2;
         end;

Output:

> median [1, 3, 5];
3.0
> median [1, 2, 3, 4];
2.5

PureBasic

Procedure.d median(Array values.d(1), length.i)
  If length = 0 : ProcedureReturn 0.0 : EndIf
  SortArray(values(), #PB_Sort_Ascending)
  If length % 2
    ProcedureReturn values(length / 2)
  EndIf
  ProcedureReturn 0.5 * (values(length / 2 - 1) + values(length / 2))
EndProcedure

Procedure.i readArray(Array values.d(1))
  Protected length.i, i.i
  Read.i length
  ReDim values(length - 1)
  For i = 0 To length - 1
    Read.d values(i)
  Next
  ProcedureReturn i
EndProcedure

Dim floats.d(0)
Restore array1
length.i = readArray(floats())
Debug median(floats(), length)
Restore array2
length.i = readArray(floats())
Debug median(floats(), length)

DataSection
  array1:
    Data.i 7
    Data.d 4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2
  array2:
    Data.i 6
    Data.d 4.1, 7.2, 1.7, 9.3, 4.4, 3.2
EndDataSection

Python

def median(aray):
    srtd = sorted(aray)
    alen = len(srtd)
    return 0.5*( srtd[(alen-1)//2] + srtd[alen//2])

a = (4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2)
print a, median(a)
a = (4.1, 7.2, 1.7, 9.3, 4.4, 3.2)
print a, median(a)

R

R has its built-in median function. {{trans|Octave}}

omedian <- function(v) {
  if ( length(v) < 1 )
    NA
  else {
    sv <- sort(v)
    l <- length(sv)
    if ( l %% 2 == 0 )
      (sv[floor(l/2)+1] + sv[floor(l/2)])/2
    else
      sv[floor(l/2)+1]
  }
}

a <- c(4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2)
b <- c(4.1, 7.2, 1.7, 9.3, 4.4, 3.2)

print(median(a))   # 4.4
print(omedian(a))
print(median(b))   # 4.25
print(omedian(b))

Racket

#lang racket
(define (median numbers)
  (define sorted (list->vector (sort (vector->list numbers) <)))
  (define count (vector-length numbers))
  (if (zero? count)
      #f
      (/ (+ (vector-ref sorted (floor (/ (sub1 count) 2)))
            (vector-ref sorted (floor (/ count 2))))
         2)))

(median '#(5 3 4)) ;; 4
(median '#()) ;; #f
(median '#(5 4 2 3)) ;; 7/2
(median '#(3 4 1 -8.4 7.2 4 1 1.2)) ;; 2.1

REBOL

median: func [
    "Returns the midpoint value in a series of numbers; half the values are above, half are below."
    block [any-block!]
    /local len mid
][
    if empty? block [return none]
    block: sort copy block
    len: length? block
    mid: to integer! len / 2
    either odd? len [
        pick block add 1 mid
    ][
        (block/:mid) + (pick block add 1 mid) / 2
    ]
]

REXX

/*REXX program finds the  median  of a  vector  (and displays the  vector  and  median).*/
/*  ══════════vector════════════   ══show vector═══   ════════show result═══════════    */
    v=  1 9 2 4                ;   say "vector"  v;   say 'median──────►' median(v);   say
    v=  3 1 4 1 5 9 7 6        ;   say "vector"  v;   say 'median──────►' median(v);   say
    v= '3 4 1 -8.4 7.2 4 1 1.2';   say "vector"  v;   say 'median──────►' median(v);   say
    v=  -1.2345678e99  2.3e700 ;   say "vector"  v;   say 'median──────►' median(v);   say
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
eSORT:  procedure expose @. #;     parse arg $;     #= words($)   /*$:  is the  vector. */
                do g=1  for #;   @.g= word($, g);   end  /*g*/    /*convert list──►array*/
        h=#                                                       /*#:  number elements.*/
                do  while  h>1;             h= h % 2              /*cut entries by half.*/
                   do i=1  for #-h;         j= i;        k= h + i /*sort lower section. */
                      do  while @.k<@.j;    parse value  @.j @.k  with  @.k @.j  /*swap.*/
                      if h>=j  then leave;  j= j - h;    k= k - h /*diminish  J  and  K.*/
                      end   /*while @.k<@.j*/
                   end      /*i*/
                end         /*while h>1*/                         /*end of exchange sort*/
        return
/*──────────────────────────────────────────────────────────────────────────────────────*/
median: procedure; call eSORT arg(1);   m= # % 2    /*   %   is REXX's integer division.*/
        n= m + 1                                    /*N:     the next element after  M. */
        if # // 2  then return @.n                  /*[odd?]   // ◄───REXX's ÷ remainder*/
                        return (@.m + @.n) / 2      /*process an  even─element  vector. */

{{out|output}}

vector: 1 9 2 4
median──────► 3

vector: 3 1 4 1 5 9 7 6
median──────► 4.5

vector: 3 4 1 -8.4 7.2 4 1 1.2
median──────► 2.1

vector: -1.2345678e99  2.3e700
median──────► 1.15000000E+700

Ring

aList = [5,4,2,3]
see "medium : " + median(aList) + nl

func median aray
     srtd = sort(aray)
     alen = len(srtd)
     if alen % 2 = 0
        return (srtd[alen/2] + srtd[alen/2 + 1]) / 2.0
     else return srtd[ceil(alen/2)] ok

Ruby

def median(ary)
  return nil if ary.empty?
  mid, rem = ary.length.divmod(2)
  if rem == 0
    ary.sort[mid-1,2].inject(:+) / 2.0
  else
    ary.sort[mid]
  end
end

p median([])                        # => nil
p median([5,3,4])                   # => 4
p median([5,4,2,3])                 # => 3.5
p median([3,4,1,-8.4,7.2,4,1,1.2])  # => 2.1

Alternately:

def median(aray)
    srtd = aray.sort
    alen = srtd.length
    (srtd[(alen-1)/2] + srtd[alen/2]) / 2.0
end

Run BASIC

sqliteconnect #mem, ":memory:"
mem$ = "CREATE TABLE med (x float)"
#mem execute(mem$)

a$ ="4.1,5.6,7.2,1.7,9.3,4.4,3.2"	:gosub [median]
a$ ="4.1,7.2,1.7,9.3,4.4,3.2"		:gosub [median]
a$ ="4.1,4,1.2,6.235,7868.33"  		:gosub [median]
a$ ="1,5,3,2,4"       			:gosub [median]
a$ ="1,5,3,6,4,2"       		:gosub [median]
a$ ="4.4,2.3,-1.7,7.5,6.6,0.0,1.9,8.2,9.3,4.5"   :gosub [median]'
end
[median]
#mem execute("DELETE FROM med")
for i = 1 to 100
	v$	= word$( a$, i, ",")
	if v$ = "" then exit for
	mem$	= "INSERT INTO med values(";v$;")"
	#mem execute(mem$)
next i
mem$ = "SELECT AVG(x) as median FROM (SELECT x FROM med
ORDER BY x LIMIT 2 - (SELECT COUNT(*) FROM med) % 2
OFFSET (SELECT (COUNT(*) - 1) / 2
FROM med))"

#mem	execute(mem$)
	#row 	= #mem #nextrow()
	median	= #row median()
print " Median :";median;chr$(9);" Values:";a$

RETURN

Output:

Median :4.4	 Values:4.1,5.6,7.2,1.7,9.3,4.4,3.2
 Median :4.25	 Values:4.1,7.2,1.7,9.3,4.4,3.2
 Median :4.1	 Values:4.1,4,1.2,6.235,7868.33
 Median :3.0	 Values:1,5,3,2,4
 Median :3.5	 Values:1,5,3,6,4,2
 Median :4.45	 Values:4.4,2.3,-1.7,7.5,6.6,0.0,1.9,8.2,9.3,4.5

Rust

Sorting, then obtaining the median element:

fn median(mut xs: Vec<f64>) -> f64 {
    // sort in ascending order, panic on f64::NaN
    xs.sort_by(|x,y| x.partial_cmp(y).unwrap() );
    let n = xs.len();
    if n % 2 == 0 {
        (xs[n/2] + xs[n/2 - 1]) / 2.0
    } else {
        xs[n/2]
    }
}

fn main() {
    let nums = vec![2.,3.,5.,0.,9.,82.,353.,32.,12.];
    println!("{:?}", median(nums))
}

{{out}}

9

Scala

{{works with|Scala|2.8}} (See the Scala discussion on [[Mean]] for more information.)

def median[T](s: Seq[T])(implicit n: Fractional[T]) = {
  import n._
  val (lower, upper) = s.sortWith(_<_).splitAt(s.size / 2)
  if (s.size % 2 == 0) (lower.last + upper.head) / fromInt(2) else upper.head
}

This isn't really optimal. The methods splitAt and last are O(n/2) on many sequences, and then there's the lower bound imposed by the sort. Finally, we call size two times, and it can be O(n).

Scheme

{{trans|Python}} Using Rosetta Code's [[Bubble_Sort#Scheme|bubble-sort function]]

(define (median l)
  (* (+ (list-ref (bubble-sort l >) (round (/ (- (length l) 1) 2)))
        (list-ref (bubble-sort l >) (round (/ (length l) 2)))) 0.5))

Using [http://srfi.schemers.org/srfi-95/srfi-95.html SRFI-95]:

(define (median l)
  (* (+ (list-ref (sort l less?) (round (/ (- (length l) 1) 2)))
        (list-ref (sort l less?) (round (/ (length l) 2)))) 0.5))

Seed7

$ include "seed7_05.s7i";
  include "float.s7i";

const type: floatList is array float;

const func float: median (in floatList: floats) is func
  result
    var float: median is 0.0;
  local
    var floatList: sortedFloats is 0 times 0.0;
  begin
    sortedFloats := sort(floats);
    if odd(length(sortedFloats)) then
      median := sortedFloats[succ(length(sortedFloats)) div 2];
    else
      median := 0.5 * (sortedFloats[length(sortedFloats) div 2] +
                       sortedFloats[succ(length(sortedFloats) div 2)]);
    end if;
  end func;

const proc: main is func
  local
    const floatList: flist1 is [] (5.1, 2.6, 6.2, 8.8, 4.6, 4.1);
    const floatList: flist2 is [] (5.1, 2.6, 8.8, 4.6, 4.1);
  begin
    writeln("flist1 median is " <& median(flist1) digits 2 lpad 7); # 4.85
    writeln("flist2 median is " <& median(flist2) digits 2 lpad 7); # 4.60
  end func;

Sidef

func median(arry) {
    var srtd = arry.sort;
    var alen = srtd.length;
    srtd[(alen-1)/2]+srtd[alen/2] / 2;
}

Slate

s@(Sequence traits) median
[
  s isEmpty
    ifTrue: [Nil]
    ifFalse:
      [| sorted |
       sorted: s sort.
       sorted length `cache isEven
         ifTrue: [(sorted middle + (sorted at: sorted indexMiddle - 1)) / 2]
         ifFalse: [sorted middle]]
].

inform: { 4.1 . 5.6 . 7.2 . 1.7 . 9.3 . 4.4 . 3.2 } median.
inform: { 4.1 . 7.2 . 1.7 . 9.3 . 4.4 . 3.2 } median.

Smalltalk

{{works with|GNU Smalltalk}}

OrderedCollection extend [
    median [
      self size = 0
        ifFalse: [ |s l|
          l := self size.
          s := self asSortedCollection.
	  (l rem: 2) = 0
	    ifTrue: [ ^ ((s at: (l//2 + 1)) + (s at: (l//2))) / 2 ]
	    ifFalse: [ ^ s at: (l//2 + 1) ]
	]
	ifTrue: [ ^nil ]
    ]
].

{ 4.1 . 5.6 . 7.2 . 1.7 . 9.3 . 4.4 . 3.2 } asOrderedCollection
   median displayNl.
{ 4.1 . 7.2 . 1.7 . 9.3 . 4.4 . 3.2 } asOrderedCollection
   median displayNl.

Stata

Use '''[https://www.stata.com/help.cgi?summarize summarize]''' to compute the median of a variable (as well as other basic statistics).

set obs 100000
gen x=rbeta(0.2,1.3)
quietly summarize x, detail
display r(p50)

Here is a straightforward implementation using '''[https://www.stata.com/help.cgi? sort]'''.

program calcmedian, rclass sortpreserve
sort `1'
if mod(_N,2)==0 {
	return scalar p50=(`1'[_N/2]+`1'[_N/2+1])/2
}
else {
	return scalar p50=`1'[(_N-1)/2]
}
end

calcmedian x
display r(p50)

Tcl

proc median args {
    set list [lsort -real $args]
    set len [llength $list]
    # Odd number of elements
    if {$len & 1} {
        return [lindex $list [expr {($len-1)/2}]]
    }
    # Even number of elements
    set idx2 [expr {$len/2}]
    set idx1 [expr {$idx2-1}]
    return [expr {
        ([lindex $list $idx1] + [lindex $list $idx2])/2.0
    }]
}

puts [median 3.0 4.0 1.0 -8.4 7.2 4.0 1.0 1.2]; # --> 2.1

=={{header|TI-83 BASIC}}==

Using the built-in function:

median({1.1, 2.5, 0.3241})

=={{header|TI-89 BASIC}}==

median({3, 4, 1, -8.4, 7.2, 4, 1, 1})

Ursala

the simple way (sort first and then look in the middle)

#import std
#import flo

median = fleq-<; @K30K31X eql?\~&rh div\2.+ plus@lzPrhPX

test program, once with an odd length and once with an even length vector

#cast %eW

examples =

median~~ (
   <9.3,-2.0,4.0,7.3,8.1,4.1,-6.3,4.2,-1.0,-8.4>,
   <8.3,-3.6,5.7,2.3,9.3,5.4,-2.3,6.3,9.9>)

output:

(4.050000e+00,5.700000e+00)

== {{header|Vala}} == Requires --pkg posix -X -lm compilation flags in order to use POSIX qsort, and to have access to math library.

int compare_numbers(void* a_ref, void* b_ref) {
    double a = *(double*) a_ref;
    double b = *(double*) b_ref;
    return a > b ? 1 : a < b ? -1 : 0;
}

double median(double[] elements) {
    double[] clone = elements;
    Posix.qsort(clone, clone.length, sizeof(double), compare_numbers);
    double middle = clone.length / 2.0;
    int first = (int) Math.floor(middle);
    int second = (int) Math.ceil(middle);
    return (clone[first] + clone[second]) / 2;
}
void main() {
    double[] array1 = {2, 4, 6, 1, 7, 3, 5};
    double[] array2 = {2, 4, 6, 1, 7, 3, 5, 8};
    print(@"$(median(array1)) $(median(array2))\n");
}

VBA

{{trans|Phix}} Uses [[Quickselect_algorithm#VBA|quick select]].

Private Function medianq(s As Variant) As Double
    Dim res As Double, tmp As Integer
    Dim l As Integer, k As Integer
    res = 0
    l = UBound(s): k = WorksheetFunction.Floor_Precise((l + 1) / 2, 1)
        If l Then
            res = quick_select(s, k)
            If l Mod 2 = 0 Then
                tmp = quick_select(s, k + 1)
                res = (res + tmp) / 2
            End If
        End If
    medianq = res
End Function
Public Sub main2()
    s = [{4, 2, 3, 5, 1, 6}]
    Debug.Print medianq(s)
End Sub

{{out}}

 3,5

Vedit macro language

This is a simple implementation for positive integers using sorting. The data is stored in current edit buffer in ascii representation. The values must be right justified.

The result is returned in text register @10. In case of even number of items, the lower middle value is returned.

Sort(0, File_Size, NOCOLLATE+NORESTORE)
EOF Goto_Line(Cur_Line/2)
Reg_Copy(10, 1)

Wortel

@let {
  ; iterative
  med1 &l @let {a @sort l s #a i @/s 2 ?{%%s 2 ~/ 2 +`-i 1 a `i a `i a}}

  ; tacit
  med2 ^(\~/2 @sum @(^(\&![#~f #~c] \~/2 \~-1 #) @` @id) @sort)

  [[
    !med1 [4 2 5 2 1]
    !med1 [4 5 2 1]
    !med2 [4 2 5 2 1]
    !med2 [4 5 2 1]
  ]]
}

Returns:

[2 3 2 3]

Yabasic

{{trans|Lua}}

sub floor(x)
    return int(x + .05)
end sub

sub ceil(x)
    if x > int(x) x = x + 1
    return x
end sub

SUB ASort$(matriz$())
    local last, gap, first, tempi$, tempj$, i, j

    last = arraysize(matriz$(), 1)

    gap = floor(last / 10) + 1
    while(TRUE)
	first = gap + 1
	for i = first to last
	    tempi$ = matriz$(i)
	    j = i - gap
	    while(TRUE)
	        tempj$ = matriz$(j)
	 	if (tempi$ >= tempj$) then
	   	    j = j + gap
	   	    break
	 	end if
	 	matriz$(j+gap) = tempj$
	 	if j <= gap then
	   	    break
	 	end if
	 	j = j - gap
	    wend
	    matriz$(j) = tempi$
        next i
	if gap = 1 then
	    return
	else
	    gap = floor(gap / 3.5) + 1
	end if
    wend
END SUB


sub median(numlist$)
    local numlist$(1), n

    n = token(numlist$, numlist$(), ", ")

    ASort$(numlist$())

    if mod(n, 2) = 0 then return (val(numlist$(n / 2)) + val(numlist$(n / 2 + 1))) / 2 end if
    return val(numlist$(ceil(n / 2)))
end sub

print median("4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2")    // 4.4
print median("4.1, 7.2, 1.7, 9.3, 4.4, 3.2")         // 4.25

zonnon

module Averages;

type
	Vector = array {math} * of real;

procedure Partition(var a: Vector; left, right: integer): integer;
var
	pValue,aux: real;
	store,i,pivot: integer;
begin
	pivot := right;
	pValue := a[pivot];
	aux := a[right];a[right] := a[pivot];a[pivot] := aux; (* a[pivot] <-> a[right] *)
	store := left;
	for i := left to right -1 do
		if a[i] <= pValue then
			aux := a[store];a[store] := a[i];a[i]:=aux;
			inc(store)
		end
	end;
	aux := a[right];a[right] := a[store]; a[store] := aux;
	return store
end Partition;

(* QuickSelect algorithm *)
procedure Select(a: Vector; left,right,k: integer;var r: real);
var
	pIndex, pDist : integer;
begin
	if left = right then r := a[left]; return end;
	pIndex := Partition(a,left,right);
	pDist := pIndex - left + 1;
	if pDist = k then
		r := a[pIndex];return
	elsif k < pDist then
		Select(a,left, pIndex - 1, k, r)
	else
		Select(a,pIndex + 1, right, k - pDist, r)
	end
end Select;

procedure Median(a: Vector): real;
var
	idx: integer;
	r1,r2 : real;
begin
	idx := len(a) div 2 + 1;
	r1 := 0.0;r2 := 0.0;
	Select(a,0,len(a) - 1,idx,r1);
	if odd(len(a)) then return r1 end;
	Select(a,0,len(a) - 1,idx - 1,r2);
	return (r1 + r2) / 2;
end Median;

var
	ary: Vector;
	r: real;

begin
	ary := new Vector(3);
	ary := [5.0,3.0,4.0];
	writeln(Median(ary):10:2);
	ary := new Vector(4);
	ary := [5.0,4.0,2.0,3.0];
	writeln(Median(ary):10:2);
	ary := new Vector(8);
	ary := [3.0,4.0,1.0,-8.4,7.2,4.0,1.0,1.2];
	writeln(Median(ary):10:2)
end Averages.

        4
       3,5
       2,1

zkl

Using the [[Quickselect algorithm#zkl]] for O(n) time:

var quickSelect=Import("quickSelect").qselect;

fcn median(xs){
   n:=xs.len();
   if (n.isOdd) return(quickSelect(xs,n/2));
   ( quickSelect(xs,n/2-1) + quickSelect(xs,n/2) )/2;
}

median(T( 5.1, 2.6, 6.2, 8.8, 4.6, 4.1 )); //-->4.85
median(T( 5.1, 2.6, 8.8, 4.6, 4.1 ));      //-->4.6