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: