Averages/Median: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

V srtd = sorted(aray)

V alen = srtd.len

 

print(median([4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2]))

{{out}}

<pre>

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

DEFINE PTR="CARD"

Test(a,i)

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Averages_Median.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

 

procedure FindMedian is

Ada.Float_Text_IO.Put( median_val );

Ada.Text_IO.New_line;

 

=={{header|ALGOL 68}}==

# Return the k-th smallest item in array x of length len #

"<: ", whole (less,0), new line,

">: ", whole (more, 0), new line,

Sample output:

<pre>length: 97738

=={{header|AntLang}}==

AntLang has a built-in median function.

 

=={{header|APL}}==

 

First, the input vector ⍵ is sorted with ⍵[⍋⍵] and the result placed in v. If the dimension ⍴v of v is odd, then both ⌈¯1+.5×⍴v and ⌊.5×⍴v give the index of the middle element. If ⍴v is even, ⌈¯1+.5×⍴v and ⌊.5×⍴v give the indices of the two middle-most elements. In either case, the average of the elements at these indices gives the median.

 

 

If you prefer an index origin of 1, use this code instead:

⎕IO←1

median←{v←⍵[⍋⍵] ⋄ 0.5×v[⌈0.5×⍴v]+v[⌊1+0.5×⍴v]}

 

This code was tested with ngn/apl and Dyalog 12.1. You can try this function online with [http://ngn.github.io/apl/web/index.html#code=median%u2190%7Bv%u2190%u2375%5B%u234B%u2375%5D%u22C4.5%D7v%5B%u2308%AF1+.5%D7%u2374v%5D+v%5B%u230A.5%D7%u2374v%5D%7D ngn/apl]. Note that ngn/apl currently only supports index origin 0. Examples:

=={{header|AppleScript}}==

===By iteration===

set med to medi(alist)

 

return max

 

{{output}}

 

===Composing functionally===

{{Trans|JavaScript}}

{{Trans|Haskell}}

 

-- median :: [Num] -> Num

missing value

end if

{{Out}}

 

----

 

===Quickselect===

on getMedian(theList, l, r)

if (theList is {}) then return theList

set end of testList to (random number 500) / 5

end repeat

 

{{output}}

<pre>{|numbers|:{71.6, 44.8, 45.8, 28.6, 96.8, 98.4, 42.4, 97.8}, median:58.7}</pre>

===Partial heap sort===

on getMedian(theList, l, r)

script o

end repeat

return {|numbers|:testList, median:getMedian(testList, 1, (count testList))}

 

{{output}}

 

=={{header|Applesoft BASIC}}==

110 K = INT(L/2) : GOSUB 150

120 R = X(K)

300 REMSWAP

310 H = X(P1):X(P1) = X(P2)

L = 11 : GOSUB 100MEDIAN

 

=={{header|Arturo}}==

 

arr2: [1 2 3 4 5 6]

print median arr

 

{{out}}

=={{header|AutoHotkey}}==

Takes the lower of the middle two if length is even

MsgBox % median(seq, "`,") ; 4.1

 

median := Floor(seq0 / 2)

Return seq%median%

 

=={{header|AWK}}==

AWK arrays can be passed as parameters, but not returned, so they are usually global.

 

 

BEGIN {

print ""

}

 

Example output:

 

=={{header|BaCon}}==

DECLARE b[] = { 4.1, 7.2, 1.7, 9.3, 4.4, 3.2 } TYPE FLOATING

 

 

SORT b

{{out}}

<pre>

Note that in order to truly work with the Windows versions of PowerBASIC, the module-level code must be contained inside <code>FUNCTION PBMAIN</code>. Similarly, in order to work under Visual Basic, the same module-level code must be contained with <code>Sub Main</code>.

 

 

DIM vec1(10) AS SINGLE, vec2(11) AS SINGLE, n AS INTEGER

median = (v(INT((ub + lb) / 2)) + v(INT((ub + lb) / 2) + 1)) / 2

END IF

 

See also: [[#BBC BASIC|BBC BASIC]], [[#Liberty BASIC|Liberty BASIC]], [[#PureBasic|PureBasic]], [[#TI-83 BASIC|TI-83 BASIC]], [[#TI-89 BASIC|TI-89 BASIC]].

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

Sort% = FN_sortinit(0,0)

 

CALL Sort%, a(0)

= (a(C% DIV 2) + a((C%-1) DIV 2)) / 2

Output:

<pre>Median of a() is 4.4

Each number is packaged in a little list and these lists are accumulated in a sum. Bracmat keeps sums sorted, so the median is the term in the middle of the list, or the average of the two terms in the middle of the list.

 

begin decimals end int list med med1 med2 num number

. 0:?list

)

& !med

 

 

=={{header|C}}==

#include <stdlib.h>

 

printf("flist2 median is %7.2f\n", median(&flist2)); /* 4.60 */

return 0;

===Quickselect algorithm===

Average O(n) time:

#include <stdlib.h>

#include <time.h>

return 0;

}

 

Output:

median: 0.000473

<: 496010

>: 496010

 

=={{header|C sharp|C#}}==

using System.Linq;

 

}

}

 

=={{header|C++}}==

This function runs in linear time on average.

 

// inputs must be random-access iterators of doubles

 

return 0;

 

===Order Statistic Tree===

Uses a GNU C++ policy-based data structure to compute median in O(log n) time.

{{libheader|gnu_pbds}}

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

return 0;

}

 

=={{header|Clojure}}==

Simple:

(let [ns (sort ns)

cnt (count ns)

(if (odd? cnt)

(nth ns mid)

 

=={{header|COBOL}}==

Intrinsic function:

 

=={{header|Common Lisp}}==

The recursive partitioning solution, without the median of medians optimization.

 

"Select nth element in list, ordered by predicate, modifying list."

(do ((pivot (pop list))

 

(defun median (list predicate)

 

=={{header|Crystal}}==

srtd = ary.sort

alen = srtd.size

a = [5.0]

puts median a

 

{{out}}

 

=={{header|D}}==

 

T median(T)(T[] nums) pure nothrow {

auto a2 = [5.1, 2.6, 8.8, 4.6, 4.1];

writeln("Odd median: ", a2.median);

{{out}}

<pre>Even median: 4.85

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(Median(TDoubleDynArray.Create(4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2)));

Writeln(Median(TDoubleDynArray.Create(4.1, 7.2, 1.7, 9.3, 4.4, 3.2)));

 

=={{header|E}}==

TODO: Use the selection algorithm, whatever that is [[Category:E examples needing attention]]

 

def sorted := list.sort()

def count := sorted.size()

return (sorted[mid1] + sorted[mid2]) / 2

}

 

# value: 2

 

? median([1,9,2,4])

 

=={{header|EasyLang}}==

test[] = [ 4.1 7.2 1.7 9.3 4.4 3.2 ]

call median test[] med

 

<pre>

 

=={{header|EchoLisp}}==

(define (median L) ;; O(n log(n))

(set! L (vector-sort! < (list->vector L)))

(median (iota 10001))

→ 5000

 

=={{header|Elena}}==

ELENA 5.0 :

import system'math;

import extensions;

console.readChar()

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def median([]), do: nil

def median(list) do

Enum.each(1..6, fn i ->

(for _ <- 1..i, do: :rand.uniform(6)) |> median.()

 

{{out}}

 

=={{header|Erlang}}==

-import(lists, [nth/2, sort/1]).

-compile(export_all).

end.

 

=={{header|ERRE}}==

PRINT(R)

END PROGRAM

Ouput is 5.95

 

v. Moreover it can search for the p median, not only the p=0.5 median.

 

>type median

function median (x, v: none, p)

>0.2*10+0.8*1

2.8

 

=={{header|Euphoria}}==

atom min,k

-- Selection sort of half+1

end function

 

 

Output:

Assuming the values are entered in the A column, type into any cell which will not be part of the list :

 

=MEDIAN(A1:A10)

 

Assuming 10 values will be entered, alternatively, you can just type

 

=MEDIAN(

and then select the start and end cells, not necessarily in the same row or column.

 

9

0

 

=={{header|F Sharp|F#}}==

Median of Medians algorithm implementation

let rec splitToFives list =

match list with

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

start z'

 

=={{header|Factor}}==

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

IN: median

 

 

: median ( seq -- median )

 

Usage:

5

( scratchpad ) 10 iota median .

 

=={{header|Forth}}==

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

: cell- -cell + ;

 

: median ( array len -- m )

1- cells over + 2dup mid to midpoint

 

test 4 median . \ 2

 

=={{header|Fortran}}==

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

 

 

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

end function median

 

 

MEDIAN = FINDELEMENT(K + 1,A,N)

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

 

=={{header|FreeBASIC}}==

 

Sub quicksort(a() As Double, first As Integer, last As Integer)

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|GAP}}==

local n, w;

w := SortedList(v);

# 44

Median(b);

 

=={{header|Go}}==

===Sort===

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

 

import (

}

return m

===Partial selection sort===

 

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().

 

 

import "fmt"

}

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.

 

import (

}

return a[0]

 

=={{header|Groovy}}==

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

def s = col as SortedSet

if (s == null) return null

def l = s.collect { it }

n%2 == 1 ? l[m] : (l[m] + l[m-1])/2

 

Test:

def sz = a.size()

 

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

${median(a[it..<sz])} == median(${a[it..<sz]})"""

 

Output:

 

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

 

nth :: Ord t => [t] -> Int -> t

[[], [7], [5, 3, 4], [5, 4, 2, 3], [3, 4, 1, -8.4, 7.2, 4, 1, 1.2]]

where

{{Out}}

<pre>(not defined)

Or {{libheader|hstats}}

 

 

=={{header|HicEst}}==

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

 

vec = RAN(1)

ELSE

median = ( vec(n/2) + vec(n/2 + 1) ) / 2

 

=={{header|Icon}} and {{header|Unicon}}==

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

 

Sample outputs:

=={{header|J}}==

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

median 1 9 2 4

The definition given in the addon script is:

 

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

median 1 9 2 4

 

=={{header|Java}}==

 

Sorting:

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

PriorityQueue<Double> pq = new PriorityQueue<Double>(list);

int n = list.size();

else

return (pq.poll() + pq.poll()) / 2.0;

 

{{works with|Java|1.8+}}

This version operates on objects rather than primitives and uses abstractions to operate on all of the standard numerics.

 

@FunctionalInterface

interface MedianFinder<T, R> extends Function<Collection<T>, R> {

public static BigDecimal bigDecimals(Collection<BigDecimal> bigDecimalCollection) { return BIG_DECIMALS.apply(bigDecimalCollection); }

}

 

=={{header|JavaScript}}==

 

===ES5===

if (ary.length == 0)

return null;

median([5,3,4]); // 4

median([5,4,2,3]); // 3.5

 

===ES6===

{{Trans|Haskell}}

 

'use strict';

 

[3, 4, 1, -8.4, 7.2, 4, 1, 1.2]

].map(median);

 

{{Out}}

null,

4,

3.5,

2.1

 

=={{header|jq}}==

length as $length

| sort as $s

else $s[$l2]

end

4.4

 

=={{header|Julia}}==

Julia has a built-in median() function

function median2(n)

s = sort(n)

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

 

 

{{out}}

 

=={{header|K}}==

med:{a:x@<x; i:(#a)%2; :[(#a)!2; a@i; {(+/x)%#x} a@i,i-1]}

v:10*6 _draw 0

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

 

=={{header|Kotlin}}==

{{works with|Kotlin|1.0+}}

 

fun main(args: Array<String>) {

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

 

=={{header|Lasso}}==

 

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

#a->sort

 

 

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

 

=={{header|Liberty BASIC}}==

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

 

if middle <>intmiddle then median= a( 1 +intmiddle) else median =( a( intmiddle) +a( intmiddle +1)) /2

end function

<pre>

4.1 5.6 7.2 1.7 9.3 4.4 3.2

 

=={{header|Lingo}}==

-- numlist = numlist.duplicate() -- if input list should not be altered

numlist.sort()

return (numlist[numlist.count/2]+numlist[numlist.count/2+1])/2.0

end if

 

=={{header|LiveCode}}==

LC has median as a built-in function

 

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

 

if n < 0 then

return (trunc(n) - 1)

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

 

=={{header|LSL}}==

integer MAX_VALUE = 100;

default {

llOwnerSay(" Sum Squares: "+(string)llListStatistics(LIST_STAT_SUM_SQUARES, lst));

}

Output:

<pre>

 

=={{header|Lua}}==

if type(numlist) ~= 'table' then return numlist end

table.sort(numlist)

 

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

 

=={{header|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:

{{out}}

<pre>3

7/2</pre>

Custom function:

If[Mod[L,2]==0,

(t[[L/2]]+t[[L/2+1]])/2

t[[(L+1)/2]]

]

Example of custom function:

{{out}}

<pre>3

=={{header|MATLAB}}==

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

medianValue = median(setOfValues);

 

=={{header|Maxima}}==

median([41, 56, 72, 17, 93, 44, 32]); /* 44 */

 

=={{header|MiniScript}}==

self.sort

m = floor(self.len/2)

print [41, 56, 72, 17, 93, 44, 32].median

{{out}}

<pre>44

 

=={{header|MUMPS}}==

;X is assumed to be a list of numbers separated by "^"

;I is a loop index

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)

<pre>USER>W $$MEDIAN^ROSETTA("-1.3^2.43^3.14^17^2E-3")

3.14

=={{header|Nanoquery}}==

{{trans|Python}}

 

def median(aray)

println a + " " + median(a)

a = {4.1, 7.2, 1.7, 9.3, 4.4, 3.2}

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

if i > j then return +1

else return 0

'''Output:'''

<pre>

 

=={{header|NewLISP}}==

; oofoe 2012-01-25

 

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

 

 

Sample output:

=={{header|Nim}}==

{{trans|Python}}

proc median(xs: seq[float]): float =

echo formatFloat(median(a), precision = 0)

a = @[4.1, 7.2, 1.7, 9.3, 4.4, 3.2]

 

Example Output:

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

Oxford Oberon-2

MODULE Median;

IMPORT Out;

Out.Fixed(Median(ary,0,7),4,2);Out.Ln;

END Median.

Output:

<pre>

 

=={{header|Objeck}}==

use Structure;

 

}

}

 

=={{header|OCaml}}==

let median array =

let len = Array.length array in

median a;;

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

 

=={{header|Octave}}==

Of course Octave has its own <tt>median</tt> 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.

if (numel(v) < 1)

y = NA;

disp(median(a))

disp(median2(b)) % 4.25

 

=={{header|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)

-- results for the compares

return (left - right)~sign

 

=={{header|Oz}}==

fun {Median Xs}

Len = {Length Xs}

in

{Show {Median [4.1 5.6 7.2 1.7 9.3 4.4 3.2]}}

 

=={{header|PARI/GP}}==

Sorting solution.

vecsort(v)[#v\2]

 

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

if(#v<15, return(vecsort(v)[k]));

my(u=List(),pivot,left=List(),right=List());

BFPRT(left, k)

)

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

 

type

writeln;

writeln('Median: ', Median(A):7:3);

Output:

<pre>% ./Median

=={{header|Perl}}==

{{trans|Python}}

my @a = sort {$a <=> $b} @_;

return ($a[$#a/2] + $a[@a/2]) / 2;

 

=={{header|Phix}}==

The obvious simple way:

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">median</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

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.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">medianq</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">res</span> <span style="color: #000080;font-style:italic;">-- (or perhaps return {s,res})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

 

=={{header|Phixmonti}}==

 

def median /# l -- n #/

 

( 4.1 5.6 7.2 1.7 9.3 4.4 3.2 ) median ?

 

=={{header|PHP}}==

This solution uses the sorting method of finding the median.

function median($arr)

{

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

 

=={{header|Picat}}==

Lists = [

[1.121,10.3223,3.41,12.1,0.01],

Len = L.length,

H = Len // 2,

 

{{out}}

 

=={{header|PicoLisp}}==

(let N (length Lst)

(if (bit? 1 N)

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

Output:

<pre>2.00

 

=={{header|PL/I}}==

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

 

=={{header|PowerShell}}==

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

 

function Measure-Data

{

}

}

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

$statistics

{{Out}}

<pre>

</pre>

Median only:

$statistics.Median

{{Out}}

<pre>

 

=={{header|Processing}}==

float[] numbers = {3.1, 4.1, 5.9, 2.6, 5.3, 5.8};

println(median(numbers));

float median = (nums[(nums.length - 1) / 2] + nums[nums.length / 2]) / 2.0;

return median;

{{Out}}

<pre>4.7

 

=={{header|Prolog}}==

length(L, Length),

I is Length div 2,

maplist(nth1, Mid, [S, S], X),

sumlist(X, Y),

 

=={{header|Pure}}==

Inspired by the Haskell version.

when len = # x;

mid = len div 2;

rem = len mod 2;

Output:<pre>> median [1, 3, 5];

3.0

 

=={{header|PureBasic}}==

If length = 0 : ProcedureReturn 0.0 : EndIf

SortArray(values(), #PB_Sort_Ascending)

Data.i 6

Data.d 4.1, 7.2, 1.7, 9.3, 4.4, 3.2

 

=={{header|Python}}==

srtd = sorted(aray)

alen = len(srtd)

print a, median(a)

a = (4.1, 7.2, 1.7, 9.3, 4.4, 3.2)

 

=={{header|R}}==

{{trans|Octave}}

 

if ( length(v) < 1 )

NA

print(omedian(a))

print(median(b)) # 4.25

 

=={{header|Racket}}==

(define (median numbers)

(define sorted (list->vector (sort (vector->list numbers) <)))

(median '#()) ;; #f

(median '#(5 4 2 3)) ;; 7/2

 

=={{header|Raku}}==

 

{{works with|Rakudo|2016.08}}

my @a = sort @_;

return (@a[(*-1) div 2] + @a[* div 2]) / 2;

 

Notes:

<br>

In a slightly more compact way:

 

=={{header|REBOL}}==

median: func [

"Returns the midpoint value in a series of numbers; half the values are above, half are below."

]

]

 

=={{header|ReScript}}==

{

let float_compare = (a, b) => {

Js.log(median([4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2]))

{{out}}

<pre>

 

=={{header|REXX}}==

/* ══════════vector════════════ ══show vector═══ ════════show result═══════════ */

v= 1 9 2 4 ; say "vector" v; say 'median──────►' median(v); say

n= m + 1 /*N: the next element after M. */

if # // 2 then return @.n /*[odd?] // ◄───REXX's ÷ remainder*/

{{out|output}}

<pre>

 

=={{header|Ring}}==

aList = [5,4,2,3]

see "medium : " + median(aList) + nl

return (srtd[alen/2] + srtd[alen/2 + 1]) / 2.0

else return srtd[ceil(alen/2)] ok

 

=={{header|Ruby}}==

return nil if ary.empty?

mid, rem = ary.length.divmod(2)

p median([5,3,4]) # => 4

p median([5,4,2,3]) # => 3.5

 

Alternately:

srtd = aray.sort

alen = srtd.length

(srtd[(alen-1)/2] + srtd[alen/2]) / 2.0

 

=={{header|Run BASIC}}==

mem$ = "CREATE TABLE med (x float)"

#mem execute(mem$)

print " Median :";median;chr$(9);" Values:";a$

 

<pre>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

Sorting, then obtaining the median element:

 

// sort in ascending order, panic on f64::NaN

xs.sort_by(|x,y| x.partial_cmp(y).unwrap() );

let nums = vec![2.,3.,5.,0.,9.,82.,353.,32.,12.];

println!("{:?}", median(nums))

 

{{out}}

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

 

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 <tt>splitAt</tt> and <tt>last</tt> are O(n/2)

{{trans|Python}}

Using Rosetta Code's [[Bubble_Sort#Scheme|bubble-sort function]]

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

 

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

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

 

=={{header|Seed7}}==

include "float.s7i";

writeln("flist1 median is " <& median(flist1) digits 2 lpad 7); # 4.85

writeln("flist2 median is " <& median(flist2) digits 2 lpad 7); # 4.60

 

=={{header|SenseTalk}}==

SenseTalk has a built-in median function. This example also shows the implementation of a customMedian function that returns the same results.

put the median of [4.1, 5.6, 7.2, 1.7, 9.3, 4.4, 3.2, 6.6]

 

return the middle item of list

end if

Output:

5

4.4

 

=={{header|Sidef}}==

var srtd = arry.sort;

var alen = srtd.length;

srtd[(alen-1)/2]+srtd[alen/2] / 2;

 

=={{header|Slate}}==

[

s isEmpty

ifTrue: [(sorted middle + (sorted at: sorted indexMiddle - 1)) / 2]

ifFalse: [sorted middle]]

 

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

median [

self size = 0

ifTrue: [ ^nil ]

]

 

median displayNl.

{ 4.1 . 7.2 . 1.7 . 9.3 . 4.4 . 3.2 } asOrderedCollection

 

=={{header|Stata}}==

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

 

gen x=rbeta(0.2,1.3)

quietly summarize x, detail

 

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

 

sort `1'

if mod(_N,2)==0 {

 

calcmedian x

 

=={{header|Tcl}}==

set list [lsort -real $args]

set len [llength $list]

}

 

 

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

 

Using the built-in function:

 

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

 

 

=={{header|Ursala}}==

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

#import flo

 

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

 

examples =

median~~ (

<9.3,-2.0,4.0,7.3,8.1,4.1,-6.3,4.2,-1.0,-8.4>,

output:

<pre>

Requires <code>--pkg posix -X -lm</code> compilation flags in order to use POSIX qsort, and to have access to math library.

 

double a = *(double*) a_ref;

double b = *(double*) b_ref;

double[] array2 = {2, 4, 6, 1, 7, 3, 5, 8};

print(@"$(median(array1)) $(median(array2))\n");

 

=={{header|VBA}}==

{{trans|Phix}}

Uses [[Quickselect_algorithm#VBA|quick select]].

Dim res As Double, tmp As Integer

Dim l As Integer, k As Integer

s = [{4, 2, 3, 5, 1, 6}]

Debug.Print medianq(s)

<pre> 3,5 </pre>

 

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

 

EOF Goto_Line(Cur_Line/2)

 

=={{header|Vlang}}==

println(median([3, 1, 4, 1])) // prints 2

println(median([3, 1, 4, 1, 5])) // prints 3

}

return m

 

{{out}}

println(stats.median<int>([1, 1, 3, 4])) // prints 2

println(stats.median<int>([1, 1, 3, 4, 5])) // prints 3

 

=={{header|Wortel}}==

; iterative

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

!med2 [4 5 2 1]

]]

Returns: <pre>[2 3 2 3]</pre>

 

{{libheader|Wren-math}}

{{libheader|Wren-queue}}

import "/math" for Nums

import "/queue" for PriorityQueue

}

System.print()

 

{{out}}

=={{header|Yabasic}}==

{{trans|Lua}}

return int(x + .05)

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

 

=={{header|zkl}}==

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

 

fcn median(xs){

if (n.isOdd) return(quickSelect(xs,n/2));

( quickSelect(xs,n/2-1) + quickSelect(xs,n/2) )/2;

 

=={{header|Zoea}}==

program: median

case: 1

input: [2,5,6,8]

output: 5.5

 

=={{header|Zoea Visual}}==

 

=={{header|zonnon}}==

module Averages;

 

writeln(Median(ary):10:2)

end Averages.

<pre>

4