Averages/Mode: Difference between revisions

=={{Header|ActionScript}}==

=={{Header|Ada}}==

=={{Header|APL}}==

=={{Header|AutoHotkey}}==

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

<lang csharp>using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

namespace Test

{

class Program

{

static void Main(string[] args)

{

/*

* We Use Linq To Determine The Mode

*/

List<int> myList = new List<int>() { 1, 1, 2, 4, 4 };

var query = from numbers in myList //select the numbers

group numbers by numbers //group them together so we can get the count

into groupedNumbers

select new { Number = groupedNumbers.Key, Count = groupedNumbers.Count() }; //so we got a query

//find the max of the occurence of the mode

int max = query.Max(g => g.Count);

IEnumerable<int> modes = query.Where(x => x.Count == max).Select(x => x.Number);//match the frequence and select the number

foreach (var item in modes)

{

Console.WriteLine(item);

}

Console.ReadLine();

}

}

}

</lang>

=={{header|Haskell}}==

<lang haskell>import Prelude (foldr, maximum, (==), (+))

import Data.Map (insertWith', empty, filter, elems, keys)

mode :: (Ord a) => [a] -> [a]

mode xs = keys (filter (== maximum (elems counts)) counts)

where counts = foldr (\x -> insertWith' (+) x 1) empty xs</lang>

''counts'' is a map from each value found in ''xs'' to the number of occurrences (foldr traverses the list, insertWith' increments the count). This map is then filtered to only those entries whose count is the maximum count, and their keys (the values from the input list) are returned.

> mode [1,2,3,3,2,1,1]

[1]

> mode [1,2,3,3,2,1]

[1,2,3]

Alternately:

<lang haskell>import Data.List (group, sort)

mode :: (Ord a) => [a] -> [a]

mode xs = map fst $ filter ((==best).snd) counts

where counts = map (\l -> (head l, length l)) . group . sort $ xs

best = maximum (map snd counts)</lang>

Another version that does not require an orderable type:

<lang haskell>import Data.List (partition)

mode :: (Eq a) => [a] -> [a]

mode = snd . modesWithCount

where modesWithCount :: (Eq a) => [a] -> (Int, [a])

modesWithCount [] = (0,[])

modesWithCount l@(x:_) | length xs > best = (length xs, [x])

| length xs < best = (best, modes)

| otherwise = (best, x:modes)

where (xs, notxs) = partition (== x) l

(best, modes) = modesWithCount notxs</lang>

=={{header|Perl 6}}==

{{works with|Rakudo|2019.03.1}}

<lang perl6>sub mode (*@a) {

my %counts := @a.Bag;

my $max = %counts.values.max;

%counts.grep(*.value == $max).map(*.key);

}

# Testing with arrays:

say mode [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17];

say mode [1, 1, 2, 4, 4];</lang>

{{out}}

<pre>

6

(4 1)

</pre>

Alternatively, a version that uses a single method chain with no temporary variables: (Same output with same input)

<lang perl6>sub mode (*@a) {

@a.Bag # count elements

.classify(*.value) # group elements with the same count

.max(*.key) # get group with the highest count

.value.map(*.key); # get elements in the group

}

say mode [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17];

say mode [1, 1, 2, 4, 4];</lang>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

<lang tcl># Can find the modal value of any vector of values

proc mode {n args} {

foreach n [list $n {*}$args] {

dict incr counter $n

}

set counts [lsort -stride 2 -index 1 -decreasing $counter]

set best {}

foreach {n count} $counts {

if {[lindex $counts 1] == $count} {

lappend best $n

} else break

}

return $best

}

# Testing

puts [mode 1 3 6 6 6 6 7 7 12 12 17]; # --> 6

puts [mode 1 1 2 4 4]; # --> 1 4</lang>

Note that this works for any kind of value.