Add all the A tasks

Task/Averages-Median/0DESCRIPTION

@@ -0,0 +1,5 @@
+Write a program to find the [[wp:Median|median]] value of a vector of floating-point numbers. The program need not handle the case where the vector is empty, but ''must'' handle the case where there are an even number of elements.
+
+There are several approaches to this. One is to sort the elements, and then pick the one in the middle. Sorting would take at least <span style="font-family: serif">O(''n'' log''n'')</span>. Another would be to build a priority queue from the elements, and then extract half of the elements to get to the middle one(s). This would also take <span style="font-family: serif">O(''n'' log''n'')</span>. The best solution is to use the [[wp:Selection algorithm|selection algorithm]] to find the median in <span style="font-family: serif">O(''n'')</span> time.
+
+See also: [[Mean]], [[Mode]]

Task/Averages-Median/1META.yaml

@@ -0,0 +1,2 @@
+---
+note: Probability and statistics

Task/Averages-Median/AWK/averages-median.awk

@@ -0,0 +1,46 @@
+#!/usr/bin/awk -f
+
+BEGIN {
+    d[1] = 3.0
+    d[2] = 4.0
+    d[3] = 1.0
+    d[4] = -8.4
+    d[5] = 7.2
+    d[6] = 4.0
+    d[7] = 1.0
+    d[8] = 1.2
+    showD("Before: ")
+    gnomeSortD()
+    showD("Sorted: ")
+    printf "Median: %f\n", medianD()
+    exit
+}
+
+function medianD(     len, mid) {
+    len = length(d)
+    mid = int(len/2) + 1
+    if (len % 2) return d[mid]
+    else return (d[mid] + d[mid-1]) / 2.0
+}
+
+function gnomeSortD(    i) {
+    for (i = 2; i <= length(d); i++) {
+        if (d[i] < d[i-1]) gnomeSortBackD(i)
+    }
+}
+
+function gnomeSortBackD(i,     t) {
+    for (; i > 1 && d[i] < d[i-1]; i--) {
+        t = d[i]
+        d[i] = d[i-1]
+        d[i-1] = t
+    }
+}
+
+function showD(p,   i) {
+    printf p
+    for (i = 1; i <= length(d); i++) {
+        printf d[i] " "
+    }
+    print ""
+}

Task/Averages-Median/Ada/averages-median.ada

@@ -0,0 +1,31 @@
+with Ada.Text_IO, Ada.Float_Text_IO;
+
+procedure FindMedian is
+
+    f: array(1..10) of float := ( 4.4, 2.3, -1.7, 7.5, 6.6, 0.0, 1.9, 8.2, 9.3, 4.5 );
+    min_idx: integer;
+    min_val, median_val, swap: float;
+
+begin
+    for i in f'range loop
+        min_idx := i;
+        min_val := f(i);
+        for j in i+1 .. f'last loop
+            if f(j) < min_val then
+                min_idx := j;
+                min_val := f(j);
+            end if;
+        end loop;
+        swap := f(i); f(i) := f(min_idx); f(min_idx) := swap;
+    end loop;
+
+    if f'length mod 2 /= 0 then
+        median_val := f( f'length/2+1 );
+    else
+        median_val := ( f(f'length/2) + f(f'length/2+1) ) / 2.0;
+    end if;
+
+    Ada.Text_IO.Put( "Median value: " );
+    Ada.Float_Text_IO.Put( median_val );
+    Ada.Text_IO.New_line;
+end FindMedian;

Task/Averages-Median/AppleScript/averages-median.applescript

@@ -0,0 +1,44 @@
+set alist to {1,2,3,4,5,6,7,8}
+set med to medi(alist)
+
+on medi(alist)
+	
+	set temp to {}
+	set lcount to count every item of alist
+	if lcount is equal to 2 then
+		return (item (random number from 1 to 2) of alist)
+	else if lcount is less than 2 then
+		return item 1 of alist
+	else --if lcount is greater than 2
+		set min to findmin(alist)
+		set max to findmax(alist)
+		repeat with x from 1 to lcount
+			if x is not equal to min and x is not equal to max then set end of temp to item x of alist
+		end repeat
+		set med to medi(temp)
+	end if
+	return med
+	
+end medi
+
+on findmin(alist)
+	
+	set min to 1
+	set alength to count every item of alist
+	repeat with x from 1 to alength
+		if item x of alist is less than item min of alist then set min to x
+	end repeat
+	return min
+	
+end findmin
+
+on findmax(alist)
+	
+	set max to 1
+	set alength to count every item of alist
+	repeat with x from 1 to alength
+		if item x of alist is greater than item max of alist then set max to x
+	end repeat
+	return max
+	
+end findmax

Task/Averages-Median/AutoHotkey/averages-median.ahk

@@ -0,0 +1,10 @@
+seq = 4.1, 7.2, 1.7, 9.3, 4.4, 3.2, 5
+MsgBox % median(seq, "`,")  ; 4.1
+
+median(seq, delimiter)
+{
+  Sort, seq, ND%delimiter%
+  StringSplit, seq, seq, % delimiter
+  median := Floor(seq0 / 2)
+  Return seq%median%
+}

Task/Averages-Median/BASIC/averages-median.bas

@@ -0,0 +1,30 @@
+DECLARE FUNCTION median! (vector() AS SINGLE)
+
+DIM vec1(10) AS SINGLE, vec2(11) AS SINGLE, n AS INTEGER
+
+RANDOMIZE TIMER
+
+FOR n = 0 TO 10
+    vec1(n) = RND * 100
+    vec2(n) = RND * 100
+NEXT
+vec2(11) = RND * 100
+
+PRINT median(vec1())
+PRINT median(vec2())
+
+FUNCTION median! (vector() AS SINGLE)
+    DIM lb AS INTEGER, ub AS INTEGER, L0 AS INTEGER
+    lb = LBOUND(vector)
+    ub = UBOUND(vector)
+    REDIM v(lb TO ub) AS SINGLE
+    FOR L0 = lb TO ub
+        v(L0) = vector(L0)
+    NEXT
+    quicksort v(), lb, ub
+    IF ((ub - lb + 1) MOD 2) THEN
+        median = v((ub + lb) / 2)
+    ELSE
+        median = (v(INT((ub + lb) / 2)) + v(INT((ub + lb) / 2) + 1)) / 2
+    END IF
+END FUNCTION

Task/Averages-Median/C/averages-median-1.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct floatList {
+    float *list;
+    int   size;
+} *FloatList;
+
+int floatcmp( const void *a, const void *b) {
+    if  (*(float *)a > *(float *)b)  return 1;
+    else if (*(float *)a < *(float *)b) return -1;
+    else return 0;
+}
+
+float median( FloatList fl )
+{
+    qsort( fl->list, fl->size, sizeof(float), floatcmp);
+    return 0.5 * ( fl->list[fl->size/2] + fl->list[(fl->size-1)/2]);
+}
+
+int main()
+{
+    static float floats1[] = { 5.1, 2.6, 6.2, 8.8, 4.6, 4.1 };
+    static struct floatList flist1 = { floats1, sizeof(floats1)/sizeof(float) };
+
+    static float floats2[] = { 5.1, 2.6, 8.8, 4.6, 4.1 };
+    static struct floatList flist2 = { floats2, sizeof(floats2)/sizeof(float) };
+
+    printf("flist1 median is %7.2f\n", median(&flist1)); /* 4.85 */
+    printf("flist2 median is %7.2f\n", median(&flist2)); /* 4.60 */
+    return 0;
+}

Task/Averages-Median/C/averages-median-2.c

@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/* select the k-th smallest item in array x of length len */
+int qselect(int *x, int k, int len)
+{
+	inline void swap(int a, int b) {
+		int t = x[a];
+		x[a] = x[b], x[b] = t;
+	}
+
+	int left = 0, right = len - 1;
+	int pivot, pos, i;
+
+	while (left < right) {
+		pivot = x[k];
+		swap(k, right);
+		for (i = pos = left; i < right; i++) {
+			if (x[i] < pivot) {
+				swap(i, pos);
+				pos++;
+			}
+		}
+		swap(right, pos);
+		if (pos == k) break;
+		if (pos < k) left = pos + 1;
+		else right = pos - 1;
+	}
+	return x[k];
+}
+
+#define N 10000001
+
+int icmp(const void *a, const void *b)
+{
+	return *(int*)a < *(int*)b ? -1 : *(int*)a > *(int*) b;
+}
+
+int main()
+{
+	int i, med, *x = malloc(sizeof(int) * N);
+
+	/* divide by large value to create many duplicate values */
+	for (i = 0; i < N; i++) x[i] = rand()/100000;
+
+	med = qselect(x, N/2, N);
+
+	/* qsort for speed comparison */
+	//qsort(x, N, sizeof(int), icmp); med = x[N/2];
+
+	printf("median is %d\n", med);
+
+	/* just to show it is the median */
+	int less = 0, more = 0, eq = 0;
+	for (i = 0; i < N; i++) {
+		if	(x[i] < med) less ++;
+		else if (x[i] > med) more ++;
+		else eq ++;
+	}
+	printf("<: %d\n>: %d\n=: %d\n", less, more, eq);
+
+	return 0;
+}

Task/Averages-Median/Clojure/averages-median.clj

@@ -0,0 +1,7 @@
+(defn median [ns]
+  (let [ns (sort ns)
+        cnt (count ns)
+        mid (bit-shift-right cnt 1)]
+    (if (odd? cnt)
+      (nth ns mid)
+      (/ (+ (nth ns mid) (nth ns (dec mid))) 2))))

Task/Averages-Median/Erlang/averages-median.erl

@@ -0,0 +1,10 @@
+-module(median).
+-import(lists, [nth/2, sort/1]).
+-compile(export_all).
+
+median(Unsorted) ->
+    Sorted = sort(Unsorted),
+    Length = length(Sorted),
+    Mid = Length div 2,
+    Rem = Length rem 2,
+    (nth(Mid+Rem, Sorted) + nth(Mid+1, Sorted)) / 2.

Task/Averages-Median/Forth/averages-median-1.fth

@@ -0,0 +1,30 @@
+-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 @ ;

Task/Averages-Median/Forth/averages-median-2.fth

@@ -0,0 +1,4 @@
+create test 4 , 2 , 1 , 3 , 5 ,
+
+test 4 median .   \ 2
+test 5 median .   \ 3

Task/Averages-Median/Fortran/averages-median.f

@@ -0,0 +1,43 @@
+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

Task/Averages-Median/Go/averages-median.go

@@ -0,0 +1,21 @@
+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
+}

Task/Averages-Median/Haskell/averages-median-1.hs

@@ -0,0 +1,8 @@
+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
+
+median xs = nth xs $ length xs `div` 2

Task/Averages-Median/Haskell/averages-median-2.hs

@@ -0,0 +1,2 @@
+> Math.Statistics.median [1,9,2,4]
+3.0

Task/Averages-Median/Java/averages-median-1.java

@@ -0,0 +1,5 @@
+// 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;
+}

Task/Averages-Median/Java/averages-median-2.java

@@ -0,0 +1,10 @@
+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;
+}

Task/Averages-Median/JavaScript/averages-median.js

@@ -0,0 +1,15 @@
+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

Task/Averages-Median/Lua/averages-median.lua

@@ -0,0 +1,9 @@
+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}))

Task/Averages-Median/PHP/averages-median.php

@@ -0,0 +1,17 @@
+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

Task/Averages-Median/Perl/averages-median.pl

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

Task/Averages-Median/PicoLisp/averages-median.l

@@ -0,0 +1,12 @@
+(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))))

Task/Averages-Median/Prolog/averages-median.pro

@@ -0,0 +1,9 @@
+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.

Task/Averages-Median/Python/averages-median.py

@@ -0,0 +1,9 @@
+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)

Task/Averages-Median/R/averages-median.r

@@ -0,0 +1,20 @@
+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))

Task/Averages-Median/REXX/averages-median.rexx

@@ -0,0 +1,33 @@
+/*REXX program to find the medium of a vector (& displays vector,medium)*/
+
+/*────────vector────────── ───show vector─── ───────show result─────────*/
+v='1 9 2 4'               ;  say 'vector=' v;  say 'medium=' medium(v);  say
+v='3 1 4 1 5 9 7 6'       ;  say 'vector= 'v;  say 'medium=' medium(v);  say
+v='3 4 1 -8.4 7.2 4 1 1.2';  say 'vector= 'v;  say 'medium=' medium(v);  say
+v='-1.2345678e99 2.3e+700';  say 'vector= 'v;  say 'medium=' medium(v);  say
+
+exit                                   /*stick a fork in it, we're done.*/
+/*──────────────────────────────────MEDIUM subroutine───────────────────*/
+medium: procedure;   parse arg x
+call makeArray x                       /*make into scaler array (faster)*/
+call Esort                             /*(ESORT is an overkill for this)*/
+m=@.0%2                                /*      %   is integer division. */
+n=m+1
+if @.0//2==1 then return @.n           /*(odd?)        //   is  modulus.*/
+                  return (@.m+@.n)/2   /*process an even-element vector.*/
+/*──────────────────────────────────MAKEARRAY subroutine────────────────*/
+makeArray: procedure expose @.;  parse arg v;  @.0=words(v) /*make array*/
+              do j=1 for @.0;   @.j=word(v,j);   end
+           return
+/*──────────────────────────────────ESORT subroutine────────────────────*/
+Esort: procedure expose @.;     h=@.0                /*@.0 =  # entries.*/
+        do while h>1;           h=h%2                /*cut entries by ½.*/
+           do i=1 for @.0-h;    j=i;      k=h+i
+              do while @.k<@.j
+              parse value  @.j @.k  with  @.k @.j    /*swap two values. */
+              if h>=j then leave
+              j=j-h;   k=k-h
+              end   /*while @.k<@.j*/
+           end      /*i*/
+        end         /*while h>l*/
+return                                      /*exchange sort is finished.*/

Task/Averages-Median/Racket/averages-median.rkt

@@ -0,0 +1,14 @@
+#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

Task/Averages-Median/Ruby/averages-median-1.rb

@@ -0,0 +1,14 @@
+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

Task/Averages-Median/Ruby/averages-median-2.rb

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

Task/Averages-Median/Scala/averages-median.scala

@@ -0,0 +1,5 @@
+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
+}

Task/Averages-Median/Scheme/averages-median-1.ss

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

Task/Averages-Median/Scheme/averages-median-2.ss

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

Task/Averages-Median/Smalltalk/averages-median-1.st

@@ -0,0 +1,13 @@
+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 ]
+    ]
+].

Task/Averages-Median/Smalltalk/averages-median-2.st

@@ -0,0 +1,4 @@
+{ 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.

Task/Averages-Median/Tcl/averages-median.tcl

@@ -0,0 +1,16 @@
+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