Averages/Mode: Difference between revisions

{{task|Probability and statistics}}

Write a program to find the [[wp:Mode (statistics)|mode]] value of a collection.

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

{{trans|Python}}

DefaultDict[Int, Int] count

L(v) values

=={{header|Action!}}==

INT ARRAY keys(MAX)

INT ARRAY values(MAX)

=={{header|ActionScript}}==

This implementation does not work with arbitrary collections. However, it works with arrays containing mixed data, including strings and other arrays.

//Create an associative array to count how many times each element occurs,

//an array to contain the modes, and a variable to store how many times each mode appears.

{{works with|Ada 2005}}

mode.ads:

type Element_Type is private;

type Element_Array is array (Positive range <>) of Element_Type;

end Mode;</syntaxhighlight>

mode.adb:

package body Mode is

end Mode;</syntaxhighlight>

example use:

with Mode;

procedure Main is

=={{header|APL}}==

=={{header|AppleScript}}==

This works with both lists and records containing numbers and/or text values.

use sorter : script "Shell sort" -- https://www.rosettacode.org/wiki/Sorting_algorithms/Shell_sort#AppleScript

=={{header|Arturo}}==

freqs: new #[]

loop arr 'i [

{{AutoHotkey case}}

Source: [http://www.autohotkey.com/forum/post-276175.html#276175 AutoHotkey forum] by Laszlo

MsgBox % Mode("1 2 0 3 0.0")

MsgBox % Mode("0.1 2.2 -0.1 0.22e1 2.20 0.1")

=={{header|AWK}}==

{

# compute histogram

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

a() = 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17

b() = 1, 2, 4, 4, 1

=={{header|C}}==

Using an array of doubles. If another data type is desired, the <code>cmp_dbl</code> and <code>vcount</code> definitions should be changed accordingly.

#include <stdlib.h>

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

using System.Collections;

using System.Collections.Generic;

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

{{works with|g++|4.3.2}}

#include <utility>

#include <algorithm>

=={{header|Clojure}}==

(let [distrib (frequencies coll)

[value freq] [first second] ; name the key/value pairs in the distrib (map) entries

(map value (take-while #(= maxfq (freq %)) sorted))))</syntaxhighlight>

Or a one-liner solution

(->> coll frequencies (sort-by val >) (partition-by val) first (map key)))</syntaxhighlight>

=={{header|CoffeeScript}}==

# returns an array with the modes of arr, i.e. the

# elements that appear most often in arr

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

The following returns a list of the modes of a sequence as the primary value, and the frequency as the secondary value. E.g., <code>(mode '(a b c d a b c a b))</code> produces <code>(A B)</code> and <code>3</code>. hash-table-options can be used to customize the hash table, e.g., to specify the test by which elements are compared.

(let ((frequencies (apply #'make-hash-table hash-table-options)))

(map nil (lambda (element)

=={{header|D}}==

The mode function returns a range of all the mode items:

auto mode(T)(T[] items) pure /*nothrow @safe*/ {

{{libheader| System.Generics.Collections}}

{{libheader| System.Generics.Defaults}}

program AveragesMode;

Value: 12, Count: 4</pre>

=={{header|E}}==

def mode(values) {

def counts := [].asMap().diverge()

return accum [].asSet() for v => ==maxCount in counts { _.with(v) }

}</syntaxhighlight>

# value: [4, 0].asSet()</syntaxhighlight>

In the line "<code>maxCount max= (counts[v] := counts.fetch(v, fn{0}) + 1)</code>", <code>max=</code> is an update-assignment operation like <code>+=</code>. (The parentheses are unnecessary.) A more verbose version would be:

counts[v] := newCount

maxCount := maxCount.max(newCount)</syntaxhighlight>

=={{header|EchoLisp}}==

(define (modes L)

(define G (group* L)) ;; sorts and group equal items

=={{header|Elena}}==

ELENA 5.0:

import system'collections;

import extensions;

=={{header|Elixir}}==

def mode(list) do

gb = Enum.group_by(list, &(&1))

=={{header|Erlang}}==

-module( mode ).

-export( [example/0, values/1] ).

=={{header|ERRE}}==

!$INTEGER

=={{header|Euphoria}}==

function mode(sequence s)

=={{header|F_Sharp|F#}}==

The Unchecked.defaultof became available in version 1.9.4 I think.

l

|> Seq.countBy (fun item -> item) // Count individual items

|> snd // From (count, list) we just want the second item (the list)</syntaxhighlight>

Example usage:

val it : string list = ["c"]

> mode ["a"; "b"; "c"; "c";"a"];;

=={{header|Factor}}==

Factor has the word <code>mode</code> in <code>math.statistics</code> vocabulary.

=={{header|Fortran}}==

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

For the <tt>Qsort_Module</tt> see [[Sorting_algorithms/Quicksort#Fortran]]

use Qsort_Module only Qsort => sort

implicit none

=={{header|FreeBASIC}}==

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

=={{header|Frink}}==

{

count = countToArray[vals]

</pre>

As of the 2022-07-31 release of Frink, the function can be rewritten as:

=={{header|GAP}}==

local c, m;

c := Collected(SortedList(v));

=={{header|Go}}==

'''Fixed collection type, fixed value type.''' In Go it is appropriate to program directly with built in types when possible.

import "fmt"

</pre>

'''Fixed collection type, unspecified value type.''' An empty interface can hold any type. A slice <tt>[]interface</tt> can hold a mix of types. It's not too much more source code, although there is some overhead to support this generality.

import "fmt"

</pre>

'''General collection, fixed value type.''' The other kind of generality mentioned in the task requires more code. In Go this is done with an interface to define generalized collection methods. Here, the only method we need to demonstrate is iteration over the collection, so the interface has only one method. Any number of types then can implement the interface. Note that the mode function now takes an object of this interface type. In effect, it becomes a generic function, oblivious to the implementation of the collection, and accessing it only through its methods.

import "fmt"

</pre>

'''General collection, unspecified value type,''' Finally, the two kinds of generality can be combined. The iterator returned by the interface method now returns an empty interface rather than an int. The intSlice concrete type of the previous example is retained, but now it must satisfy this interface method that uses <tt>interface{}</tt> instead of int. <tt>runeList</tt> is added to illustrate how multiple types can satisfy the same interface.

import "fmt"

=={{header|Groovy}}==

Solution, both "collection type" and "element type" agnostic:

assert col

def m = [:]

}</syntaxhighlight>

Test:

def sourceList = [ 'Lamp', 42.0, java.awt.Color.RED, new Date(), ~/pattern/]

(0..10).each {

=={{header|Haskell}}==

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

[1,2,3]

Alternately:

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

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

Another version that does not require an orderable type:

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

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

The <tt>mode</tt> procedure generates all <i>n</i> mode values if the collection is <i>n</i>-modal.

every write(!mode(args))

end

=={{header|J}}==

Literally: select from the unique values the values which appear the most often.

=={{header|Java}}==

public class Mode {

=={{header|JavaScript}}==

var counter = {};

var mode = [];

=={{header|jq}}==

jq only supports hashing of strings, so to preserve generality -- that is, to avoid assuming anything about the input array -- we simply sort it.

# in increasing order of count:

def modes:

| $modes[-1][1] as $count

| $modes[] | select( .[1] == $count) | .[0]

[1,2,3,1,2,1] | mode # => 1

[1,2,3,1,2,1,2] | mode # => 1 2

=={{header|Julia}}==

dict = Dict() # Values => Number of repetitions

modesArray = typeof(values[1])[] # Array of the modes so far

=={{header|K}}==

mode 1 1 1 1 2 2 2 3 3 3 3 4 4 3 2 4 4 4

3 4</syntaxhighlight>

=={{header|Kotlin}}==

val sortedByFreq = a.groupBy { it }.entries.sortedByDescending { it.value.size }

val maxFreq = sortedByFreq.first().value.size

=={{header|Lasso}}==

local(mmap = map, maxv = 0, modes = array)

// store counts

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

Using string of integers instead collection.

a$ = "1 3 6 6 6 6 7 7 12 12 17"

b$ = "1 2 4 4 1"

=={{header|Lua}}==

assert(type(tbl) == 'table')

local counts = { }

Function return an inventory, with all "modes" with same max number. Now work with mix numbers and strings. Islet return true if top of stack is letter (string).

Module Checkit {

\\ find mode

Module Checkit {

Function GetMode(&a()){

The built-in function Statistics:-Mode can be used to compute a mode.

When the mode is unique, it returns a numeric result and when there are multiple modes, it returns a set, as in the following example:

Statistics:-Mode([1, 2.1, 2.1, 3.2, 3.2, 5]);</syntaxhighlight>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Built-in function commonest returns a '''list''' of the most common element(s), even is there is only one 'commonest' number. Example for multiple 'commonest' numbers and a single 'commonest' number:

Commonest[{1, 3, 2, 3}]</syntaxhighlight>

{{out}}

=={{header|MATLAB}}==

modeValue = mode(setOfValues);

end</syntaxhighlight>

=={{header|MUMPS}}==

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

;I is a loop index

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

=={{header|Nim}}==

proc modes[T](xs: openArray[T]): T =

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

{{Works with|oo2c version2}}

MODULE Mode;

IMPORT

=={{header|Objeck}}==

use Collection;

=={{header|Objective-C}}==

@interface NSArray (Mode)

=={{header|OCaml}}==

let seen = Hashtbl.create 42 in

List.iter (fun x ->

=={{header|Octave}}==

Of course Octave has the <tt>mode</tt> function; but it returns only the "lowest" mode if multiple modes are available.

sv = sort(v);

% build two vectors, vals and c, so that

endwhile

endfunction</syntaxhighlight>

mode2(a)

mode(a)

=={{header|ooRexx}}==

See the example at [[#Version_2|REXX, Version 2]] for a version that returns multiple mode values.

-- will work with just about any collection...

call testMode .array~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

=={{header|Oz}}==

fun {Mode Xs}

Freq = {Dictionary.new}

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

my(count=1,r=1,b=v[1]);

v=vecsort(v);

=={{header|Perl}}==

use List::Util qw(max);

}</syntaxhighlight>

print "\n";

print "$_ " foreach mode(1, 1, 2, 4, 4);

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">mode</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: #000080;font-style:italic;">-- returns a list of the most common values, each of which occurs the same number of times</span>

=={{header|PHP}}==

Note: this function only works with strings and integers, as those are the only things that can be used as keys of an (associative) array in PHP.

function mode($arr) {

$count = array_count_values($arr);

=={{header|PicoLisp}}==

(let A NIL

(for X Lst

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

declare x(10) fixed binary static initial (1, 4, 2, 6, 2, 5, 6, 2, 4, 2);

declare f(32767) fixed binary;

=={{header|PowerShell}}==

$groups = $data | group-object | sort-object count -Descending

$groups | ? {$_.Count -eq $groups[0].Count}</syntaxhighlight>

=={{header|PureBasic}}==

Structure MyMean

The following solutions require that the elements be ''hashable''.

{{works with|Python|2.5+ and 3.x}}

>>> def modes(values):

count = defaultdict(int)

[1, 4]</syntaxhighlight>

{{works with|Python|2.7+ and 3.1+}}

>>> def modes(values):

count = Counter(values)

[1, 4]</syntaxhighlight>

If you just want one mode (instead of all of them), here's a one-liner for that:

return max(set(values), key=values.count)</syntaxhighlight>

=={{header|Q}}==

=={{header|Quackery}}==

[] [] rot

dup 0 peek temp put

=={{header|R}}==

a <- sort(table(v), decreasing=TRUE)

r <- c()

=={{header|Racket}}==

Returns values of list of modes and their frequencies of appearance.

(define (mode seq)

{{works with|Rakudo|2019.03.1}}

my %counts := @a.Bag;

my $max = %counts.values.max;

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

@a.Bag # count elements

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

===version 1===

Returns one mode value.

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

v= 1 8 6 0 1 9 4 6 1 9 9 9 ; say 'vector='v; say 'mode='mode(v); say

{{works with|Regina}}

and should work for every REXX.

/*-- ~~ main ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

call run_samples

=={{header|Ring}}==

# Project : Averages/Mode

=={{header|Ruby}}==

Here's two methods, the first more Ruby-ish, the second perhaps a bit more efficient.

seen = Hash.new(0)

ary.each {|value| seen[value] += 1}

{{works with|Ruby|1.8.7}}

If you just want one mode (instead of all of them), here's a one-liner for that:

ary.max_by { |x| ary.count(x) }

end</syntaxhighlight>

=={{header|Rust}}==

fn main() {

I'm accepting strings and numbers, although I'm converting numbers to strings,

as S-Lang Assoc_Type only accepts strings as keys.

define find_max(key) {

{{works with|Scala|2.8}}

Receiving any collection is easy. Returning the result in the same collection takes some doing.

import scala.collection.generic.CanBuildFrom

def mode

=={{header|Scheme}}==

{{works with|Berkeley Scheme}}

(define (helper collection counts)

(if (null? collection)

This way the <code>main</code> function can just [http://seed7.sourceforge.net/libraries/enable_output.htm#write%28in_aType%29 write] the mode.

const proc: createModeFunction (in type: elemType) is func

=={{header|Sidef}}==

var c = Hash.new;

array.each{|i| c{i} := 0 ++};

'''Calling the function'''

say mode([1, 1, 2, 4, 4]).join(' ');</syntaxhighlight>

If you just want one mode (instead of all of them), here's a one-liner for that:

arr.max_by{|i| arr.count(i)};

}</syntaxhighlight>

=={{header|Slate}}==

[| sortedCounts |

sortedCounts: (s as: Bag) sortedCounts.

{{works with|GNU Smalltalk}}

This code is able to find the mode of any collection of any kind of object.

mode [ |s|

s := self asBag sortedByCount.

=={{header|SQL}}==

create table averages (val integer);

insert into averages values (1);

This solution uses an extension of the Collection type to add a mode method. The only additional requirement of the Collection is that its Element conforms to Hashable.

// Extend the Collection protocol. Any type that conforms to extension where its Element type conforms to Hashable will automatically gain this method.

extension Collection where Element: Hashable {

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

proc mode {n args} {

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

=={{header|UNIX Shell}}==

{{works with|bash|4.0}}

function mode {

echo

}</syntaxhighlight>

a 2</syntaxhighlight>

=={{header|Ursala}}==

The mode function defined below works on lists of any type and returns a list of the modes. There is no concept of a general collection in Ursala. The algorithm is to partition the list by equality, then partition the classes by their lengths, and then select a representative from each member of the set of classes with the maximum length.

mode = ~&hS+ leql$^&h+ eql|=@K2

=={{header|VBA}}==

Using an array of integers to show the built-in Mode_Mult function, which find and displays the modes in an array. The function ignores text and only works for numbers.

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

t = WorksheetFunction.Mode_Mult(s)

The "mode" item and it's count are displayed on status line.

If there are multiple items with the same count, the smallest one is displayed.

Reg_Copy(10, ALL)

Buf_Switch(Buf_Free)

=={{header|Vlang}}==

println(mode([2, 7, 1, 8, 2]))

println(mode([2, 7, 1, 8, 2, 8]))

</pre>

Or using `math.stats` module

fn main() {

println(stats.mode<int>([2, 7, 1, 8, 2]))

=={{header|Wren}}==

static mode(arr) {

var map = {}

=={{header|XEmacs Lisp}}==

This returns a list of the modes. Any type(s) of data can be passed in, and any "equal" predicate function can be specified.

"Finds the mode of all values passed in.

Uses `predicate' to compare items."

=={{header|Yabasic}}==

return int(x + .05)

end sub

This is a bit funky in that modes are returned as strings.

{{trans|D}}

d:=Dictionary(); foreach i in (items){ d.incV(i) }

m:=d.reduce(fcn(m,[(_,v)]){ v.max(m) },0);

d.filter('wrap([(_,v)]){ v==m }).apply("get",0);

}</syntaxhighlight>

println("Mode: ", mode(data));

println("Mode: ", mode(data.append(2)));