Averages/Mode: Difference between revisions
imported>Arakov |
|||
(184 intermediate revisions by 84 users not shown) | |||
Line 1: | Line 1: | ||
{{task|Probability and statistics}} |
|||
{{task|Probability and statistics}}Write a program to find the [[wp:Mode (statistics)|mode]] value of a collection. The case where the collection is empty may be ignored. Care must be taken to handle the case where the mode is non-unique. |
|||
;Task |
|||
Write a program to find the [[wp:Mode (statistics)|mode]] value of a collection. |
|||
The case where the collection is empty may be ignored. Care must be taken to handle the case where the mode is non-unique. |
|||
If it is not appropriate or possible to support a general collection, use a vector (array), if possible. If it is not appropriate or possible to support an unspecified value type, use integers. |
If it is not appropriate or possible to support a general collection, use a vector (array), if possible. If it is not appropriate or possible to support an unspecified value type, use integers. |
||
{{task heading|See also}} |
|||
See also: [[Mean]], [[Median]] |
|||
{{Related tasks/Statistical measures}} |
|||
<hr> |
|||
=={{header|11l}}== |
|||
{{trans|Python}} |
|||
<syntaxhighlight lang="11l">F modes(values) |
|||
DefaultDict[Int, Int] count |
|||
L(v) values |
|||
count[v]++ |
|||
V best = max(count.values()) |
|||
R count.filter(kv -> kv[1] == @best).map(kv -> kv[0]) |
|||
print(modes([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])) |
|||
print(modes([1, 1, 2, 4, 4]))</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[6] |
|||
[1, 4] |
|||
</pre> |
|||
=={{header|Action!}}== |
|||
<syntaxhighlight lang="action!">DEFINE MAX="100" |
|||
INT ARRAY keys(MAX) |
|||
INT ARRAY values(MAX) |
|||
BYTE count |
|||
PROC PrintArray(INT ARRAY a INT size) |
|||
INT i |
|||
Put('[) |
|||
FOR i=0 TO size-1 |
|||
DO |
|||
IF i>0 THEN Put(' ) FI |
|||
PrintI(a(i)) |
|||
OD |
|||
Put(']) PutE() |
|||
RETURN |
|||
PROC ClearMap() |
|||
count=0 |
|||
RETURN |
|||
PROC AddToMap(INT a) |
|||
INT i,index |
|||
index=-1 |
|||
IF count>0 THEN |
|||
FOR i=0 TO count-1 |
|||
DO |
|||
IF keys(i)=a THEN |
|||
index=i EXIT |
|||
FI |
|||
OD |
|||
FI |
|||
IF index=-1 THEN |
|||
keys(count)=a |
|||
values(count)=1 |
|||
count==+1 |
|||
ELSE |
|||
values(index)==+1 |
|||
FI |
|||
RETURN |
|||
PROC Mode(INT ARRAY a INT aSize INT ARRAY m INT POINTER mSize) |
|||
INT i,mx |
|||
ClearMap() |
|||
FOR i=0 TO aSize-1 |
|||
DO |
|||
AddToMap(a(i)) |
|||
OD |
|||
mx=0 |
|||
FOR i=0 TO count-1 |
|||
DO |
|||
IF values(i)>mx THEN |
|||
mx=values(i) |
|||
FI |
|||
OD |
|||
mSize^=0 |
|||
FOR i=0 TO count-1 |
|||
DO |
|||
IF values(i)=mx THEN |
|||
m(mSize^)=keys(i) |
|||
mSize^==+1 |
|||
FI |
|||
OD |
|||
RETURN |
|||
PROC Test(INT ARRAY a INT size) |
|||
INT ARRAY m(MAX) |
|||
INT mSize |
|||
PrintE("Array:") PrintArray(a,size) |
|||
Mode(a,size,m,@mSize) |
|||
PrintE("Mode:") PrintArray(m,mSize) |
|||
PutE() |
|||
RETURN |
|||
PROC Main() |
|||
INT ARRAY a=[1 3 5 7 3 1 3 7 7 3 3] |
|||
INT ARRAY b=[7 13 5 13 7 2 7 10 13] |
|||
INT ARRAY c=[5] |
|||
Test(a,11) |
|||
Test(b,9) |
|||
Test(c,1) |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Mode.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
Array: |
|||
[1 3 5 7 3 1 3 7 7 3 3] |
|||
Mode: |
|||
[3] |
|||
Array: |
|||
[7 13 5 13 7 2 7 10 13] |
|||
Mode: |
|||
[7 13] |
|||
Array: |
|||
[5] |
|||
Mode: |
|||
[5] |
|||
</pre> |
|||
=={{ |
=={{header|ActionScript}}== |
||
This implementation does not work with arbitrary collections. However, it works with arrays containing mixed data, including strings and other arrays. |
This implementation does not work with arbitrary collections. However, it works with arrays containing mixed data, including strings and other arrays. |
||
< |
<syntaxhighlight lang="actionscript">function Mode(arr:Array):Array { |
||
//Create an associative array to count how many times each element occurs, |
//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. |
//an array to contain the modes, and a variable to store how many times each mode appears. |
||
Line 34: | Line 169: | ||
} |
} |
||
return modeList; |
return modeList; |
||
}</ |
}</syntaxhighlight> |
||
=={{Header|AutoHotkey}}== |
|||
{{AutoHotkey case}} |
|||
=={{header|Ada}}== |
|||
{{works with|Ada 2005}} |
|||
mode.ads: |
|||
<syntaxhighlight lang="ada">generic |
|||
type Element_Type is private; |
|||
type Element_Array is array (Positive range <>) of Element_Type; |
|||
package Mode is |
|||
function Get_Mode (Set : Element_Array) return Element_Array; |
|||
end Mode;</syntaxhighlight> |
|||
mode.adb: |
|||
<syntaxhighlight lang="ada">with Ada.Containers.Indefinite_Vectors; |
|||
package body Mode is |
|||
-- map Count to Elements |
|||
package Count_Vectors is new Ada.Containers.Indefinite_Vectors |
|||
(Element_Type => Element_Array, |
|||
Index_Type => Positive); |
|||
procedure Add (To : in out Count_Vectors.Vector; Item : Element_Type) is |
|||
use type Count_Vectors.Cursor; |
|||
Position : Count_Vectors.Cursor := To.First; |
|||
Found : Boolean := False; |
|||
begin |
|||
while not Found and then Position /= Count_Vectors.No_Element loop |
|||
declare |
|||
Elements : Element_Array := Count_Vectors.Element (Position); |
|||
begin |
|||
for I in Elements'Range loop |
|||
if Elements (I) = Item then |
|||
Found := True; |
|||
end if; |
|||
end loop; |
|||
end; |
|||
if not Found then |
|||
Position := Count_Vectors.Next (Position); |
|||
end if; |
|||
end loop; |
|||
if Position /= Count_Vectors.No_Element then |
|||
-- element found, remove it and insert to next count |
|||
declare |
|||
New_Position : Count_Vectors.Cursor := |
|||
Count_Vectors.Next (Position); |
|||
begin |
|||
-- remove from old position |
|||
declare |
|||
Old_Elements : Element_Array := |
|||
Count_Vectors.Element (Position); |
|||
New_Elements : Element_Array (1 .. Old_Elements'Length - 1); |
|||
New_Index : Positive := New_Elements'First; |
|||
begin |
|||
for I in Old_Elements'Range loop |
|||
if Old_Elements (I) /= Item then |
|||
New_Elements (New_Index) := Old_Elements (I); |
|||
New_Index := New_Index + 1; |
|||
end if; |
|||
end loop; |
|||
To.Replace_Element (Position, New_Elements); |
|||
end; |
|||
-- new position not already there? |
|||
if New_Position = Count_Vectors.No_Element then |
|||
declare |
|||
New_Array : Element_Array (1 .. 1) := (1 => Item); |
|||
begin |
|||
To.Append (New_Array); |
|||
end; |
|||
else |
|||
-- add to new position |
|||
declare |
|||
Old_Elements : Element_Array := |
|||
Count_Vectors.Element (New_Position); |
|||
New_Elements : Element_Array (1 .. Old_Elements'Length + 1); |
|||
begin |
|||
New_Elements (1 .. Old_Elements'Length) := Old_Elements; |
|||
New_Elements (New_Elements'Last) := Item; |
|||
To.Replace_Element (New_Position, New_Elements); |
|||
end; |
|||
end if; |
|||
end; |
|||
else |
|||
-- element not found, add to count 1 |
|||
Position := To.First; |
|||
if Position = Count_Vectors.No_Element then |
|||
declare |
|||
New_Array : Element_Array (1 .. 1) := (1 => Item); |
|||
begin |
|||
To.Append (New_Array); |
|||
end; |
|||
else |
|||
declare |
|||
Old_Elements : Element_Array := |
|||
Count_Vectors.Element (Position); |
|||
New_Elements : Element_Array (1 .. Old_Elements'Length + 1); |
|||
begin |
|||
New_Elements (1 .. Old_Elements'Length) := Old_Elements; |
|||
New_Elements (New_Elements'Last) := Item; |
|||
To.Replace_Element (Position, New_Elements); |
|||
end; |
|||
end if; |
|||
end if; |
|||
end Add; |
|||
function Get_Mode (Set : Element_Array) return Element_Array is |
|||
Counts : Count_Vectors.Vector; |
|||
begin |
|||
for I in Set'Range loop |
|||
Add (Counts, Set (I)); |
|||
end loop; |
|||
return Counts.Last_Element; |
|||
end Get_Mode; |
|||
end Mode;</syntaxhighlight> |
|||
example use: |
|||
<syntaxhighlight lang="ada">with Ada.Text_IO; |
|||
with Mode; |
|||
procedure Main is |
|||
type Int_Array is array (Positive range <>) of Integer; |
|||
package Int_Mode is new Mode (Integer, Int_Array); |
|||
Test_1 : Int_Array := (1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6); |
|||
Result : Int_Array := Int_Mode.Get_Mode (Test_1); |
|||
begin |
|||
Ada.Text_IO.Put ("Input: "); |
|||
for I in Test_1'Range loop |
|||
Ada.Text_IO.Put (Integer'Image (Test_1 (I))); |
|||
if I /= Test_1'Last then |
|||
Ada.Text_IO.Put (","); |
|||
end if; |
|||
end loop; |
|||
Ada.Text_IO.New_Line; |
|||
Ada.Text_IO.Put ("Result:"); |
|||
for I in Result'Range loop |
|||
Ada.Text_IO.Put (Integer'Image (Result (I))); |
|||
if I /= Result'Last then |
|||
Ada.Text_IO.Put (","); |
|||
end if; |
|||
end loop; |
|||
Ada.Text_IO.New_Line; |
|||
end Main;</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Input: 1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6 |
|||
Result: 2, 3</pre> |
|||
=={{header|ALGOL 68}}== |
|||
{{libheader|ALGOL 68-rows}} |
|||
This sample defines an operator to return the mode(s) of an integer array. Additional operators cound be defined for other array types. |
|||
<br>Note the source of rows.incl.a68 (containing the QUICKSORT and SHOW operators) is available on a page in Rosetta Code, see the above link. |
|||
<syntaxhighlight lang="algol68"> |
|||
BEGIN # find the mode (most frequent value) of a set of items # |
|||
PR read "rows.incl.a68" PR # include row (array) utilities # |
|||
# returns the mode(s) of a - similar operators could be defined for # |
|||
# types other than INT # |
|||
OP MODEOF = ( []INT a )[]INT: |
|||
IF LWB a > UPB a THEN []INT() # no data # |
|||
ELSE # have data # |
|||
[ LWB a : UPB a ]INT sorted data := a; |
|||
QUICKSORT sorted data FROMELEMENT LWB sorted data TOELEMENT UPB sorted data; |
|||
INT distinct count = BEGIN # count the number of distinct values # |
|||
INT count := 1; |
|||
INT value := sorted data[ LWB sorted data ]; |
|||
FOR i FROM LWB sorted data + 1 TO UPB sorted data DO |
|||
IF value /= sorted data[ i ] THEN |
|||
count +:= 1; |
|||
value := sorted data[ i ] |
|||
FI |
|||
OD; |
|||
count |
|||
END; |
|||
INT current value := sorted data[ LWB sorted data ]; |
|||
INT max count := 0; |
|||
INT current count := 1; |
|||
INT s pos := LWB sorted data + 1; |
|||
# allow for the maximum possible number of modes # |
|||
[ 1 : distinct count ]INT modes; |
|||
INT mode count := 1; |
|||
modes[ 1 ] := current value; |
|||
WHILE s pos <= UPB sorted data DO |
|||
s pos +:= 1; |
|||
WHILE IF s pos > UPB sorted data |
|||
THEN FALSE |
|||
ELSE sorted data[ s pos ] = current value |
|||
FI |
|||
DO |
|||
current count +:= 1; |
|||
s pos +:= 1 |
|||
OD; |
|||
IF current count > max count THEN |
|||
max count := current count; |
|||
modes[ mode count := 1 ] := sorted data[ s pos - 1 ] |
|||
ELIF current count = max count THEN |
|||
modes[ mode count +:= 1 ] := sorted data[ s pos - 1 ] |
|||
FI; |
|||
current count := 0; |
|||
IF s pos <= UPB sorted data THEN |
|||
current value := sorted data[ s pos ] |
|||
FI |
|||
OD; |
|||
modes[ 1 : mode count ] |
|||
FI # MODEOF # ; |
|||
# test cases as in the 11l sample # |
|||
SHOW MODEOF []INT( 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17 );print( ( newline ) ); |
|||
SHOW MODEOF []INT( 1, 1, 2, 4, 4 ) ;print( ( newline ) ); |
|||
# test cases as in the Action! sample # |
|||
SHOW MODEOF []INT( 1, 3, 5, 7, 3, 1, 3, 7, 7, 3, 3 ) ;print( ( newline ) ); |
|||
SHOW MODEOF []INT( 7, 13, 5, 13, 7, 2, 7, 10, 13 ) ;print( ( newline ) ); |
|||
SHOW MODEOF []INT( 5 ) ;print( ( newline ) ); |
|||
# additional test case # |
|||
SHOW MODEOF []INT( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 ) ;print( ( newline ) |
|||
END |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
6 |
|||
1 4 |
|||
3 |
|||
7 13 |
|||
5 |
|||
9 |
|||
</pre> |
|||
=={{header|APL}}== |
|||
<syntaxhighlight lang="apl">mode←{{s←⌈/⍵[;2]⋄⊃¨(↓⍵)∩{⍵,s}¨⍵[;1]}{⍺,≢⍵}⌸⍵}</syntaxhighlight> |
|||
=={{header|AppleScript}}== |
|||
This works with both lists and records containing numbers and/or text values. |
|||
<syntaxhighlight lang="applescript">use AppleScript version "2.3.1" -- Mac OS X 10.9 (Mavericks) or later (for these 'use' commands). |
|||
use sorter : script "Shell sort" -- https://www.rosettacode.org/wiki/Sorting_algorithms/Shell_sort#AppleScript |
|||
on modeOf(listOrRecord) |
|||
-- Extract and sort numbers and text separately, then concatenate the results to get a single list of values. |
|||
set theNumbers to listOrRecord's numbers |
|||
tell sorter to sort(theNumbers, 1, -1) |
|||
set theTexts to listOrRecord's text |
|||
tell sorter to sort(theTexts, 1, -1) |
|||
script o |
|||
property values : theNumbers & theTexts |
|||
property mode : {} |
|||
end script |
|||
-- Identify the most frequently occurring value(s). |
|||
if (o's values is not {}) then |
|||
set i to 1 |
|||
set currentValue to beginning of o's values |
|||
set maxCount to 1 |
|||
repeat with j from 2 to (count o's values) |
|||
set thisValue to item j of o's values |
|||
if (thisValue is not currentValue) then |
|||
set thisCount to j - i |
|||
if (thisCount > maxCount) then |
|||
set o's mode to {currentValue} |
|||
set maxCount to thisCount |
|||
else if (thisCount = maxCount) then |
|||
set end of o's mode to currentValue |
|||
end if |
|||
set i to j |
|||
set currentValue to thisValue |
|||
end if |
|||
end repeat |
|||
if (j + 1 - i > maxCount) then |
|||
set o's mode to {currentValue} |
|||
else if (j + 1 - i = maxCount) then |
|||
set end of o's mode to currentValue |
|||
end if |
|||
end if |
|||
return o's mode |
|||
end modeOf |
|||
-- Test code: |
|||
-- With a list: |
|||
modeOf({12, 4, "rhubarb", 88, "rhubarb", 17, "custard", 4.0, 4, 88, "rhubarb"}) |
|||
--> {4, "rhubarb"} |
|||
-- With a record: |
|||
modeOf({a:12, b:4, c:"rhubarb", d:88, e:"rhubarb", f:17, g:"custard", h:4.0, i:4, j:88}) |
|||
--> {4}</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">getMode: function [arr][ |
|||
freqs: new #[] |
|||
loop arr 'i [ |
|||
k: to :string i |
|||
if not? key? freqs k -> set freqs k 0 |
|||
freqs\[k]: (freqs\[k]) + 1 |
|||
] |
|||
maximum: max values freqs |
|||
select keys freqs 'i -> maximum = freqs\[i] |
|||
] |
|||
print getMode [1 3 6 6 6 6 7 7 12 12 17] |
|||
print getMode [1 1 2 4 4]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>6 |
|||
1 4</pre> |
|||
=={{header|AutoHotkey}}== |
|||
{{AutoHotkey case}} |
|||
Source: [http://www.autohotkey.com/forum/post-276175.html#276175 AutoHotkey forum] by Laszlo |
Source: [http://www.autohotkey.com/forum/post-276175.html#276175 AutoHotkey forum] by Laszlo |
||
< |
<syntaxhighlight lang="autohotkey">MsgBox % Mode("1 2 3") |
||
MsgBox % Mode("1 2 0 3 0.0") |
MsgBox % Mode("1 2 0 3 0.0") |
||
MsgBox % Mode("0.1 2.2 -0.1 0.22e1 2.20 0.1") |
MsgBox % Mode("0.1 2.2 -0.1 0.22e1 2.20 0.1") |
||
Line 53: | Line 492: | ||
Else Ct++ |
Else Ct++ |
||
Return Ct>MxCt ? V : MxV |
Return Ct>MxCt ? V : MxV |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C}}== |
|||
Here we use an array of double (easily we could change it to handle integers or any other basic type). |
|||
<lang c>#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <stdbool.h> |
|||
=={{header|AWK}}== |
|||
#define INC_VAL 50 |
|||
<syntaxhighlight lang="awk">#!/usr/bin/gawk -f |
|||
{ |
|||
# compute histogram |
|||
histo[$1] += 1; |
|||
}; |
|||
function mode(HIS) { |
|||
// to hold the results |
|||
# Computes the mode from Histogram A |
|||
typedef struct stack { |
|||
max = 0; |
|||
n = 0; |
|||
for (k in HIS) { |
|||
size_t cap; |
|||
val = HIS[k]; |
|||
} stack_t; |
|||
if (HIS[k] > max) { |
|||
max = HIS[k]; |
|||
n = 1; |
|||
List[n] = k; |
|||
} else if (HIS[k] == max) { |
|||
List[++n] = k; |
|||
} |
|||
} |
|||
for (k=1; k<=n; k++) { |
|||
// to hold values and their frequencies |
|||
o = o""OFS""List[k]; |
|||
typedef struct fav_el { |
|||
} |
|||
return o; |
|||
size_t f; |
|||
} |
|||
} fav_el_t; |
|||
END { |
|||
typedef struct freqs_and_vals_table { |
|||
print mode(histo); |
|||
fav_el_t *vf; |
|||
};</syntaxhighlight> |
|||
size_t n; |
|||
size_t cap; |
|||
} fav_t;</lang> |
|||
<pre>cat modedata.txt |
|||
<lang c>fav_t *alloc_table() |
|||
0 |
|||
{ |
|||
3 |
|||
fav_t *r = malloc(sizeof(fav_t)); |
|||
6 |
|||
r->n = 0; |
|||
aa |
|||
r->cap = 1; |
|||
3 |
|||
r->vf = malloc(sizeof(fav_el_t)*INC_VAL); |
|||
6 |
|||
return r; |
|||
aa |
|||
} |
|||
3 |
|||
aa |
|||
6 |
|||
7 |
|||
1 |
|||
as@mini10:~/src/RosettaCode$ ./mode.awk modedata.txt |
|||
6 aa 3 |
|||
</pre> |
|||
=={{header|BBC BASIC}}== |
|||
void free_table(fav_t *t) |
|||
<syntaxhighlight lang="bbcbasic"> DIM a(10), b(4) |
|||
{ |
|||
a() = 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17 |
|||
free(t->vf); |
|||
b() = 1, 2, 4, 4, 1 |
|||
free(t); |
|||
} |
|||
DIM modes(10) |
|||
PRINT "Mode(s) of a() = " ; |
|||
FOR i% = 1 TO FNmodes(a(), modes()) |
|||
PRINT ; modes(i%) " " ; |
|||
NEXT |
|||
PRINT |
|||
PRINT "Mode(s) of b() = " ; |
|||
FOR i% = 1 TO FNmodes(b(), modes()) |
|||
PRINT ; modes(i%) " " ; |
|||
NEXT |
|||
PRINT |
|||
END |
|||
DEF FNmodes(a(), m()) |
|||
LOCAL I%, J%, N%, c%(), max% |
|||
N% = DIM(a(),1) |
|||
IF N% = 0 THEN m(1) = a(0) : = 1 |
|||
DIM c%(N%) |
|||
FOR I% = 0 TO N%-1 |
|||
FOR J% = I%+1 TO N% |
|||
IF a(I%) = a(J%) c%(I%) += 1 |
|||
NEXT |
|||
IF c%(I%) > max% max% = c%(I%) |
|||
NEXT I% |
|||
J% = 0 |
|||
FOR I% = 0 TO N% |
|||
IF c%(I%) = max% J% += 1 : m(J%) = a(I%) |
|||
NEXT |
|||
= J% |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Mode(s) of a() = 6 |
|||
Mode(s) of b() = 1 4</pre> |
|||
=={{header|BQN}}== |
|||
// compare functions for bsearch and qsort |
|||
#define CMP_HOOK(F) ((int (*)(const void *, const void *))F) |
|||
[https://mlochbaum.github.io/bqncrate/?q=mode# BQNcrate] lists two functions for mode. Of these, the first is faster. |
|||
int t_cmp(double *k, double *v) |
|||
{ |
|||
if ( *k < *v ) |
|||
return -1; |
|||
else if ( *k > *v ) |
|||
return 1; |
|||
else |
|||
return 0; |
|||
} |
|||
<pre>Mode1 ← ⌈´⊸=∘⊒⊸/ |
|||
int s_cmp(fav_el_t *a, fav_el_t *b) |
|||
Mode2 ← ⊏∘⊑˘·(⌈´⊸=≠¨)⊸/⊐⊸⊔ |
|||
{ |
|||
return t_cmp(&a->v, &b->v); |
|||
} |
|||
arr ← 1‿1‿1‿1‿2‿2‿2‿3‿3‿3‿3‿4‿4‿3‿2‿4‿4‿4‿5‿5‿5‿5‿5 |
|||
int f_cmp(fav_el_t *a, fav_el_t *b) |
|||
•Show Mode1 arr |
|||
•Show Mode2 arr</pre> |
|||
<pre>⟨ 3 4 5 ⟩ |
|||
⟨ 3 4 5 ⟩</pre> |
|||
=={{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. |
|||
<syntaxhighlight lang="c">#include <stdio.h> |
|||
#include <stdlib.h> |
|||
typedef struct { double v; int c; } vcount; |
|||
int cmp_dbl(const void *a, const void *b) |
|||
{ |
{ |
||
double x = *(const double*)a - *(const double*)b; |
|||
if ( a->f < b->f ) |
|||
return x < 0 ? -1 : x > 0; |
|||
else if ( a->f > b->f ) |
|||
return -1; |
|||
else |
|||
return 0; |
|||
} |
} |
||
int vc_cmp(const void *a, const void *b) |
|||
size_t table_search(fav_t *t, double v) |
|||
{ |
{ |
||
return ((const vcount*)b)->c - ((const vcount*)a)->c; |
|||
fav_el_t *el = bsearch(&v, t->vf, t->n, sizeof(fav_el_t), CMP_HOOK(s_cmp)); |
|||
return (el==NULL) ? -1 : (el - t->vf); |
|||
} |
} |
||
int get_mode(double* x, int len, vcount **list) |
|||
void add_value(fav_t *t, double v) |
|||
{ |
{ |
||
int i, j; |
|||
vcount *vc; |
|||
/* sort values */ |
|||
if ( (i=table_search(t, v)) < 0 ) { |
|||
qsort(x, len, sizeof(double), cmp_dbl); |
|||
if ( (t->n + 1) > (t->cap * INC_VAL) ) { |
|||
t->cap++; |
|||
t->vf = realloc(t->vf, t->cap * INC_VAL * sizeof(fav_el_t)); |
|||
} |
|||
t->vf[t->n].v = v; |
|||
t->vf[t->n].f = 1; |
|||
t->n++; |
|||
} else { |
|||
t->vf[i].f++; |
|||
} |
|||
} |
|||
/* count occurence of each value */ |
|||
void collect_from_array(fav_t *t, double *v, size_t n) |
|||
for (i = 0, j = 1; i < len - 1; i++, j += (x[i] != x[i + 1])); |
|||
{ |
|||
size_t i; |
|||
qsort(v, n, sizeof(double), CMP_HOOK(t_cmp)); |
|||
for(i=0; i < n; i++) { |
|||
add_value(t, v[i]); |
|||
} |
|||
} |
|||
*list = vc = malloc(sizeof(vcount) * j); |
|||
stack_t *init_stack() |
|||
vc[0].v = x[0]; |
|||
{ |
|||
vc[0].c = 1; |
|||
stack_t *r = malloc(sizeof(stack_t)); |
|||
r->n = 0; |
|||
r->cap = 1; |
|||
r->data = malloc(sizeof(double)*INC_VAL); |
|||
return r; |
|||
} |
|||
/* generate list value-count pairs */ |
|||
void free_stack(stack_t *s) |
|||
for (i = j = 0; i < len - 1; i++, vc[j].c++) |
|||
{ |
|||
if (x[i] != x[i + 1]) vc[++j].v = x[i + 1]; |
|||
free(s->data); |
|||
free(s); |
|||
/* sort that by count in descending order */ |
|||
qsort(vc, j + 1, sizeof(vcount), vc_cmp); |
|||
/* the number of entries with same count as the highest */ |
|||
for (i = 0; i <= j && vc[i].c == vc[0].c; i++); |
|||
return i; |
|||
} |
} |
||
int main() |
|||
void push_value(stack_t *s, double v) |
|||
{ |
{ |
||
double values[] = { 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 12, 12, 17 }; |
|||
if ( (s->n + 1) > (s->cap * INC_VAL) ) { |
|||
# define len sizeof(values)/sizeof(double) |
|||
s->cap++; |
|||
vcount *vc; |
|||
s->data = realloc(s->data, s->cap * INC_VAL * sizeof(double)); |
|||
} |
|||
s->data[s->n] = v; |
|||
s->n++; |
|||
}</lang> |
|||
int i, n_modes = get_mode(values, len, &vc); |
|||
All the codes above are utilities to keep this main function simple. First, we build a |
|||
table of value-frequency, for each different value, using the utility function |
|||
<tt>collect_from_array</tt>. Then we sort the value-frequency pair according to |
|||
the frequency (descending, cfr. <tt>f_cmp</tt>), and push on a "stack" all the |
|||
values with the biggest same frequency. |
|||
printf("got %d modes:\n", n_modes); |
|||
<lang c>stack_t *mode(double *v, size_t n) |
|||
for (i = 0; i < n_modes; i++) |
|||
{ |
|||
printf("\tvalue = %g, count = %d\n", vc[i].v, vc[i].c); |
|||
size_t i, f; |
|||
stack_t *r; |
|||
free(vc); |
|||
fav_t *t1 = alloc_table(); |
|||
return 0; |
|||
collect_from_array(t1, v, n); |
|||
}</syntaxhighlight> |
|||
// now let's sort according to freqs |
|||
{{out}} |
|||
qsort(t1->vf, t1->n, sizeof(fav_el_t), CMP_HOOK(f_cmp)); |
|||
<pre>got 2 modes: |
|||
r = init_stack(); |
|||
value = 6, count = 4 |
|||
f = t1->vf[0].f; |
|||
value = 12, count = 4</pre> |
|||
push_value(r, t1->vf[0].v); |
|||
for(i=1; (i < t1->n) && (t1->vf[i].f == f); i++) |
|||
push_value(r, t1->vf[i].v); |
|||
free_table(t1); |
|||
return r; |
|||
}</lang> |
|||
=={{header|C sharp|C#}}== |
|||
<lang c>double v1[] = { 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17 }; |
|||
<syntaxhighlight lang="csharp">using System; |
|||
double v2[] = { 1, 1, 2, 4, 4 }; |
|||
using System.Collections; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
namespace Test |
|||
#define PRINT_MODE(V) do { size_t i; \ |
|||
stack_t *r = mode(V, sizeof(V)/sizeof(double)); \ |
|||
for(i=0; i < r->n; i++) printf("%lf ", r->data[i]); \ |
|||
free_stack(r); printf("\n"); \ |
|||
} while(0); |
|||
int main() |
|||
{ |
{ |
||
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 |
|||
PRINT_MODE(v1) |
|||
group numbers by numbers //group them together so we can get the count |
|||
PRINT_MODE(v2); |
|||
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(); |
|||
} |
|||
return EXIT_SUCCESS; |
|||
}</lang> |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|C++}}== |
=={{header|C++}}== |
||
{{works with|g++|4.3.2}} |
{{works with|g++|4.3.2}} |
||
<syntaxhighlight lang="cpp">#include <iterator> |
|||
<lang cpp> |
|||
#include <iterator> |
|||
#include <utility> |
#include <utility> |
||
#include <algorithm> |
#include <algorithm> |
||
Line 237: | Line 716: | ||
referring(T const& t): value(t) {} |
referring(T const& t): value(t) {} |
||
template<typename Iter> |
template<typename Iter> |
||
bool operator()(std::pair<Iter, int> const& p) |
bool operator()(std::pair<Iter, int> const& p) const |
||
{ |
{ |
||
return *p.first == value; |
return *p.first == value; |
||
Line 292: | Line 771: | ||
std::ostream_iterator<int>(std::cout, " ")); |
std::ostream_iterator<int>(std::cout, " ")); |
||
std::cout << std::endl; |
std::cout << std::endl; |
||
return 0; |
|||
} |
|||
}</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
|||
Output: |
|||
2 3 |
2 3 |
||
=={{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|Clojure}}== |
=={{header|Clojure}}== |
||
< |
<syntaxhighlight lang="clojure">(defn modes [coll] |
||
(let [distrib (frequencies coll) |
(let [distrib (frequencies coll) |
||
[value freq] [first second] ; name the key/value pairs in the distrib (map) entries |
[value freq] [first second] ; name the key/value pairs in the distrib (map) entries |
||
sorted (sort-by (comp - freq) distrib) |
sorted (sort-by (comp - freq) distrib) |
||
maxfq (freq (first sorted))] |
maxfq (freq (first sorted))] |
||
(map value (take-while #(= maxfq (freq %)) sorted)))) |
(map value (take-while #(= maxfq (freq %)) sorted))))</syntaxhighlight> |
||
Or a one-liner solution |
|||
</lang> |
|||
<syntaxhighlight lang="clojure">(defn modes [coll] |
|||
(->> coll frequencies (sort-by val >) (partition-by val) first (map key)))</syntaxhighlight> |
|||
== |
=={{header|CoffeeScript}}== |
||
<syntaxhighlight lang="coffeescript">mode = (arr) -> |
|||
# returns an array with the modes of arr, i.e. the |
|||
# elements that appear most often in arr |
|||
counts = {} |
|||
for elem in arr |
|||
counts[elem] ||= 0 |
|||
counts[elem] += 1 |
|||
max = 0 |
|||
for key, cnt of counts |
|||
max = cnt if cnt > max |
|||
(key for key, cnt of counts when cnt == max) |
|||
console.log mode [1, 2, 2, 2, 3, 3, 3, 4, 4]</syntaxhighlight> |
|||
=={{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. |
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. |
||
< |
<syntaxhighlight lang="lisp">(defun mode (sequence &rest hash-table-options) |
||
(let ((frequencies (apply #'make-hash-table hash-table-options))) |
(let ((frequencies (apply #'make-hash-table hash-table-options))) |
||
(map nil (lambda (element) |
(map nil (lambda (element) |
||
Line 364: | Line 818: | ||
(push element modes)))) |
(push element modes)))) |
||
frequencies) |
frequencies) |
||
(values modes hifreq))))</ |
(values modes hifreq))))</syntaxhighlight> |
||
=={{header|D}}== |
=={{header|D}}== |
||
The mode function returns a range of all the mode items: |
|||
This getMode function works for all primitive types and also for complex types that implement opCmp. |
|||
<syntaxhighlight lang="d">import std.stdio, std.algorithm, std.array; |
|||
<lang d> |
|||
import std.stdio; |
|||
auto mode(T)(T[] items) pure /*nothrow @safe*/ { |
|||
// returns an array containing the mode (array just in case there is more than one mode) |
|||
int[T] aa; |
|||
T[]getMode(T)(T[]set) { |
|||
foreach (item; items) |
|||
int[T]aa; |
|||
aa[item]++; |
|||
immutable m = aa.byValue.reduce!max; |
|||
if ((element in aa) is null) aa[element] = 0; |
|||
return aa.byKey.filter!(k => aa[k] == m); |
|||
} |
|||
int modenum = 0; |
|||
T[]ret; |
|||
foreach(key,value;aa) { |
|||
if (value > modenum) { |
|||
modenum = value; |
|||
ret = [key]; |
|||
} else if (value == modenum) ret ~= key; |
|||
} |
|||
return ret; |
|||
} |
} |
||
void main() /*@safe*/ { |
|||
auto data = [1, 2, 3, 1, 2, 4, 2, 5, 3, 3, 1, 3, 6]; |
|||
writeln("Mode: ", data.mode); |
|||
int[]ret = getMode(vals); |
|||
foreach(mode;ret) writefln("Got mode %d for first set",mode); |
|||
vals ~= 2; |
|||
ret = getMode(vals); |
|||
foreach(mode;ret) writefln("Got mode %d for second set",mode); |
|||
return 0; |
|||
} |
|||
</lang> |
|||
data ~= 2; |
|||
=={{header|E}}== |
|||
writeln("Mode: ", data.mode); |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Mode: [3] |
|||
Mode: [2, 3]</pre> |
|||
=={{header|Delphi}}== |
|||
{{libheader| System.Generics.Collections}} |
|||
{{libheader| System.Generics.Defaults}} |
|||
<syntaxhighlight lang="delphi"> |
|||
program AveragesMode; |
|||
{$APPTYPE CONSOLE} |
|||
<lang e>pragma.enable("accumulator") |
|||
uses |
|||
System.SysUtils, |
|||
System.Generics.Collections, |
|||
System.Generics.Defaults; |
|||
type |
|||
TCounts = TDictionary<Integer, Integer>; |
|||
TPair = record |
|||
value, count: Integer; |
|||
constructor Create(value, count: Integer); |
|||
end; |
|||
TPairs = TArray<TPair>; |
|||
var |
|||
dict: TCounts; |
|||
Pairs: TPairs; |
|||
list: TArray<Integer>; |
|||
i, key, max: Integer; |
|||
p: TPair; |
|||
{ TPair } |
|||
constructor TPair.Create(value, count: Integer); |
|||
begin |
|||
self.value := value; |
|||
self.count := count; |
|||
end; |
|||
function SortByCount(const left, right: TPair): Integer; |
|||
begin |
|||
Result := right.count - left.count; |
|||
end; |
|||
begin |
|||
list := [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 12, 12, 17]; |
|||
dict := TCounts.Create; |
|||
for i in list do |
|||
begin |
|||
if dict.ContainsKey(i) then |
|||
dict[i] := dict[i] + 1 |
|||
else |
|||
begin |
|||
dict.Add(i, 1); |
|||
end; |
|||
end; |
|||
SetLength(Pairs, dict.Count); |
|||
i := 0; |
|||
for key in dict.Keys do |
|||
begin |
|||
Pairs[i] := TPair.Create(key, dict[key]); |
|||
inc(i); |
|||
end; |
|||
TArray.Sort<TPair>(Pairs, TComparer<TPair>.Construct(SortByCount)); |
|||
Writeln('Modes:'); |
|||
max := Pairs[0].count; |
|||
for p in Pairs do |
|||
if p.count = max then |
|||
Writeln(' Value: ', p.value, ', Count: ', p.count); |
|||
dict.Free; |
|||
Readln; |
|||
end.</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Modes: |
|||
Value: 6, Count: 4 |
|||
Value: 12, Count: 4</pre> |
|||
=={{header|E}}== |
|||
<syntaxhighlight lang="e">pragma.enable("accumulator") |
|||
def mode(values) { |
def mode(values) { |
||
def counts := [].asMap().diverge() |
def counts := [].asMap().diverge() |
||
Line 410: | Line 931: | ||
} |
} |
||
return accum [].asSet() for v => ==maxCount in counts { _.with(v) } |
return accum [].asSet() for v => ==maxCount in counts { _.with(v) } |
||
}</ |
}</syntaxhighlight> |
||
<syntaxhighlight lang="e">? mode([1,1,2,2,3,3,4,4,4,5,5,6,6,7,8,8,9,9,0,0,0]) |
|||
# value: [4, 0].asSet()</syntaxhighlight> |
|||
<lang e>? mode([1,1,2,2,3,3,4,4,4,5,5,6,6,7,8,8,9,9,0,0,0]) |
|||
# value: [4, 0].asSet()</lang> |
|||
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: |
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: |
||
<syntaxhighlight lang="e"> def newCount := counts.fetch(v, fn { 0 }) + 1 |
|||
<lang e> def newCount := counts.fetch(v, fn { 0 }) + 1 |
|||
counts[v] := newCount |
counts[v] := newCount |
||
maxCount := maxCount.max(newCount)</ |
maxCount := maxCount.max(newCount)</syntaxhighlight> |
||
In for loops, each key and value from the collection are [[Pattern Matching|pattern matched]] against the specified <code><var>key pattern</var> => <var>value pattern</var></code>. In "<code>for v => ==maxCount in counts</code>", the <code>==</code> is a pattern-match operator which fails unless the value examined is equal to the specified value; so this selects only the input values (keys in <code>counts</code>) whose counts are equal to the maximum count. |
In for loops, each key and value from the collection are [[Pattern Matching|pattern matched]] against the specified <code><var>key pattern</var> => <var>value pattern</var></code>. In "<code>for v => ==maxCount in counts</code>", the <code>==</code> is a pattern-match operator which fails unless the value examined is equal to the specified value; so this selects only the input values (keys in <code>counts</code>) whose counts are equal to the maximum count. |
||
=={{header|EasyLang}}== |
|||
<syntaxhighlight> |
|||
proc modes . in[] r[] . |
|||
r[] = [ ] |
|||
for v in in[] |
|||
for i to len vals[] |
|||
if v = vals[i] |
|||
cnt[i] += 1 |
|||
max = higher cnt[i] max |
|||
break 1 |
|||
. |
|||
. |
|||
vals[] &= v |
|||
cnt[] &= 0 |
|||
. |
|||
for i to len cnt[] |
|||
if cnt[i] = max |
|||
r[] &= vals[i] |
|||
. |
|||
. |
|||
. |
|||
in[] = [ 1 3 6 6 6 6 7 7 12 12 17 ] |
|||
modes in[] mods[] |
|||
print mods[] |
|||
in[] = [ 1 1 2 4 4 ] |
|||
modes in[] mods[] |
|||
print mods[] |
|||
</syntaxhighlight> |
|||
=={{header|EchoLisp}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
(define (modes L) |
|||
(define G (group* L)) ;; sorts and group equal items |
|||
(define cardmax (for/max [(g G)] (length g))) |
|||
(map first (filter (lambda(g) (= cardmax (length g))) G))) |
|||
(modes '( a b c a d e f)) |
|||
→ (a) |
|||
(modes (iota 6)) |
|||
→ (0 1 2 3 4 5) |
|||
(modes '(x)) |
|||
→ (x) |
|||
(modes '(🎾 🏉 ☕️ 🎾 🎲 🎯 🎺 ☕️ 🎲 🎸 🎻 🏆 ☕️ 🏁 🎾 🎲 🎻 🏉 )) |
|||
→ (🎾 ☕️ 🎲) |
|||
(modes '()) |
|||
😖️ error: group : expected list : null 🔎 'modes' |
|||
</syntaxhighlight> |
|||
=={{header|Elena}}== |
|||
ELENA 6.x: |
|||
<syntaxhighlight lang="elena">import system'routines; |
|||
import system'collections; |
|||
import extensions; |
|||
extension op |
|||
{ |
|||
get Mode() |
|||
{ |
|||
var countMap := Dictionary.new(0); |
|||
self.forEach::(item) |
|||
{ |
|||
countMap[item] := countMap[item] + 1 |
|||
}; |
|||
countMap := countMap.Values.sort::(p,n => p > n); |
|||
var max := countMap.FirstMember; |
|||
^ countMap |
|||
.filterBy::(kv => max.equal(kv.Value)) |
|||
.selectBy::(kv => kv.Key) |
|||
.toArray() |
|||
} |
|||
} |
|||
public program() |
|||
{ |
|||
var array1 := new int[]{1, 1, 2, 4, 4}; |
|||
var array2 := new int[]{1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17}; |
|||
var array3 := new object[]{1, "blue", 2, 7.5r, 5, "green", "red", 5, 2, "blue", "white"}; |
|||
console |
|||
.printLine("mode of (",array1.asEnumerable(),") is (",array1.Mode,")") |
|||
.printLine("mode of (",array2.asEnumerable(),") is (",array2.Mode,")") |
|||
.printLine("mode of (",array3.asEnumerable(),") is (",array3.Mode,")") |
|||
.readChar() |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
mode of (1,1,2,4,4) is (4,1) |
|||
mode of (1,3,6,6,6,6,7,7,12,12,17) is (6) |
|||
mode of (1,blue,2,7.5,5,green,red,5,2,blue,white) is (5,2,blue) |
|||
</pre> |
|||
=={{header|Elixir}}== |
|||
<syntaxhighlight lang="elixir">defmodule Average do |
|||
def mode(list) do |
|||
gb = Enum.group_by(list, &(&1)) |
|||
max = Enum.map(gb, fn {_,val} -> length(val) end) |> Enum.max |
|||
for {key,val} <- gb, length(val)==max, do: key |
|||
end |
|||
end |
|||
lists = [[3,1,4,1,5,9,2,6,5,3,5,8,9], |
|||
[1, 2, "qwe", "asd", 1, 2, "qwe", "asd", 2, "qwe"]] |
|||
Enum.each(lists, fn list -> |
|||
IO.puts "mode: #{inspect list}" |
|||
IO.puts " => #{inspect Average.mode(list)}" |
|||
end)</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
mode: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9] |
|||
=> [5] |
|||
mode: [1, 2, "qwe", "asd", 1, 2, "qwe", "asd", 2, "qwe"] |
|||
=> [2, "qwe"] |
|||
</pre> |
|||
=={{header|Erlang}}== |
|||
<syntaxhighlight lang="erlang"> |
|||
-module( mode ). |
|||
-export( [example/0, values/1] ). |
|||
example() -> |
|||
Set = [1, 2, "qwe", "asd", 1, 2, "qwe", "asd", 2, "qwe"], |
|||
io:fwrite( "In ~p the mode(s) is(are): ~p~n", [Set, values(Set)] ). |
|||
values( Set ) -> |
|||
Dict = lists:foldl( fun values_count/2, dict:new(), Set ), |
|||
[X || {X, _Y} <- dict:fold( fun keep_maxs/3, [{0, 0}], Dict )]. |
|||
keep_maxs( Key, Value, [{_Max_key, Max_value} | _] ) when Value > Max_value -> |
|||
[{Key, Value}]; |
|||
keep_maxs( Key, Value, [{_Max_key, Max_value} | _]=Maxs ) when Value =:= Max_value -> |
|||
[{Key, Value} | Maxs]; |
|||
keep_maxs( _Key, _Value, Maxs ) -> |
|||
Maxs. |
|||
values_count( Value, Dict ) -> dict:update_counter( Value, 1, Dict ). |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
12> mode:example(). |
|||
In [1, 2, "qwe", "asd", 1, 2, "qwe", "asd", 2, "qwe"] the mode(s) is(are): ["qwe", 2] |
|||
</pre> |
|||
=={{header|ERRE}}== |
|||
<syntaxhighlight lang="erre">PROGRAM MODE_AVG |
|||
!$INTEGER |
|||
DIM A[10],B[10],Z[10] |
|||
PROCEDURE SORT(Z[],P->Z[]) |
|||
LOCAL N,FLIPS |
|||
FLIPS=TRUE |
|||
WHILE FLIPS DO |
|||
FLIPS=FALSE |
|||
FOR N=0 TO P-1 DO |
|||
IF Z[N]>Z[N+1] THEN SWAP(Z[N],Z[N+1]) FLIPS=TRUE |
|||
END FOR |
|||
END WHILE |
|||
END PROCEDURE |
|||
PROCEDURE CALC_MODE(Z[],P->MODES$) |
|||
LOCAL I,OCCURRENCE,MAXOCCURRENCE,OLDVAL |
|||
SORT(Z[],P->Z[]) |
|||
OCCURENCE=1 |
|||
MAXOCCURENCE=0 |
|||
OLDVAL=Z[0] |
|||
MODES$="" |
|||
FOR I=1 TO P DO |
|||
IF Z[I]=OLDVAL THEN |
|||
OCCURENCE=OCCURENCE+1 |
|||
ELSE |
|||
IF OCCURENCE>MAXOCCURENCE THEN |
|||
MAXOCCURENCE=OCCURENCE |
|||
MODES$=STR$(OLDVAL) |
|||
ELSIF OCCURENCE=MAXOCCURENCE THEN |
|||
MODES$=MODES$+STR$(OLDVAL) |
|||
ELSE |
|||
!$NULL |
|||
END IF |
|||
OCCURENCE=1 |
|||
END IF |
|||
OLDVAL=Z[I] |
|||
END FOR |
|||
!check after loop |
|||
IF OCCURENCE>MAXOCCURENCE THEN |
|||
MAXOCCURENCE=OCCURENCE |
|||
MODES$=STR$(OLDVAL) |
|||
ELSIF OCCURENCE=MAXOCCURENCE THEN |
|||
MODES$=MODES$+STR$(OLDVAL) |
|||
ELSE |
|||
!$NULL |
|||
END IF |
|||
END PROCEDURE |
|||
BEGIN |
|||
A[]=(1,3,6,6,6,6,7,7,12,12,17) |
|||
B[]=(1,2,4,4,1) |
|||
PRINT("Modes for array A (1,3,6,6,6,6,7,7,12,12,17)";) |
|||
CALC_MODE(A[],10->MODES$) |
|||
PRINT(MODES$) |
|||
PRINT("Modes for array B (1,2,4,4,1)";) |
|||
CALC_MODE(B[],4->MODES$) |
|||
PRINT(MODES$) |
|||
END PROGRAM</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Modes for array A (1,3,6,6,6,6,7,7,12,12,17) 6 |
|||
Modes for array B (1,2,4,4,1) 1 4 |
|||
</pre> |
|||
=={{header|Euphoria}}== |
|||
<syntaxhighlight lang="euphoria">include misc.e |
|||
function mode(sequence s) |
|||
sequence uniques, counts, modes |
|||
integer j,max |
|||
uniques = {} |
|||
counts = {} |
|||
for i = 1 to length(s) do |
|||
j = find(s[i], uniques) |
|||
if j then |
|||
counts[j] += 1 |
|||
else |
|||
uniques = append(uniques, s[i]) |
|||
counts = append(counts, 1) |
|||
end if |
|||
end for |
|||
max = counts[1] |
|||
for i = 2 to length(counts) do |
|||
if counts[i] > max then |
|||
max = counts[i] |
|||
end if |
|||
end for |
|||
j = 1 |
|||
modes = {} |
|||
while j <= length(s) do |
|||
j = find_from(max, counts, j) |
|||
if j = 0 then |
|||
exit |
|||
end if |
|||
modes = append(modes, uniques[j]) |
|||
j += 1 |
|||
end while |
|||
return modes |
|||
end function |
|||
constant s = { 1, "blue", 2, 7.5, 5, "green", "red", 5, 2, "blue", "white" } |
|||
pretty_print(1,mode(s),{3})</syntaxhighlight> |
|||
{{out}} |
|||
<pre>{ |
|||
"blue", |
|||
2, |
|||
5 |
|||
}</pre> |
|||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
The Unchecked.defaultof became available in version 1.9.4 I think. |
The Unchecked.defaultof became available in version 1.9.4 I think. |
||
< |
<syntaxhighlight lang="fsharp">let mode (l:'a seq) = |
||
l |
l |
||
|> Seq.countBy (fun item -> item) // Count individual items |
|> Seq.countBy (fun item -> item) // Count individual items |
||
Line 433: | Line 1,215: | ||
else (cp,lst)) // else just keep old count/list |
else (cp,lst)) // else just keep old count/list |
||
(0, [Unchecked.defaultof<'a>]) // Start with a count of 0 and a dummy item |
(0, [Unchecked.defaultof<'a>]) // Start with a count of 0 and a dummy item |
||
|> snd // From (count, list) we just want the second item (the list)</ |
|> snd // From (count, list) we just want the second item (the list)</syntaxhighlight> |
||
Example usage: |
Example usage: |
||
< |
<syntaxhighlight lang="fsharp">> mode ["a"; "b"; "c"; "c"];; |
||
val it : string list = ["c"] |
val it : string list = ["c"] |
||
> mode ["a"; "b"; "c"; "c";"a"];; |
> mode ["a"; "b"; "c"; "c";"a"];; |
||
val it : string list = ["c"; "a"] |
val it : string list = ["c"; "a"] |
||
> mode [1;2;1;3;2;0;0];; |
> mode [1;2;1;3;2;0;0];; |
||
val it : int list = [0; 2; 1]</ |
val it : int list = [0; 2; 1]</syntaxhighlight> |
||
=={{header|Factor}}== |
|||
Factor has the word <code>mode</code> in <code>math.statistics</code> vocabulary. |
|||
<syntaxhighlight lang="factor">{ 11 9 4 9 4 9 } mode ! 9 </syntaxhighlight> |
|||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
{{works with|Fortran|90 and later}} |
{{works with|Fortran|90 and later}} |
||
For the <tt>Qsort_Module</tt> see [[Sorting_algorithms/Quicksort#Fortran]] |
For the <tt>Qsort_Module</tt> see [[Sorting_algorithms/Quicksort#Fortran]] |
||
< |
<syntaxhighlight lang="fortran">program mode_test |
||
use Qsort_Module only Qsort => sort |
use Qsort_Module only Qsort => sort |
||
implicit none |
implicit none |
||
Line 543: | Line 1,328: | ||
end function stat_mode |
end function stat_mode |
||
end program mode_test</ |
end program mode_test</syntaxhighlight> |
||
=={{header| |
=={{header|FreeBASIC}}== |
||
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
|||
<lang haskell>import Prelude (foldr, maximum, (==), (+)) |
|||
import Data.Map (insertWith', empty, filter, elems, keys) |
|||
Sub quicksort(a() As Integer, first As Integer, last As Integer) |
|||
mode :: (Ord a) => [a] -> [a] |
|||
Dim As Integer length = last - first + 1 |
|||
mode xs = keys (filter (== maximum (elems counts)) counts) |
|||
If length < 2 Then Return |
|||
where counts = foldr (\x -> insertWith' (+) x 1) empty xs</lang> |
|||
Dim pivot As Integer = a(first + length\ 2) |
|||
Dim lft As Integer = first |
|||
Dim rgt As Integer = last |
|||
While lft <= rgt |
|||
While a(lft) < pivot |
|||
lft +=1 |
|||
Wend |
|||
While a(rgt) > pivot |
|||
rgt -= 1 |
|||
Wend |
|||
If lft <= rgt Then |
|||
Swap a(lft), a(rgt) |
|||
lft += 1 |
|||
rgt -= 1 |
|||
End If |
|||
Wend |
|||
quicksort(a(), first, rgt) |
|||
quicksort(a(), lft, last) |
|||
End Sub |
|||
' The modal value(s) is/are stored in 'm'. |
|||
''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. |
|||
' The function returns the modal count. |
|||
Function mode(a() As Integer, m() As Integer, sorted As Boolean = false) As Integer |
|||
Dim lb As Integer = LBound(a) |
|||
Dim ub As Integer = UBound(a) |
|||
If ub = -1 Then Return 0 '' empty array |
|||
If Not sorted Then quicksort(a(), lb, ub) |
|||
Dim cValue As Integer = a(lb) |
|||
Dim cCount As Integer = 1 |
|||
Dim cMax As Integer = 0 |
|||
'' We iterate to the end of the array plus 1 to ensure the |
|||
'' final value is dealt with properly |
|||
For i As Integer = lb + 1 To ub + 1 |
|||
If i <= ub AndAlso a(i) = cValue Then |
|||
cCount += 1 |
|||
Else |
|||
If cCount > cMax Then |
|||
Erase m |
|||
Redim m(1 To 1) |
|||
m(1) = cValue |
|||
cMax = cCount |
|||
ElseIf cCount = cMax Then |
|||
Redim Preserve m(1 To UBound(m) + 1) |
|||
m(UBound(m)) = cValue |
|||
End If |
|||
If i = ub + 1 Then Exit For |
|||
cValue = a(i) |
|||
cCount = 1 |
|||
End If |
|||
Next |
|||
Return cMax |
|||
End Function |
|||
Dim a(1 To 14) As Integer = {1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6} |
|||
> mode [1,2,3,3,2,1,1] |
|||
Dim m() As Integer '' to store the mode(s) |
|||
[1] |
|||
Dim mCount As Integer = mode(a(), m()) |
|||
> mode [1,2,3,3,2,1] |
|||
Print "The following are the modes which occur"; mCount; " times : " |
|||
[1,2,3] |
|||
For i As Integer = LBound(m) To UBound(m) : Print m(i); " "; : Next |
|||
Print |
|||
Print "Press any key to quit" |
|||
Sleep</syntaxhighlight> |
|||
{{out}} |
|||
Alternately: |
|||
<pre> |
|||
<lang haskell>import Data.List (group, sort) |
|||
c:\FreeBasic>mode |
|||
The following are the modes which occur 4 times : |
|||
2 3 |
|||
</pre> |
|||
=={{header|Frink}}== |
|||
mode :: (Ord a) => [a] -> [a] |
|||
<syntaxhighlight lang="frink">modes[vals] := |
|||
mode xs = map fst $ filter ((==best).snd) counts |
|||
{ |
|||
where counts = map (\l -> (head l, length l)) . group . sort $ xs |
|||
count = countToArray[vals] |
|||
best = maximum (map snd counts)</lang> |
|||
biggest = count@0@1 |
|||
result = new array |
|||
for i = rangeOf[count] |
|||
if count@i@1 < biggest |
|||
break // count is sorted so we can bail out when numbers decrease |
|||
else |
|||
result.push[count@i@0] |
|||
return result |
|||
} |
|||
println[modes[[1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]]] |
|||
println[modes[[1, 1, 2, 4, 4]]]</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[6] |
|||
[1, 4] |
|||
</pre> |
|||
As of the 2022-07-31 release of Frink, the function can be rewritten as: |
|||
<syntaxhighlight lang="frink">modes[vals] := mostCommon[vals]@0</syntaxhighlight> |
|||
=={{header|FutureBasic}}== |
|||
FB has a native function for an array of mode averages. |
|||
<syntaxhighlight lang="futurebasic"> |
|||
local fn ModeAverage( arguments as CFArrayRef ) as CFStringRef |
|||
ExpressionRef expRef = fn ExpressionForFunction( @"mode:", @[fn ExpressionForConstantValue( arguments )] ) |
|||
CFArrayRef modeArray = fn ExpressionValueWithObject( expRef, NULL, NULL ) |
|||
CFNumberRef number |
|||
CFMutableStringRef modeStr = fn MutableStringNew |
|||
for number in modeArray |
|||
MutableStringAppendFormat( modeStr, @"value = %@\n", number ) |
|||
next |
|||
end fn = modeStr |
|||
print fn ModeAverage( @[@1, @3, @6, @6, @6, @6, @7, @7, @12, @12, @12, @12, @17] ) |
|||
HandleEvents |
|||
</syntaxhighlight> |
|||
{{output}} |
|||
<pre> |
|||
value = 6 |
|||
value = 12 |
|||
</pre> |
|||
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|GAP}}== |
=={{header|GAP}}== |
||
< |
<syntaxhighlight lang="gap">mode := function(v) |
||
local c, m; |
local c, m; |
||
c := Collected(SortedList(v)); |
c := Collected(SortedList(v)); |
||
Line 589: | Line 1,464: | ||
mode([ 7, 5, 6, 1, 5, 5, 7, 12, 17, 6, 6, 5, 12, 3, 6 ]); |
mode([ 7, 5, 6, 1, 5, 5, 7, 12, 17, 6, 6, 5, 12, 3, 6 ]); |
||
# [ 5, 6 ]</ |
# [ 5, 6 ]</syntaxhighlight> |
||
=={{header|Go}}== |
=={{header|Go}}== |
||
'''Fixed collection type, fixed value type.''' In Go it is appropriate to program directly with built in types when possible. |
|||
<lang go>package main |
|||
<syntaxhighlight lang="go">package main |
|||
import |
import "fmt" |
||
"fmt" |
|||
) |
|||
func main() { |
func main() { |
||
Line 605: | Line 1,480: | ||
m := make(map[int]int) |
m := make(map[int]int) |
||
for _, v := range a { |
for _, v := range a { |
||
m[v] |
m[v]++ |
||
} |
} |
||
var mode []int |
var mode []int |
||
Line 620: | Line 1,495: | ||
} |
} |
||
return mode |
return mode |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
|||
<pre> |
|||
[2] |
|||
[2 8] |
|||
</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. |
|||
<syntaxhighlight lang="go">package main |
|||
import "fmt" |
|||
=={{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. |
|||
func main() { |
|||
fmt.Println(mode([]interface{}{.2, .7, .1, .8, .2})) |
|||
fmt.Println(mode([]interface{}{"two", 7, 1, 8, "two", 8})) |
|||
} |
|||
func mode(a []interface{}) []interface{} { |
|||
m := make(map[interface{}]int) |
|||
for _, v := range a { |
|||
m[v]++ |
|||
} |
|||
var mode []interface{} |
|||
var n int |
|||
for k, v := range m { |
|||
switch { |
|||
case v < n: |
|||
case v > n: |
|||
n = v |
|||
mode = append(mode[:0], k) |
|||
default: |
|||
mode = append(mode, k) |
|||
} |
|||
} |
|||
return mode |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[0.2] |
|||
[two 8] |
|||
</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. |
|||
<syntaxhighlight lang="go">package main |
|||
import "fmt" |
|||
// interface type |
|||
type intCollection interface { |
|||
iterator() func() (int, bool) |
|||
} |
|||
// concrete type implements interface |
|||
type intSlice []int |
|||
// method on concrete type satisfies interface method |
|||
func (s intSlice) iterator() func() (int, bool) { |
|||
i := 0 |
|||
return func() (int, bool) { |
|||
if i >= len(s) { |
|||
return 0, false |
|||
} |
|||
v := s[i] |
|||
i++ |
|||
return v, true |
|||
} |
|||
} |
|||
func main() { |
|||
fmt.Println(mode(intSlice{2, 7, 1, 8, 2})) |
|||
fmt.Println(mode(intSlice{2, 7, 1, 8, 2, 8})) |
|||
} |
|||
// mode is now a generic function, in a sense. |
|||
// It knows what to do with an intCollection, |
|||
// but does not know the underlying concrete type. |
|||
func mode(a intCollection) []int { |
|||
m := make(map[int]int) |
|||
i := a.iterator() |
|||
for { |
|||
v, ok := i() |
|||
if !ok { |
|||
break |
|||
} |
|||
m[v]++ |
|||
} |
|||
var mode []int |
|||
var n int |
|||
for k, v := range m { |
|||
switch { |
|||
case v < n: |
|||
case v > n: |
|||
n = v |
|||
mode = append(mode[:0], k) |
|||
default: |
|||
mode = append(mode, k) |
|||
} |
|||
} |
|||
return mode |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[2] |
|||
[8 2] |
|||
</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. |
|||
<syntaxhighlight lang="go">package main |
|||
import "fmt" |
|||
type collection interface { |
|||
iterator() func() (interface{}, bool) |
|||
} |
|||
type intSlice []int |
|||
func (s intSlice) iterator() func() (interface{}, bool) { |
|||
i := 0 |
|||
return func() (interface{}, bool) { |
|||
if i >= len(s) { |
|||
return 0, false |
|||
} |
|||
v := s[i] |
|||
i++ |
|||
return v, true |
|||
} |
|||
} |
|||
type runeList string |
|||
func (s runeList) iterator() func() (interface{}, bool) { |
|||
c := make(chan rune) |
|||
go func() { |
|||
for _, r := range s { |
|||
c <- r |
|||
} |
|||
close(c) |
|||
}() |
|||
return func() (interface{}, bool) { |
|||
r, ok := <-c |
|||
return string(r), ok |
|||
} |
|||
} |
|||
func main() { |
|||
fmt.Println(mode(intSlice{2, 7, 1, 8, 2})) |
|||
fmt.Println(mode(runeList("Enzyklopädie"))) |
|||
} |
|||
func mode(a collection) []interface{} { |
|||
m := make(map[interface{}]int) |
|||
i := a.iterator() |
|||
for { |
|||
v, ok := i() |
|||
if !ok { |
|||
break |
|||
} |
|||
m[v]++ |
|||
} |
|||
var mode []interface{} |
|||
var n int |
|||
for k, v := range m { |
|||
switch { |
|||
case v < n: |
|||
case v > n: |
|||
n = v |
|||
mode = append(mode[:0], k) |
|||
default: |
|||
mode = append(mode, k) |
|||
} |
|||
} |
|||
return mode |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
("Enzyklopädie" has no repeated letters. All are modal.) |
|||
<pre> |
|||
[2] |
|||
[e d i k l o n p y z E ä] |
|||
</pre> |
|||
=={{header|Groovy}}== |
|||
Solution, both "collection type" and "element type" agnostic: |
|||
<syntaxhighlight lang="groovy">def mode(Iterable col) { |
|||
assert col |
|||
def m = [:] |
|||
col.each { |
|||
m[it] = m[it] == null ? 1 : m[it] + 1 |
|||
} |
|||
def keys = m.keySet().sort { -m[it] } |
|||
keys.findAll { m[it] == m[keys[0]] } |
|||
}</syntaxhighlight> |
|||
Test: |
|||
<syntaxhighlight lang="groovy">def random = new Random() |
|||
def sourceList = [ 'Lamp', 42.0, java.awt.Color.RED, new Date(), ~/pattern/] |
|||
(0..10).each { |
|||
def a = (0..10).collect { sourceList[random.nextInt(5)] } |
|||
println "${mode(a)} == mode(${a})" |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[pattern] == mode([pattern, pattern, pattern, Lamp, pattern, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], Lamp, Lamp, Lamp, pattern]) |
|||
[Lamp] == mode([Lamp, Fri Oct 28 23:43:20 CDT 2011, Lamp, java.awt.Color[r=255,g=0,b=0], 42.0, java.awt.Color[r=255,g=0,b=0], Fri Oct 28 23:43:20 CDT 2011, Lamp, pattern, pattern, 42.0]) |
|||
[java.awt.Color[r=255,g=0,b=0]] == mode([java.awt.Color[r=255,g=0,b=0], java.awt.Color[r=255,g=0,b=0], 42.0, 42.0, Fri Oct 28 23:43:20 CDT 2011, Fri Oct 28 23:43:20 CDT 2011, 42.0, java.awt.Color[r=255,g=0,b=0], pattern, pattern, java.awt.Color[r=255,g=0,b=0]]) |
|||
[Fri Oct 28 23:43:20 CDT 2011] == mode([Fri Oct 28 23:43:20 CDT 2011, pattern, 42.0, Fri Oct 28 23:43:20 CDT 2011, Lamp, pattern, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], 42.0, 42.0, Fri Oct 28 23:43:20 CDT 2011]) |
|||
[Fri Oct 28 23:43:20 CDT 2011, Lamp] == mode([42.0, Fri Oct 28 23:43:20 CDT 2011, Lamp, Lamp, Fri Oct 28 23:43:20 CDT 2011, Fri Oct 28 23:43:20 CDT 2011, 42.0, Lamp, java.awt.Color[r=255,g=0,b=0], Lamp, Fri Oct 28 23:43:20 CDT 2011]) |
|||
[java.awt.Color[r=255,g=0,b=0]] == mode([Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], java.awt.Color[r=255,g=0,b=0], pattern, 42.0, java.awt.Color[r=255,g=0,b=0], java.awt.Color[r=255,g=0,b=0], 42.0, pattern, Fri Oct 28 23:43:20 CDT 2011, pattern]) |
|||
[42.0, java.awt.Color[r=255,g=0,b=0]] == mode([42.0, java.awt.Color[r=255,g=0,b=0], pattern, Fri Oct 28 23:43:20 CDT 2011, Lamp, java.awt.Color[r=255,g=0,b=0], Lamp, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], 42.0, 42.0]) |
|||
[Fri Oct 28 23:43:20 CDT 2011] == mode([java.awt.Color[r=255,g=0,b=0], pattern, Fri Oct 28 23:43:20 CDT 2011, Lamp, 42.0, Fri Oct 28 23:43:20 CDT 2011, Fri Oct 28 23:43:20 CDT 2011, pattern, java.awt.Color[r=255,g=0,b=0], Lamp, Fri Oct 28 23:43:20 CDT 2011]) |
|||
[Fri Oct 28 23:43:20 CDT 2011] == mode([Fri Oct 28 23:43:20 CDT 2011, pattern, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], pattern, Fri Oct 28 23:43:20 CDT 2011, 42.0, java.awt.Color[r=255,g=0,b=0], Lamp, Fri Oct 28 23:43:20 CDT 2011, 42.0]) |
|||
[pattern] == mode([42.0, pattern, pattern, Lamp, 42.0, Lamp, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], pattern, 42.0, pattern]) |
|||
[Lamp, 42.0] == mode([Fri Oct 28 23:43:20 CDT 2011, pattern, Lamp, Lamp, Lamp, java.awt.Color[r=255,g=0,b=0], Fri Oct 28 23:43:20 CDT 2011, 42.0, 42.0, pattern, 42.0])</pre> |
|||
=={{header|Haskell}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
''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: |
|||
<syntaxhighlight 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)</syntaxhighlight> |
|||
Another version that does not require an orderable type: |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="icon">procedure main(args) |
|||
every write(!mode(args)) |
every write(!mode(args)) |
||
end |
end |
||
Line 639: | Line 1,751: | ||
else fail |
else fail |
||
} |
} |
||
end</ |
end</syntaxhighlight> |
||
{{out|Sample outputs}} |
|||
Sample outputs: |
|||
<pre>->am 3 1 4 1 5 9 7 6 |
<pre>->am 3 1 4 1 5 9 7 6 |
||
1 |
1 |
||
Line 651: | Line 1,761: | ||
=={{header|J}}== |
=={{header|J}}== |
||
< |
<syntaxhighlight lang="j">mode=: ~. #~ ( = >./ )@( #/.~ )</syntaxhighlight> |
||
Literally: select from the unique values the values which appear the most often. |
|||
Example: |
Example: |
||
<pre> mode 1 1 2 2 3 3 4 4 4 5 5 6 6 7 8 8 9 9 0 0 0 |
|||
4 0 |
|||
mode 1 3 6 6 6 6 7 7 12 12 17 |
|||
6 |
|||
mode 1 2 4 4 1 |
|||
1 4 |
|||
</pre> |
|||
=={{header|Jakt}}== |
|||
<lang> mode 1 1 2 2 3 3 4 4 4 5 5 6 6 7 8 8 9 9 0 0 0 |
|||
An empty set is returned if the iterable is empty. |
|||
4 0</lang> |
|||
<syntaxhighlight lang="jakt"> |
|||
fn mode<T, U>(anon iterable: U) throws -> {T} { |
|||
mut dictionary = Dictionary<T, u64>() |
|||
for item in iterable { |
|||
if dictionary.contains(item) { |
|||
dictionary[item]++ |
|||
} else { |
|||
dictionary[item] = 1 |
|||
} |
|||
} |
|||
mut items = dictionary.iterator() |
|||
let mode = items.next() |
|||
if not mode.has_value() { |
|||
let empty_set: {T} = {} |
|||
return empty_set |
|||
} |
|||
mut modes = [mode.value()] |
|||
for item in items { |
|||
if item.1 > modes[0].1 { |
|||
modes = [item] |
|||
} else if item.1 == modes[0].1 { |
|||
modes.push(item) |
|||
} |
|||
} |
|||
mut mode_set: {T} = {} |
|||
for mode in modes { |
|||
mode_set.add(mode.0) |
|||
} |
|||
return mode_set |
|||
} |
|||
fn main() { |
|||
println("{}", mode<i64>([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])) |
|||
println("{}", mode<i64>([1, 1, 2, 4, 4])) |
|||
let empty_array: [i64] = [] |
|||
println("{}", mode<i64>(empty_array)) |
|||
let test_string = "abcabbcaca" |
|||
println("{}", mode<u32>(test_string.code_points())) |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
< |
<syntaxhighlight lang="java">import java.util.*; |
||
public class Mode { |
public class Mode { |
||
Line 686: | Line 1,853: | ||
System.out.println(mode(Arrays.asList(1, 1, 2, 4, 4))); // prints [1, 4] |
System.out.println(mode(Arrays.asList(1, 1, 2, 4, 4))); // prints [1, 4] |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
< |
<syntaxhighlight lang="javascript">function mode(ary) { |
||
var counter = {}; |
|||
{ |
|||
var mode = []; |
|||
var |
|||
var max = 0; |
|||
for (var i in ary) { |
|||
mode = [], |
|||
if (!(ary[i] in counter)) |
|||
max = 0, |
|||
counter[ary[i]] = 0; |
|||
i; |
|||
counter[ary[i]]++; |
|||
for (i in ary) |
|||
{ |
|||
if (!(ary[i] in counter)) |
|||
counter[ary[i]] = 0; |
|||
counter[ary[i]]++; |
|||
if (counter[ary[i]] == max) |
if (counter[ary[i]] == max) |
||
mode.push(ary[i]); |
mode.push(ary[i]); |
||
else if (counter[ary[i]] > max) { |
|||
else |
|||
max = counter[ary[i]]; |
|||
mode = [ary[i]]; |
|||
{ |
|||
} |
|||
} |
|||
mode = [ary[i]]; |
|||
return mode; |
|||
} |
|||
} |
|||
return mode; |
|||
} |
} |
||
mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]); // [6] |
mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]); // [6] |
||
mode([1, 2, 4, 4, 1]); // [1,4]</ |
mode([1, 2, 4, 4, 1]); // [1,4]</syntaxhighlight> |
||
=={{header| |
=={{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. |
|||
<lang lua>function mode (numlist) |
|||
jq's <tt>sort</tt> is very fast in any case.<syntaxhighlight lang="jq"># modes/0 produces an array of [value, count] |
|||
if type(numlist) ~= 'table' then return numlist end |
|||
# in increasing order of count: |
|||
local sets = {} |
|||
def modes: |
|||
local mode |
|||
sort | reduce .[] as $i ([]; |
|||
local modeValue = 0 |
|||
# state variable is an array of [value, count] |
|||
table.foreach(numlist,function(i,v) if sets[v] then sets[v] = sets[v] + 1 else sets[v] = 1 end end) |
|||
if length == 0 then [ [$i, 1] ] |
|||
elif .[-1][0] == $i then setpath([-1,1]; .[-1][1] + 1) |
|||
if v > modeValue then |
|||
else . + [[$i,1]] |
|||
end ) |
|||
| sort_by( .[1] ); |
|||
# mode/0 outputs a stream of the modal values; |
|||
# if the input array is empty, the output stream is also empty. |
|||
def mode: |
|||
if length == 0 then empty |
|||
else modes as $modes |
|||
| $modes[-1][1] as $count |
|||
| $modes[] | select( .[1] == $count) | .[0] |
|||
end;</syntaxhighlight>Examples:<syntaxhighlight lang="jq"> |
|||
[1,2,3,1,2,1] | mode # => 1 |
|||
[1,2,3,1,2,1,2] | mode # => 1 2 |
|||
[1.1, 1.2, 1.3, 1.1, 1.2, 1.1] | mode) # => 1.1</syntaxhighlight> |
|||
=={{header|Julia}}== |
|||
<syntaxhighlight lang="julia">function modes(values) |
|||
dict = Dict() # Values => Number of repetitions |
|||
modesArray = typeof(values[1])[] # Array of the modes so far |
|||
max = 0 # Max of repetitions so far |
|||
for v in values |
|||
# Add one to the dict[v] entry (create one if none) |
|||
if v in keys(dict) |
|||
dict[v] += 1 |
|||
else |
else |
||
dict[v] = 1 |
|||
end |
|||
if type(mode) == 'table' then |
|||
table.insert(mode,i) |
|||
# Update modesArray if the number of repetitions |
|||
# of v reaches or surpasses the max value |
|||
if dict[v] >= max |
|||
if dict[v] > max |
|||
empty!(modesArray) |
|||
max += 1 |
|||
end |
end |
||
append!(modesArray, [v]) |
|||
end |
end |
||
end |
end |
||
return mode |
|||
return modesArray |
|||
end |
end |
||
println(modes([1,3,6,6,6,6,7,7,12,12,17])) |
|||
println(modes((1,1,2,4,4)))</syntaxhighlight> |
|||
print(result) |
|||
result = mode({1, 1, 2, 4, 4}) |
|||
=={{header|K}}== |
|||
if type(result) == 'table' then |
|||
<syntaxhighlight lang="k"> mode: {(?x)@&n=|/n:#:'=x} |
|||
for i,v in next,result do io.write(v..' ') end |
|||
mode 1 1 1 1 2 2 2 3 3 3 3 4 4 3 2 4 4 4 |
|||
print () |
|||
3 4</syntaxhighlight> |
|||
end</lang> |
|||
=={{header|Kotlin}}== |
|||
<syntaxhighlight lang="scala">fun <T> modeOf(a: Array<T>) { |
|||
val sortedByFreq = a.groupBy { it }.entries.sortedByDescending { it.value.size } |
|||
val maxFreq = sortedByFreq.first().value.size |
|||
val modes = sortedByFreq.takeWhile { it.value.size == maxFreq } |
|||
if (modes.size == 1) |
|||
println("The mode of the collection is ${modes.first().key} which has a frequency of $maxFreq") |
|||
else { |
|||
print("There are ${modes.size} modes with a frequency of $maxFreq, namely : ") |
|||
println(modes.map { it.key }.joinToString(", ")) |
|||
} |
|||
} |
|||
fun main(args: Array<String>) { |
|||
val a = arrayOf(7, 1, 1, 6, 2, 4, 2, 4, 2, 1, 5) |
|||
println("[" + a.joinToString(", ") + "]") |
|||
modeOf(a) |
|||
println() |
|||
val b = arrayOf(true, false, true, false, true, true) |
|||
println("[" + b.joinToString(", ") + "]") |
|||
modeOf(b) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[7, 1, 1, 6, 2, 4, 2, 4, 2, 1, 5] |
|||
There are 2 modes with a frequency of 3, namely : 1, 2 |
|||
[true, false, true, false, true, true] |
|||
The mode of the collection is true which has a frequency of 4 |
|||
</pre> |
|||
=={{header|Lasso}}== |
|||
<syntaxhighlight lang="lasso">define getmode(a::array)::array => { |
|||
local(mmap = map, maxv = 0, modes = array) |
|||
// store counts |
|||
with e in #a do => { #mmap->keys >> #e ? #mmap->find(#e) += 1 | #mmap->insert(#e = 1) } |
|||
// get max value |
|||
with e in #mmap->keys do => { #mmap->find(#e) > #maxv ? #maxv = #mmap->find(#e) } |
|||
// get modes with max value |
|||
with e in #mmap->keys where #mmap->find(#e) == #maxv do => { #modes->insert(#e) } |
|||
return #modes |
|||
} |
|||
getmode(array(1,3,6,6,6,6,7,7,12,12,17)) |
|||
getmode(array(1,3,6,3,4,8,9,1,2,3,2,2))</syntaxhighlight> |
|||
{{out}} |
|||
<pre>array(6) |
|||
array(2, 3)</pre> |
|||
=={{header|Liberty BASIC}}== |
|||
Using string of integers instead collection. |
|||
<syntaxhighlight lang="lb"> |
|||
a$ = "1 3 6 6 6 6 7 7 12 12 17" |
|||
b$ = "1 2 4 4 1" |
|||
print "Modes for ";a$ |
|||
print modes$(a$) |
|||
print "Modes for ";b$ |
|||
print modes$(b$) |
|||
function modes$(a$) |
|||
'get array size |
|||
n=0 |
|||
t$ = "*" |
|||
while t$<>"" |
|||
n=n+1 |
|||
t$=word$(a$, n) |
|||
'print n, t$ |
|||
wend |
|||
n=n-1 |
|||
'print "n=", n |
|||
'dim array |
|||
'read in array |
|||
redim a(n) |
|||
for i = 1 to n |
|||
a(i)=val(word$(a$, i)) |
|||
'print i, a(i) |
|||
next |
|||
'sort |
|||
sort a(), 1, n |
|||
'get the modes |
|||
occurence = 1 |
|||
maxOccurence = 0 |
|||
oldVal = a(1) |
|||
modes$ = "" |
|||
for i = 2 to n |
|||
'print i, a(i) |
|||
if a(i) = oldVal then |
|||
occurence = occurence + 1 |
|||
else |
|||
select case |
|||
case occurence > maxOccurence |
|||
maxOccurence = occurence |
|||
modes$ = oldVal; " " |
|||
case occurence = maxOccurence |
|||
modes$ = modes$; oldVal; " " |
|||
end select |
|||
occurence = 1 |
|||
end if |
|||
oldVal = a(i) |
|||
next |
|||
'check after loop |
|||
select case |
|||
case occurence > maxOccurence |
|||
maxOccurence = occurence |
|||
modes$ = oldVal; " " |
|||
case occurence = maxOccurence |
|||
modes$ = modes$; oldVal; " " |
|||
end select |
|||
end function </syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Modes for 1 3 6 6 6 6 7 7 12 12 17 |
|||
6 |
|||
Modes for 1 2 4 4 1 |
|||
1 4 |
|||
</pre> |
|||
=={{header|Lua}}== |
|||
<syntaxhighlight lang="lua">function mode(tbl) -- returns table of modes and count |
|||
assert(type(tbl) == 'table') |
|||
local counts = { } |
|||
for _, val in pairs(tbl) do |
|||
-- see http://lua-users.org/wiki/TernaryOperator |
|||
counts[val] = counts[val] and counts[val] + 1 or 1 |
|||
end |
|||
local modes = { } |
|||
local modeCount = 0 |
|||
for key, val in pairs(counts) do |
|||
if val > modeCount then |
|||
modeCount = val |
|||
modes = {key} |
|||
elseif val == modeCount then |
|||
table.insert(modes, key) |
|||
end |
|||
end |
|||
return modes, modeCount |
|||
end |
|||
modes, count = mode({1,3,6,6,6,6,7,7,12,12,17}) |
|||
for _, val in pairs(modes) do io.write(val..' ') end |
|||
print("occur(s) ", count, " times") |
|||
modes, count = mode({'a', 'a', 'b', 'd', 'd'}) |
|||
for _, val in pairs(modes) do io.write(val..' ') end |
|||
print("occur(s) ", count, " times") |
|||
</syntaxhighlight> |
|||
=={{header|M2000 Interpreter}}== |
|||
We use Inventory with keys as numbers (internal are strings). Inventories work with hash function. So searching is very fast. |
|||
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). |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module Checkit { |
|||
\\ find mode |
|||
Function GetMode { |
|||
Inventory N |
|||
Inventory ALLMODES |
|||
m=1 |
|||
While not empty { |
|||
if islet then { |
|||
Read A$ |
|||
if Exist(N, A$) then { |
|||
k=Eval(N) |
|||
k++ |
|||
if m=k then { |
|||
Append ALLMODES, A$ |
|||
} |
|||
if m<k then m=k : Clear ALLMODES : Append ALLMODES, A$ |
|||
return N, A$:=k |
|||
} Else Append N, A$:=1 : if m=1 then Append ALLMODES, A$ |
|||
} else { |
|||
Read A |
|||
if Exist(N, A) then { |
|||
k=Eval(N) |
|||
k++ |
|||
if m=k then { |
|||
Append ALLMODES, A |
|||
} |
|||
if m<k then m=k : Clear ALLMODES : Append ALLMODES, A |
|||
return N, A:=k |
|||
} Else Append N, A:=1 : if m=1 then Append ALLMODES, A |
|||
} |
|||
} |
|||
=ALLMODES |
|||
} |
|||
Print GetMode(1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6) ' print 2 3 |
|||
Dim A() |
|||
A()=(1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6) |
|||
\\ get a pointer from A |
|||
m=A() |
|||
Print GetMode(!m) ' print 2 3 |
|||
z=stack:=1, 2,"B", 3, 1, 2, "B", 4, 2, 5,"B", 2, 3, 3, 1, 3, 6, "B" |
|||
Print GetMode(!z) ' print 2 3 B |
|||
} |
|||
Checkit |
|||
</syntaxhighlight> |
|||
Using idea from BBC BASIC. Function GetMode return array. As Array get bigger function run slower exponential. Previous example using inventory, has linear response (double data, double time to run). Eacb function has a mew stack of value. This one line function Def AllStack()=[] get all arguments and place them in a stack object, and a pointer to stack returned. This function return an array: Def AllArray=Array([]). We can use (,) for empty array, (1,) for one item array, (1,2,3) for three item. We can use ((1,2),(3,4)) for an array with two arrays as items. We can use Stack for empty stack, or Stack:=1,2,3 for a stack with 3 items. Stacks are linked lists. A=Stack : Stack A { push 1,2,3 } : Print A ' print 3 2 1 where 3 is the top. Stack A (Data 0} : Print A ' print 3 2 1 0 (data push to bottom to stack). Functions and Modules always have a "current stack". So M2000 is like basic but is a stack oriented language, but for expressions use infix notation. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module Checkit { |
|||
Function GetMode(&a()){ |
|||
Local max% |
|||
if len(a())=0 then =(,) |
|||
link a() to a$() |
|||
n%=len(a()) |
|||
dim c%(n%) |
|||
if type$(a(0))="String" then { |
|||
For i%=0 to n%-2 |
|||
For j%=i%+1 to n%-1 |
|||
if order(a$(i%), a$(j%))=0 then c%(i%)++ |
|||
Next j% |
|||
If c%(i%)>max% Then max%=c%(i%) |
|||
Next i% |
|||
For i%=0 to n%-1 |
|||
If c%(i%) = max% Then Data a$(i%) |
|||
Next i% |
|||
} Else { |
|||
For i%=0 to n%-2 |
|||
For j%=i%+1 to n%-1 |
|||
if a(i%)==a(j%) then c%(i%)++ |
|||
Next j% |
|||
If c%(i%)>max% Then max%=c%(i%) |
|||
Next i% |
|||
For i%=0 to n%-1 |
|||
If c%(i%) = max% Then Data a(i%) |
|||
Next i% |
|||
} |
|||
=Array([]) |
|||
} |
|||
Dim m() |
|||
m()=(2,3,43,234,234,3,324) |
|||
Print GetMode(&m()) ' 3 234 |
|||
k=(1,2,1,2,1,2,3) |
|||
n=GetMode(&k) |
|||
' iterate backward |
|||
i=each(n, -1, 1) |
|||
While i { |
|||
Print Array(i), |
|||
} |
|||
Print |
|||
k=("A","B","A","B", "B","C","D","A") |
|||
? GetMode(&k) ' A B |
|||
} |
|||
Checkit |
|||
</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
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: |
|||
<syntaxhighlight lang="maple">Statistics:-Mode([1, 2.1, 2.1, 3]); |
|||
Statistics:-Mode([1, 2.1, 2.1, 3.2, 3.2, 5]);</syntaxhighlight> |
|||
{{out}} |
|||
<pre> 2.1 |
|||
{2.1, 3.2} |
|||
</pre> |
|||
=={{header|Mathematica}}== |
=={{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: |
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: |
||
<syntaxhighlight lang="mathematica"> Commonest[{b, a, c, 2, a, b, 1, 2, 3}] |
|||
<lang Mathematica> |
|||
Commonest[{ |
Commonest[{1, 3, 2, 3}]</syntaxhighlight> |
||
{{out}} |
|||
Commonest[{1, 3, 2, 3}] |
|||
<pre> {b,a,2} |
|||
</lang> |
|||
{3}</pre> |
|||
gives back: |
|||
<lang Mathematica> |
|||
{b,a,2} |
|||
{3} |
|||
</lang> |
|||
=={{header|MATLAB}}== |
=={{header|MATLAB}}== |
||
< |
<syntaxhighlight lang="matlab">function modeValue = findmode(setOfValues) |
||
modeValue = mode(setOfValues); |
modeValue = mode(setOfValues); |
||
end</ |
end</syntaxhighlight> |
||
=={{header|MUMPS}}== |
|||
<syntaxhighlight lang="mumps">MODE(X) |
|||
;X is assumed to be a list of numbers separated by "^" |
|||
;I is a loop index |
|||
;L is the length of X |
|||
;Y is a new array |
|||
;ML is the list of modes |
|||
;LOC is a placeholder to shorten the statement |
|||
Q:'$DATA(X) "No data" |
|||
Q:X="" "Empty Set" |
|||
NEW Y,I,L,LOC |
|||
SET L=$LENGTH(X,"^"),ML="" |
|||
FOR I=1:1:L SET LOC=+$P(X,"^",I),Y(LOC)=$S($DATA(Y(LOC)):Y(LOC)+1,1:1) |
|||
SET I="",I=$O(Y(I)),ML=I ;Prime the pump, rather than test for no data |
|||
FOR S I=$O(Y(I)) Q:I="" S ML=$SELECT(Y($P(ML,"^"))>Y(I):ML,Y($P(ML,"^"))<Y(I):I,Y($P(ML,"^"))=Y(I):ML_"^"_I) |
|||
QUIT ML</syntaxhighlight> |
|||
<pre>USER>W $$MODE^ROSETTA("1^2^3^2") |
|||
2 |
|||
USER>W $$MODE^ROSETTA("1^2^3^2^3") |
|||
2^3 |
|||
USER>W $$MODE^ROSETTA("") |
|||
Empty Set</pre> |
|||
=={{header|NetRexx}}== |
|||
<syntaxhighlight lang="netrexx">/* NetRexx */ |
|||
options replace format comments java crossref symbols nobinary |
|||
run_samples() |
|||
return |
|||
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
method mode(lvector = java.util.List) public static returns java.util.List |
|||
seen = 0 |
|||
modes = '' |
|||
modeMax = 0 |
|||
loop v_ = 0 to lvector.size() - 1 |
|||
mv = Rexx lvector.get(v_) |
|||
seen[mv] = seen[mv] + 1 |
|||
select |
|||
when seen[mv] > modeMax then do |
|||
modeMax = seen[mv] |
|||
modes = '' |
|||
nx = 1 |
|||
modes[0] = nx |
|||
modes[nx] = mv |
|||
end |
|||
when seen[mv] = modeMax then do |
|||
nx = modes[0] + 1 |
|||
modes[0] = nx |
|||
modes[nx] = mv |
|||
end |
|||
otherwise do |
|||
nop |
|||
end |
|||
end |
|||
end v_ |
|||
modeList = ArrayList(modes[0]) |
|||
loop v_ = 1 to modes[0] |
|||
val = modes[v_] |
|||
modeList.add(val) |
|||
end v_ |
|||
return modeList |
|||
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
method mode(rvector = Rexx[]) public static returns java.util.List |
|||
return mode(ArrayList(Arrays.asList(rvector))) |
|||
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
method show_mode(lvector = java.util.List) public static returns java.util.List |
|||
modes = mode(lvector) |
|||
say 'Vector:' (Rexx lvector).space(0)', Mode(s):' (Rexx modes).space(0) |
|||
return modes |
|||
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
method show_mode(rvector = Rexx[]) public static returns java.util.List |
|||
return show_mode(ArrayList(Arrays.asList(rvector))) |
|||
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
method run_samples() public static |
|||
show_mode([Rexx 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) -- 10 9 8 7 6 5 4 3 2 1 |
|||
show_mode([Rexx 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0.11]) -- 0 |
|||
show_mode([Rexx 30, 10, 20, 30, 40, 50, -100, 4.7, -11e+2]) -- 30 |
|||
show_mode([Rexx 30, 10, 20, 30, 40, 50, -100, 4.7, -11e+2, -11e+2]) -- 30 -11e2 |
|||
show_mode([Rexx 1, 8, 6, 0, 1, 9, 4, 6, 1, 9, 9, 9]) -- 9 |
|||
show_mode([Rexx 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) -- 1 2 3 4 5 6 7 8 9 10 11 |
|||
show_mode([Rexx 8, 8, 8, 2, 2, 2]) -- 8 2 |
|||
show_mode([Rexx 'cat', 'kat', 'Cat', 'emu', 'emu', 'Kat']) -- emu |
|||
show_mode([Rexx 0, 1, 2, 3, 3, 3, 4, 4, 4, 4, 1, 0]) -- 4 |
|||
show_mode([Rexx 2, 7, 1, 8, 2]) -- 2 |
|||
show_mode([Rexx 2, 7, 1, 8, 2, 8]) -- 8 2 |
|||
show_mode([Rexx 'E', 'n', 'z', 'y', 'k', 'l', 'o', 'p', 'ä', 'd', 'i', 'e']) -- E n z y k l o p ä d i e |
|||
show_mode([Rexx 'E', 'n', 'z', 'y', 'k', 'l', 'o', 'p', 'ä', 'd', 'i', 'e', 'ä']) -- ä |
|||
show_mode([Rexx 3, 1, 4, 1, 5, 9, 7, 6]) -- 1 |
|||
show_mode([Rexx 3, 1, 4, 1, 5, 9, 7, 6, 3]) -- 3, 1 |
|||
show_mode([Rexx 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]) -- 6 |
|||
show_mode([Rexx 1, 1, 2, 4, 4]) -- 4 1 |
|||
return |
|||
</syntaxhighlight> |
|||
'''Output:''' |
|||
<pre> |
|||
Vector: [10,9,8,7,6,5,4,3,2,1], Mode(s): [10,9,8,7,6,5,4,3,2,1] |
|||
Vector: [10,9,8,7,6,5,4,3,2,1,0,0,0,0,0.11], Mode(s): [0] |
|||
Vector: [30,10,20,30,40,50,-100,4.7,-1100], Mode(s): [30] |
|||
Vector: [30,10,20,30,40,50,-100,4.7,-1100,-1100], Mode(s): [30,-1100] |
|||
Vector: [1,8,6,0,1,9,4,6,1,9,9,9], Mode(s): [9] |
|||
Vector: [1,2,3,4,5,6,7,8,9,10,11], Mode(s): [1,2,3,4,5,6,7,8,9,10,11] |
|||
Vector: [8,8,8,2,2,2], Mode(s): [8,2] |
|||
Vector: [cat,kat,Cat,emu,emu,Kat], Mode(s): [emu] |
|||
Vector: [0,1,2,3,3,3,4,4,4,4,1,0], Mode(s): [4] |
|||
Vector: [2,7,1,8,2], Mode(s): [2] |
|||
Vector: [2,7,1,8,2,8], Mode(s): [2,8] |
|||
Vector: [E,n,z,y,k,l,o,p,ä,d,i,e], Mode(s): [E,n,z,y,k,l,o,p,ä,d,i,e] |
|||
Vector: [E,n,z,y,k,l,o,p,ä,d,i,e,ä], Mode(s): [ä] |
|||
Vector: [3,1,4,1,5,9,7,6], Mode(s): [1] |
|||
Vector: [3,1,4,1,5,9,7,6,3], Mode(s): [1,3] |
|||
Vector: [1,3,6,6,6,6,7,7,12,12,17], Mode(s): [6] |
|||
Vector: [1,1,2,4,4], Mode(s): [1,4] |
|||
</pre> |
|||
=={{header|Nim}}== |
|||
<syntaxhighlight lang="nim">import tables |
|||
proc modes[T](xs: openArray[T]): T = |
|||
var count = initCountTable[T]() |
|||
for x in xs: |
|||
count.inc(x) |
|||
largest(count).key |
|||
echo modes(@[1,3,6,6,6,6,7,7,12,12,17]) |
|||
echo modes(@[1,1,2,4,4])</syntaxhighlight> |
|||
Output: |
|||
<pre>6 |
|||
1</pre> |
|||
=={{header|Oberon-2}}== |
|||
{{Works with|oo2c version2}} |
|||
<syntaxhighlight lang="oberon2"> |
|||
MODULE Mode; |
|||
IMPORT |
|||
Object:Boxed, |
|||
ADT:Dictionary, |
|||
ADT:LinkedList, |
|||
Out := NPCT:Console; |
|||
TYPE |
|||
Key = Boxed.LongInt; |
|||
Val = Boxed.LongInt; |
|||
VAR |
|||
x: ARRAY 11 OF LONGINT; |
|||
y: ARRAY 5 OF LONGINT; |
|||
z: ARRAY 8 OF LONGINT; |
|||
PROCEDURE Show(ll: LinkedList.LinkedList(Key)); |
|||
VAR |
|||
iter: LinkedList.Iterator(Key); |
|||
i: LONGINT; |
|||
k: Key; |
|||
BEGIN |
|||
iter := ll.GetIterator(NIL); |
|||
FOR i := 0 TO ll.Size() - 1 DO; |
|||
k := iter.Next(); |
|||
Out.Int(k.value,0);Out.Ln; |
|||
END; |
|||
END Show; |
|||
PROCEDURE Mode(x: ARRAY OF LONGINT): LinkedList.LinkedList(Key); |
|||
VAR |
|||
d: Dictionary.Dictionary(Key,Val); |
|||
i: LONGINT; |
|||
k: Key; v: Val; |
|||
iter: Dictionary.IterKeys(Key,Val); |
|||
resp: LinkedList.LinkedList(Key); |
|||
max: Boxed.LongInt; |
|||
BEGIN |
|||
d := NEW(Dictionary.Dictionary(Key,Val)); |
|||
FOR i := 0 TO LEN(x) - 1 DO |
|||
k := NEW(Key,x[i]); |
|||
IF d.Lookup(k,v) THEN |
|||
d.Set(k,NEW(Val,v.value + 1)); |
|||
ELSE |
|||
d.Set(k,NEW(Val,1)) |
|||
END |
|||
END; |
|||
max := NEW(Boxed.LongInt,0); |
|||
resp := NEW(LinkedList.LinkedList(Key)); |
|||
iter := d.IterKeys(); |
|||
WHILE (iter.Next(k)) DO |
|||
v := d.Get(k); |
|||
IF v.Cmp(max) > 0 THEN |
|||
resp.Clear(); |
|||
resp.Append(k);max := v |
|||
ELSIF v.Cmp(max) = 0 THEN |
|||
resp.Append(k);max := v |
|||
END |
|||
END; |
|||
RETURN resp |
|||
END Mode; |
|||
BEGIN |
|||
x[0] := 1; x[1] := 3; x[2] := 6; x[3] := 6; |
|||
x[4] := 6; x[5] := 6; x[6] := 7; x[7] := 7; |
|||
x[8] := 12; x[9] := 12; x[10] := 17; |
|||
Show(Mode(x));Out.Ln; |
|||
y[0] := 1; y[1] := 2; y[2] := 4; y[3] := 4; y[4] := 1; |
|||
Show(Mode(y));Out.Ln; |
|||
z[0] := 1; z[1] := 2; z[2] := 4; z[3] := 4; z[4] := 1; z[5] := 5; z[6] := 5; z[7] := 5; |
|||
Show(Mode(z));Out.Ln; |
|||
END Mode. |
|||
</syntaxhighlight> |
|||
{{out} |
|||
<pre> |
|||
6 |
|||
4 |
|||
1 |
|||
5 |
|||
</pre> |
|||
=={{header|Objeck}}== |
|||
<syntaxhighlight lang="objeck"> |
|||
use Collection; |
|||
class Mode { |
|||
function : Main(args : String[]) ~ Nil { |
|||
Print(Mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])); |
|||
Print(Mode([1, 2, 4, 4, 1])); |
|||
} |
|||
function : Mode(coll : Int[]) ~ IntVector { |
|||
seen := IntMap->New(); |
|||
max := 0; |
|||
maxElems := IntVector->New(); |
|||
each(i : coll) { |
|||
value := coll[i]; |
|||
featched := seen->Find(value)->As(IntHolder); |
|||
if(featched <> Nil) { |
|||
seen->Remove(value); |
|||
seen->Insert(value, IntHolder->New(featched->Get() + 1)); |
|||
} |
|||
else { |
|||
seen->Insert(value, IntHolder->New(1)); |
|||
}; |
|||
featched := seen->Find(value)->As(IntHolder); |
|||
if(featched->Get() > max) { |
|||
max := featched->Get(); |
|||
maxElems->Empty(); |
|||
maxElems->AddBack(value); |
|||
} |
|||
else if(featched->Get() = max) { |
|||
maxElems->AddBack(value); |
|||
}; |
|||
}; |
|||
return maxElems; |
|||
} |
|||
function : Print(out : IntVector) ~ Nil { |
|||
'['->Print(); |
|||
each(i : out) { |
|||
out->Get(i)->Print(); |
|||
if(i + 1 < out->Size()) { |
|||
", "->Print(); |
|||
}; |
|||
}; |
|||
']'->PrintLine(); |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Objective-C}}== |
=={{header|Objective-C}}== |
||
< |
<syntaxhighlight lang="objc">#import <Foundation/Foundation.h> |
||
@interface NSArray (Mode) |
@interface NSArray (Mode) |
||
Line 778: | Line 2,510: | ||
int max = 0; |
int max = 0; |
||
NSMutableArray *maxElems = [NSMutableArray array]; |
NSMutableArray *maxElems = [NSMutableArray array]; |
||
for ( obj in seen ) { |
|||
id obj; |
|||
while( (obj = [enm nextObject]) ) { |
|||
int count = [seen countForObject:obj]; |
int count = [seen countForObject:obj]; |
||
if (count > max) { |
if (count > max) { |
||
Line 792: | Line 2,522: | ||
return maxElems; |
return maxElems; |
||
} |
} |
||
@end</ |
@end</syntaxhighlight> |
||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
< |
<syntaxhighlight lang="ocaml">let mode lst = |
||
let seen = Hashtbl.create 42 in |
let seen = Hashtbl.create 42 in |
||
List.iter (fun x -> |
List.iter (fun x -> |
||
Line 807: | Line 2,537: | ||
if v = best then k :: acc |
if v = best then k :: acc |
||
else acc) |
else acc) |
||
seen []</ |
seen []</syntaxhighlight> |
||
# mode [1;3;6;6;6;6;7;7;12;12;17];; |
# mode [1;3;6;6;6;6;7;7;12;12;17];; |
||
- : int list = [6] |
- : int list = [6] |
||
Line 816: | Line 2,545: | ||
=={{header|Octave}}== |
=={{header|Octave}}== |
||
Of course Octave has the <tt>mode</tt> function; but it returns only the "lowest" mode if multiple modes are available. |
Of course Octave has the <tt>mode</tt> function; but it returns only the "lowest" mode if multiple modes are available. |
||
<syntaxhighlight lang="octave">function m = mode2(v) |
|||
<lang octave>function m = mode2(v) |
|||
sv = sort(v); |
sv = sort(v); |
||
% build two vectors, vals and c, so that |
% build two vectors, vals and c, so that |
||
Line 845: | Line 2,573: | ||
i++; |
i++; |
||
endwhile |
endwhile |
||
endfunction</ |
endfunction</syntaxhighlight> |
||
<syntaxhighlight lang="octave">a = [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]; |
|||
<lang octave>a = [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]; |
|||
mode2(a) |
mode2(a) |
||
mode(a) |
mode(a) |
||
Line 853: | Line 2,580: | ||
a = [1, 1, 2, 4, 4]; |
a = [1, 1, 2, 4, 4]; |
||
mode2(a) % returns 1 and 4 |
mode2(a) % returns 1 and 4 |
||
mode(a) % returns 1 only</ |
mode(a) % returns 1 only</syntaxhighlight> |
||
=={{header|ooRexx}}== |
|||
See the example at [[#Version_2|REXX, Version 2]] for a version that returns multiple mode values. |
|||
<syntaxhighlight lang="oorexx"> |
|||
-- will work with just about any collection... |
|||
call testMode .array~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1) |
|||
call testMode .list~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11) |
|||
call testMode .queue~of(30, 10, 20, 30, 40, 50, -100, 4.7, -11e2) |
|||
::routine testMode |
|||
use arg list |
|||
say "list =" list~makearray~toString("l", ", ") |
|||
say "mode =" mode(list) |
|||
say |
|||
::routine mode |
|||
use arg list |
|||
-- this is a good application for a bag |
|||
-- add all of the items to the bag |
|||
collector = .bag~new |
|||
collector~putAll(list) |
|||
-- now get a list of unique items |
|||
indexes = .set~new~~putall(collector) |
|||
count = 0 -- this is used to keep track of the maximums |
|||
-- now see how many of each element we ended up with |
|||
loop index over indexes |
|||
items = collector~allat(index) |
|||
newCount = items~items |
|||
if newCount > count then do |
|||
mode = items[1] |
|||
count = newCount |
|||
end |
|||
end |
|||
return mode |
|||
</syntaxhighlight> |
|||
=={{header|Oz}}== |
=={{header|Oz}}== |
||
< |
<syntaxhighlight lang="oz">declare |
||
fun {Mode Xs} |
fun {Mode Xs} |
||
Freq = {Dictionary.new} |
Freq = {Dictionary.new} |
||
Line 872: | Line 2,636: | ||
in |
in |
||
{Show {Mode [1 2 3 3 2 1 1]}} |
{Show {Mode [1 2 3 3 2 1 1]}} |
||
{Show {Mode [1 2 3 3 2 1]}}</ |
{Show {Mode [1 2 3 3 2 1]}}</syntaxhighlight> |
||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
<lang>mode(v)={ |
<syntaxhighlight lang="parigp">mode(v)={ |
||
my(count=1,r=1,b=v[1]); |
my(count=1,r=1,b=v[1]); |
||
v=vecsort(v); |
v=vecsort(v); |
||
Line 890: | Line 2,654: | ||
); |
); |
||
if(count>r,v[#v],b) |
if(count>r,v[#v],b) |
||
};</ |
};</syntaxhighlight> |
||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">use strict; |
||
use List::Util qw(max); |
use List::Util qw(max); |
||
Line 904: | Line 2,668: | ||
my $best = max(values %c); |
my $best = max(values %c); |
||
return grep { $c{$_} == $best } keys %c; |
return grep { $c{$_} == $best } keys %c; |
||
}</ |
}</syntaxhighlight> |
||
< |
<syntaxhighlight lang="perl">print "$_ " foreach mode(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17); |
||
print "\n"; |
print "\n"; |
||
print "$_ " foreach mode(1, 1, 2, 4, 4); |
print "$_ " foreach mode(1, 1, 2, 4, 4); |
||
print "\n";</ |
print "\n";</syntaxhighlight> |
||
=={{header| |
=={{header|Phix}}== |
||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
{{works with|Rakudo|#22 "Thousand Oaks"}} |
|||
<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> |
|||
<lang perl6>sub mode (@a) { |
|||
<span style="color: #004080;">integer</span> <span style="color: #000000;">nxt</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">maxc</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span> |
|||
my %counts; |
|||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span> |
|||
++%counts{$_} for @a; |
|||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> |
|||
my $max = [max] values %counts; |
|||
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> |
|||
return map { .key }, grep { .value == $max }, %counts.pairs; |
|||
<span style="color: #004080;">object</span> <span style="color: #000000;">prev</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> |
|||
}</lang> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]!=</span><span style="color: #000000;">prev</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">nxt</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #000000;">prev</span><span style="color: #0000FF;">}</span> |
|||
<span style="color: #000000;">nxt</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span> |
|||
<span style="color: #000000;">prev</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> |
|||
<span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span> |
|||
<span style="color: #008080;">else</span> |
|||
<span style="color: #000000;">count</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">></span><span style="color: #000000;">maxc</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #000000;">maxc</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">count</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">nxt</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #000000;">prev</span><span style="color: #0000FF;">}</span> |
|||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">nxt</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">][</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]=</span><span style="color: #000000;">maxc</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">][</span><span style="color: #000000;">2</span><span style="color: #0000FF;">])</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</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> |
|||
<span style="color: #0000FF;">?</span><span style="color: #000000;">mode</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">9.5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3.14159</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #0000FF;">?</span><span style="color: #000000;">mode</span><span style="color: #0000FF;">({</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"blue"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">7.5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"green"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"red"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"blue"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"white"</span> <span style="color: #0000FF;">})</span> |
|||
<span style="color: #0000FF;">?</span><span style="color: #000000;">mode</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">6</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #0000FF;">?</span><span style="color: #000000;">mode</span><span style="color: #0000FF;">({.</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">.</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">.</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">.</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">.</span><span style="color: #000000;">2</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #0000FF;">?</span><span style="color: #000000;">mode</span><span style="color: #0000FF;">({</span><span style="color: #008000;">"two"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">8</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"two"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">8</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #0000FF;">?</span><span style="color: #000000;">mode</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Hello there world"</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #0000FF;">?</span><span style="color: #000000;">mode</span><span style="color: #0000FF;">({})</span> |
|||
<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
<pre> |
|||
{-9.5,-5,1,2,3.14159,5} |
|||
{2,5,"blue"} |
|||
{2,3} |
|||
{0.2} |
|||
{8,"two"} |
|||
"el" |
|||
{} |
|||
</pre> |
|||
=={{header|PHP}}== |
=={{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. |
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. |
||
< |
<syntaxhighlight lang="php"><?php |
||
function mode($arr) { |
function mode($arr) { |
||
$count = array_count_values($arr); |
$count = array_count_values($arr); |
||
Line 932: | Line 2,739: | ||
print_r(mode(array(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17))); |
print_r(mode(array(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17))); |
||
print_r(mode(array(1, 1, 2, 4, 4))); |
print_r(mode(array(1, 1, 2, 4, 4))); |
||
?></ |
?></syntaxhighlight> |
||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">(de modes (Lst) |
||
(let A NIL |
(let A NIL |
||
(for X Lst |
(for X Lst |
||
(accu 'A X 1) ) |
(accu 'A X 1) ) |
||
( |
(mapcar car |
||
( |
(maxi cdar |
||
(by cdr group A) ) ) ) )</syntaxhighlight> |
|||
{{out}} |
|||
A ) ) ) )</lang> |
|||
Output: |
|||
<pre>: (modes (1 3 6 6 6 6 7 7 12 12 17)) |
<pre>: (modes (1 3 6 6 6 6 7 7 12 12 17)) |
||
-> (6) |
-> (6) |
||
Line 951: | Line 2,757: | ||
: (modes (chop "ABRAHAMASANTACLARA")) |
: (modes (chop "ABRAHAMASANTACLARA")) |
||
-> ("A") |
-> ("A") |
||
: (modes (1 4 A 3 2 7 1 B B 3 6 2 4 C C 5 2 5 B A 3 2 C 3 5 5 4 C 7 7)) |
|||
-> (5 C 2 3)</pre> |
|||
=={{header|PL/I}}== |
|||
<syntaxhighlight lang="pl/i">av: procedure options (main); /* 28 October 2013 */ |
|||
declare x(10) fixed binary static initial (1, 4, 2, 6, 2, 5, 6, 2, 4, 2); |
|||
declare f(32767) fixed binary; |
|||
declare (j, n, max, value) fixed binary; |
|||
declare i fixed; |
|||
n = hbound(x,1); |
|||
do i = 1 to n; |
|||
j = x(i); |
|||
f(j) = f(j) + 1; |
|||
end; |
|||
max = 0; |
|||
do i = 1 to hbound(f,1); |
|||
if max < f(i) then do; max = f(i); value = i; end; |
|||
end; |
|||
put list ('The mode value is ' || value || ' occurred ' || |
|||
max || ' times.'); |
|||
end av;</syntaxhighlight> |
|||
Results: |
|||
<pre> |
|||
The mode value is 2 occurred 4 times. |
|||
</pre> |
|||
=={{header|PowerShell}}== |
|||
<syntaxhighlight lang="powershell">$data = @(1,1,1,2,3,4,5,5,6,7,7,7) |
|||
$groups = $data | group-object | sort-object count -Descending |
|||
$groups | ? {$_.Count -eq $groups[0].Count}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Count Name Group |
|||
----- ---- ----- |
|||
3 7 {7, 7, 7} |
|||
3 1 {1, 1, 1}</pre> |
|||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
< |
<syntaxhighlight lang="purebasic">Procedure mean(Array InArray(1)) |
||
Structure MyMean |
Structure MyMean |
||
Line 991: | Line 2,836: | ||
EndIf |
EndIf |
||
Next |
Next |
||
EndProcedure</ |
EndProcedure</syntaxhighlight> |
||
=={{header|Python}}== |
=={{header|Python}}== |
||
The following solutions require that the elements be ''hashable''. |
The following solutions require that the elements be ''hashable''. |
||
{{works with|Python|2.5 |
{{works with|Python|2.5+ and 3.x}} |
||
< |
<syntaxhighlight lang="python">>>> from collections import defaultdict |
||
>>> def modes(values): |
>>> def modes(values): |
||
count = defaultdict(int) |
count = defaultdict(int) |
||
Line 1,007: | Line 2,852: | ||
[6] |
[6] |
||
>>> modes((1,1,2,4,4)) |
>>> modes((1,1,2,4,4)) |
||
[1, 4]</ |
[1, 4]</syntaxhighlight> |
||
{{works with|Python|2.7+ and 3.1+}} |
|||
<syntaxhighlight lang="python">>>> from collections import Counter |
|||
{{works with|Python|3.1}} |
|||
<lang python>>>> from collections import Counter |
|||
>>> def modes(values): |
>>> def modes(values): |
||
count = Counter(values) |
count = Counter(values) |
||
Line 1,019: | Line 2,863: | ||
[6] |
[6] |
||
>>> modes((1,1,2,4,4)) |
>>> modes((1,1,2,4,4)) |
||
[1, 4]</ |
[1, 4]</syntaxhighlight> |
||
If you just want one mode (instead of all of them), here's a one-liner for that: |
If you just want one mode (instead of all of them), here's a one-liner for that: |
||
< |
<syntaxhighlight lang="python">def onemode(values): |
||
return max(set(values), key=values.count)</ |
return max(set(values), key=values.count)</syntaxhighlight> |
||
=={{header|Q}}== |
|||
<syntaxhighlight lang="q">mode:{(key x) where value x=max x} count each group @</syntaxhighlight> |
|||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery"> [ sort |
|||
[] [] rot |
|||
dup 0 peek temp put |
|||
witheach |
|||
[ dup temp share = iff |
|||
join |
|||
else |
|||
[ dup temp replace |
|||
dip [ nested join ] |
|||
[] join ] ] |
|||
nested join |
|||
temp release ] is bunch ( [ --> [ ) |
|||
[ sortwith [ size dip size < ] |
|||
[] swap |
|||
dup 0 peek size temp put |
|||
witheach |
|||
[ dup size temp share = iff |
|||
[ nested join ] |
|||
else |
|||
[ drop conclude ] ] |
|||
temp release |
|||
[] swap |
|||
witheach |
|||
[ 0 peek join ] ] is largest ( [ --> [ ) |
|||
[ bunch largest ] is mode ( [ --> [ ) |
|||
' [ 1 3 5 7 3 1 3 7 7 3 3 ] mode echo cr |
|||
' [ 7 13 5 13 7 2 7 10 13 ] mode echo cr |
|||
' [ 5 ] mode echo cr</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[ 3 ] |
|||
[ 7 13 ] |
|||
[ 5 ] |
|||
</pre> |
|||
=={{header|R}}== |
=={{header|R}}== |
||
< |
<syntaxhighlight lang="r">statmode <- function(v) { |
||
a <- sort(table(v), decreasing=TRUE) |
a <- sort(table(v), decreasing=TRUE) |
||
r <- c() |
r <- c() |
||
Line 1,039: | Line 2,927: | ||
print(statmode(c(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17))) |
print(statmode(c(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17))) |
||
print(statmode(c(1, 1, 2, 4, 4)))</ |
print(statmode(c(1, 1, 2, 4, 4)))</syntaxhighlight> |
||
=={{header| |
=={{header|Racket}}== |
||
Returns values of list of modes and their frequencies of appearance. |
|||
<lang rexx> |
|||
<syntaxhighlight lang="racket">#lang racket |
|||
/*REXX program to find the mode of a vector. */ |
|||
(define (mode seq) |
|||
/*--------vector---------- ---show vector--- ----show result------ */ |
|||
(define frequencies (make-hash)) |
|||
(for ([s seq]) |
|||
(hash-update! frequencies |
|||
s |
|||
(lambda (freq) (add1 freq)) |
|||
0)) |
|||
(for/fold ([ms null] |
|||
[freq 0]) |
|||
([(k v) (in-hash frequencies)]) |
|||
(cond [(> v freq) |
|||
(values (list k) v)] |
|||
[(= v freq) |
|||
(values (cons k ms) freq)] |
|||
[else |
|||
(values ms freq)])))</syntaxhighlight> |
|||
=={{header|Raku}}== |
|||
v='1 8 6 0 1 9 4 6 1 9 9 9' ; say 'vector='v; say 'mode='mode(v); say |
|||
(formerly Perl 6) |
|||
v='1 2 3 4 5 6 7 8 9 10 11' ; say 'vector='v; say 'mode='mode(v); say |
|||
v='8 8 8 2 2 2' ; say 'vector='v; say 'mode='mode(v); say |
|||
v='cat kat Cat emu emu Kat' ; say 'vector='v; say 'mode='mode(v); say |
|||
{{works with|Rakudo|2019.03.1}} |
|||
exit |
|||
<syntaxhighlight lang="raku" line>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];</syntaxhighlight> |
|||
{{out}} |
|||
/*-------------------------------------MAKEARRAY subroutine-------------*/ |
|||
<pre> |
|||
makeArray: procedure expose @.; parse arg v; @.0=words(v) /*make array*/ |
|||
6 |
|||
do j=1 for @.0 |
|||
(4 1) |
|||
@.j=word(v,j) |
|||
</pre> |
|||
end |
|||
return |
|||
Alternatively, a version that uses a single method chain with no temporary variables: (Same output with same input) |
|||
<syntaxhighlight lang="raku" line>sub mode (*@a) { |
|||
/*-------------------------------------ESORT subroutine-----------------*/ |
|||
@a.Bag # count elements |
|||
.classify(*.value) # group elements with the same count |
|||
do while h>1; h=h%2 |
|||
.max(*.key) # get group with the highest count |
|||
do i=1 for @.0-h;j=i;k=h+i |
|||
.value.map(*.key); # get elements in the group |
|||
do while @.k<@.j;t=@.j;@.j=@.k;@.k=t;if h>=j then leave;j=j-h;k=k-h;end |
|||
} |
|||
end /*i*/ |
|||
end |
|||
return |
|||
say mode [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]; |
|||
/*-------------------------------------MODE subroutine------------------*/ |
|||
say mode [1, 1, 2, 4, 4];</syntaxhighlight> |
|||
mode: procedure expose @.; parse arg x /*find the MODE of a vector. */ |
|||
call makeArray x /*make an array out of the vector*/ |
|||
call esort @.0 /*sort the array elements. */ |
|||
?=@.1 /*assume 1st element is the mode.*/ |
|||
freq=1 /*the frequency of the occurance.*/ |
|||
=={{header|REXX}}== |
|||
do j=1 for @.0 |
|||
===version 1=== |
|||
_=j-freq |
|||
Returns one mode value. |
|||
if @.j==@._ then do |
|||
<syntaxhighlight lang="rexx">/*REXX program finds the mode (most occurring element) of a vector. */ |
|||
/* ════════vector═══════════ ═══show vector═══ ═════show result═════ */ |
|||
?=@.j /*this is the one. */ |
|||
v= 1 8 6 0 1 9 4 6 1 9 9 9 ; say 'vector='v; say 'mode='mode(v); say |
|||
v= 1 2 3 4 5 6 7 8 9 11 10 ; say 'vector='v; say 'mode='mode(v); say |
|||
end |
|||
v= 8 8 8 2 2 2 ; say 'vector='v; say 'mode='mode(v); say |
|||
v='cat kat Cat emu emu Kat' ; say 'vector='v; say 'mode='mode(v); say |
|||
return ? |
|||
exit /*stick a fork in it, we're all done. */ |
|||
</lang> |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
Output: |
|||
sort: procedure expose @.; parse arg # 1 h /* [↓] this is an exchange sort. */ |
|||
<pre style="height:30ex;overflow:scroll"> |
|||
do while h>1; h=h%2 /*In REXX, % is an integer divide.*/ |
|||
do i=1 for #-h; j=i; k=h+i /* [↓] perform exchange for elements. */ |
|||
do while @.k<@.j & h<j; _=@.j; @.j=@.k; @.k=_; j=j-h; k=k-h; end |
|||
end /*i*/ |
|||
end /*while h>1*/; return |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
mode: procedure expose @.; parse arg x; freq=1 /*function finds the MODE of a vector*/ |
|||
#=words(x) /*#: the number of elements in vector.*/ |
|||
do k=1 for #; @.k=word(x,k); end /* ◄──── make an array from the vector.*/ |
|||
call Sort # /*sort the elements in the array. */ |
|||
?=@.1 /*assume the first element is the mode.*/ |
|||
do j=1 for #; _=j-freq /*traipse through the elements in array*/ |
|||
if @.j==@._ then do; freq=freq+1 /*is this element the same as previous?*/ |
|||
?=@.j /*this element is the mode (···so far).*/ |
|||
end |
|||
end /*j*/ |
|||
return ? /*return the mode of vector to invoker.*/</syntaxhighlight> |
|||
'''output''' |
|||
<pre> |
|||
vector=1 8 6 0 1 9 4 6 1 9 9 9 |
vector=1 8 6 0 1 9 4 6 1 9 9 9 |
||
mode=9 |
mode=9 |
||
vector=1 2 3 4 5 6 7 8 9 |
vector=1 2 3 4 5 6 7 8 9 11 10 |
||
mode=1 |
mode=1 |
||
Line 1,103: | Line 3,024: | ||
vector=cat kat Cat emu emu Kat |
vector=cat kat Cat emu emu Kat |
||
mode=emu |
mode=emu |
||
</pre> |
|||
===version 2=== |
|||
{{trans|NetRexx}} |
|||
{{works with|ooRexx}} |
|||
{{works with|Regina}} |
|||
and should work for every REXX. |
|||
<syntaxhighlight lang="rexx">/* Rexx */ |
|||
/*-- ~~ main ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ |
|||
call run_samples |
|||
return |
|||
exit |
|||
/*-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ |
|||
/*-- returns a comma separated string of mode values from a comma separated input vector string */ |
|||
mode: |
|||
procedure |
|||
parse arg lvector |
|||
drop vector. |
|||
vector. = '' |
|||
call makeStem lvector /*-- this call creates the "vector." stem from the input string */ |
|||
seen. = 0 |
|||
modes. = '' |
|||
modeMax = 0 |
|||
do v_ = 1 to vector.0 |
|||
mv = vector.v_ |
|||
seen.mv = seen.mv + 1 |
|||
select |
|||
when seen.mv > modeMax then do |
|||
modeMax = seen.mv |
|||
drop modes. |
|||
modes. = '' |
|||
nx = 1 |
|||
modes.0 = nx |
|||
modes.nx = mv |
|||
end |
|||
when seen.mv = modeMax then do |
|||
nx = modes.0 + 1 |
|||
modes.0 = nx |
|||
modes.nx = mv |
|||
end |
|||
otherwise do |
|||
nop |
|||
end |
|||
end |
|||
end v_ |
|||
lmodes = '' |
|||
do e_ = 1 to modes.0 |
|||
lmodes = lmodes modes.e_ |
|||
end e_ |
|||
lmodes = strip(space(lmodes, 1, ',')) |
|||
return lmodes |
|||
/*-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ |
|||
/*-- pretty-print */ |
|||
show_mode: |
|||
procedure |
|||
parse arg lvector |
|||
lmodes = mode(lvector) |
|||
say 'Vector: ['space(lvector, 0)'], Mode(s): ['space(lmodes, 0)']' |
|||
return modes |
|||
/*-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ |
|||
/*-- load the "vector." stem from the comma separated input vector string */ |
|||
makeStem: |
|||
procedure expose vector. |
|||
vector.0 = 0 |
|||
parse arg lvector |
|||
do v_ = 1 while lvector \= '' |
|||
parse var lvector val ',' lvector |
|||
vector.0 = v_ |
|||
vector.v_ = strip(val) |
|||
vector = strip(lvector) |
|||
end v_ |
|||
return vector.0 |
|||
/*-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ |
|||
run_samples: |
|||
procedure |
|||
call show_mode '10, 9, 8, 7, 6, 5, 4, 3, 2, 1' -- 10 9 8 7 6 5 4 3 2 1 |
|||
call show_mode '10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0.11' -- 0 |
|||
call show_mode '30, 10, 20, 30, 40, 50, -100, 4.7, -11e+2' -- 30 |
|||
call show_mode '30, 10, 20, 30, 40, 50, -100, 4.7, -11e+2, -11e+2' -- 30 -11e2 |
|||
call show_mode '1, 8, 6, 0, 1, 9, 4, 6, 1, 9, 9, 9' -- 9 |
|||
call show_mode '1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11' -- 1 2 3 4 5 6 7 8 9 10 11 |
|||
call show_mode '8, 8, 8, 2, 2, 2' -- 8 2 |
|||
call show_mode 'cat, kat, Cat, emu, emu, Kat' -- emu |
|||
call show_mode '0, 1, 2, 3, 3, 3, 4, 4, 4, 4, 1, 0' -- 4 |
|||
call show_mode '2, 7, 1, 8, 2' -- 2 |
|||
call show_mode '2, 7, 1, 8, 2, 8' -- 8 2 |
|||
call show_mode 'E, n, z, y, k, l, o, p, ä, d, i, e' -- E n z y k l o p ä d i e |
|||
call show_mode 'E, n, z, y, k, l, o, p, ä, d, i, e, ä' -- ä |
|||
call show_mode '3, 1, 4, 1, 5, 9, 7, 6' -- 1 |
|||
call show_mode '3, 1, 4, 1, 5, 9, 7, 6, 3' -- 3, 1 |
|||
call show_mode '1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17' -- 6 |
|||
call show_mode '1, 1, 2, 4, 4' -- 4 1 |
|||
return</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Vector: [10,9,8,7,6,5,4,3,2,1], Mode(s): [10,9,8,7,6,5,4,3,2,1] |
|||
Vector: [10,9,8,7,6,5,4,3,2,1,0,0,0,0,0.11], Mode(s): [0] |
|||
Vector: [30,10,20,30,40,50,-100,4.7,-11e+2], Mode(s): [30] |
|||
Vector: [30,10,20,30,40,50,-100,4.7,-11e+2,-11e+2], Mode(s): [30,-11e+2] |
|||
Vector: [1,8,6,0,1,9,4,6,1,9,9,9], Mode(s): [9] |
|||
Vector: [1,2,3,4,5,6,7,8,9,10,11], Mode(s): [1,2,3,4,5,6,7,8,9,10,11] |
|||
Vector: [8,8,8,2,2,2], Mode(s): [8,2] |
|||
Vector: [cat,kat,Cat,emu,emu,Kat], Mode(s): [emu] |
|||
Vector: [0,1,2,3,3,3,4,4,4,4,1,0], Mode(s): [4] |
|||
Vector: [2,7,1,8,2], Mode(s): [2] |
|||
Vector: [2,7,1,8,2,8], Mode(s): [2,8] |
|||
Vector: [E,n,z,y,k,l,o,p,ä,d,i,e], Mode(s): [E,n,z,y,k,l,o,p,ä,d,i,e] |
|||
Vector: [E,n,z,y,k,l,o,p,ä,d,i,e,ä], Mode(s): [ä] |
|||
Vector: [3,1,4,1,5,9,7,6], Mode(s): [1] |
|||
Vector: [3,1,4,1,5,9,7,6,3], Mode(s): [1,3] |
|||
Vector: [1,3,6,6,6,6,7,7,12,12,17], Mode(s): [6] |
|||
Vector: [1,1,2,4,4], Mode(s): [1,4]</pre> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
# Project : Averages/Mode |
|||
a = [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17] |
|||
b = [1, 2, 4, 4, 1] |
|||
amodes = list(12) |
|||
see "mode(s) of a() = " + nl |
|||
for i1 = 1 to modes(a,amodes) |
|||
see "" + amodes[i1] + " " |
|||
next |
|||
see nl |
|||
see "mode(s) of b() = " + nl |
|||
for i1 = 1 to modes(b,amodes) |
|||
see "" + amodes [i1] + " " |
|||
next |
|||
see nl |
|||
func modes(a,amodes) |
|||
max = 0 |
|||
n = len(a) |
|||
if n = 0 |
|||
amodes[1] = a[1] |
|||
return 1 |
|||
ok |
|||
c = list(n) |
|||
for i = 1 to n |
|||
for j = i+1 to n |
|||
if a[i] = a[j] |
|||
c[i] = c[i] + 1 |
|||
ok |
|||
next |
|||
if c[i] > max |
|||
max = c[i] |
|||
ok |
|||
next |
|||
j = 0 |
|||
for i = 1 to n |
|||
if c[i] = max |
|||
j = j + 1 |
|||
amodes[j] = a[i] |
|||
ok |
|||
next |
|||
return j |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
mode(s) of a() = |
|||
6 |
|||
mode(s) of b() = |
|||
1 4 |
|||
</pre> |
|||
=={{header|RPL}}== |
|||
∑VAL and ∑CNT are global lists used to store rep. values and counters. |
|||
Using the stack to handle potentially big amounts of data would slow down execution. |
|||
{{works with|Halcyon Calc|4.2.7}} |
|||
{| class="wikitable" |
|||
! RPL code |
|||
! Comment |
|||
|- |
|||
| |
|||
≪ |
|||
'''IF ∑VAL''' OVER POS |
|||
'''THEN '∑CNT'''' LAST ∑'''CNT''' OVER GET 1 + PUT DROP |
|||
'''ELSE ∑VAL''' SWAP + ''''∑VAL'''' STO '''∑CNT''' 1 + ''''∑CNT'''' STO '''END''' |
|||
≫ ''''∑ADD'''' STO |
|||
≪ → data |
|||
≪ { } DUP ''''∑VAL'''' STO ''''∑CNT'''' STO |
|||
1 data SIZE '''FOR''' j |
|||
data j GET '''∑ADD NEXT''' |
|||
'''∑CNT''' LIST→ { } + →ARRY RNRM { } |
|||
1 '''∑VAL''' SIZE '''FOR''' j |
|||
'''IF''' OVER ''''∑CNT'''' j GET == |
|||
'''THEN '∑VAL'''' j GET |
|||
'''IF''' DUP2 POS NOT '''THEN''' + '''END''' |
|||
'''END NEXT''' |
|||
≫ ''''MODE'''' STO |
|||
| |
|||
'''∑ADD''' ''( n -- )'' // update ∑VAL and ∑CNT |
|||
if n already in ∑VAL |
|||
then increment corresponding position in ∑CNT |
|||
else create new in ∑VAL / ∑CNT entries |
|||
'''MODE''' ''( { data } -- { modal value(s) } )'' |
|||
initialize ∑VAL and ∑CNT |
|||
for all input values |
|||
count occurrences |
|||
get max value in ∑CNT |
|||
for all distinct values |
|||
if count = max |
|||
then get value |
|||
and add it to output list if not already in |
|||
|} |
|||
{ 1 3 6 6 6 6 7 7 12 12 17 } '''MODE''' |
|||
{ 1 1 2 4 4 } '''MODE''' |
|||
{{out}} |
|||
<pre> |
|||
2: { 6 } |
|||
1: { 1 4 } |
|||
</pre> |
</pre> |
||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
Here's two methods, the first more Ruby-ish, the second perhaps a bit more efficient. |
Here's two methods, the first more Ruby-ish, the second perhaps a bit more efficient. |
||
< |
<syntaxhighlight lang="ruby">def mode(ary) |
||
seen = Hash.new(0) |
seen = Hash.new(0) |
||
ary.each {|value| seen[value] += 1} |
ary.each {|value| seen[value] += 1} |
||
Line 1,133: | Line 3,277: | ||
p mode([1, 1, 2, 4, 4]) # => [1, 4] |
p mode([1, 1, 2, 4, 4]) # => [1, 4] |
||
p mode_one_pass([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]) # => [6] |
p mode_one_pass([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]) # => [6] |
||
p mode_one_pass([1, 1, 2, 4, 4]) # => [1, 4]</ |
p mode_one_pass([1, 1, 2, 4, 4]) # => [1, 4]</syntaxhighlight> |
||
{{works with|Ruby|1.8.7}} |
{{works with|Ruby|1.8.7}} |
||
If you just want one mode (instead of all of them), here's a one-liner for that: |
If you just want one mode (instead of all of them), here's a one-liner for that: |
||
< |
<syntaxhighlight lang="ruby">def one_mode(ary) |
||
ary.max_by { |x| ary.count(x) } |
ary.max_by { |x| ary.count(x) } |
||
end</ |
end</syntaxhighlight> |
||
=={{header|Rust}}== |
|||
<syntaxhighlight lang="rust">use std::collections::HashMap; |
|||
fn main() { |
|||
let mode_vec1 = mode(vec![ 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]); |
|||
let mode_vec2 = mode(vec![ 1, 1, 2, 4, 4]); |
|||
println!("Mode of vec1 is: {:?}", mode_vec1); |
|||
println!("Mode of vec2 is: {:?}", mode_vec2); |
|||
assert!( mode_vec1 == [6], "Error in mode calculation"); |
|||
assert!( (mode_vec2 == [1, 4]) || (mode_vec2 == [4,1]), "Error in mode calculation" ); |
|||
} |
|||
fn mode(vs: Vec<i32>) -> Vec<i32> { |
|||
let mut vec_mode = Vec::new(); |
|||
let mut seen_map = HashMap::new(); |
|||
let mut max_val = 0; |
|||
for i in vs{ |
|||
let ctr = seen_map.entry(i).or_insert(0); |
|||
*ctr += 1; |
|||
if *ctr > max_val{ |
|||
max_val = *ctr; |
|||
} |
|||
} |
|||
for (key, val) in seen_map { |
|||
if val == max_val{ |
|||
vec_mode.push(key); |
|||
} |
|||
} |
|||
vec_mode |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Mode of vec1 is: [6] |
|||
Mode of vec2 is: [1,4] // may also print [4, 1], vector has no order guarantee |
|||
</pre> |
|||
=={{header|S-lang}}== |
|||
I'm accepting strings and numbers, although I'm converting numbers to strings, |
|||
as S-Lang Assoc_Type only accepts strings as keys. |
|||
<syntaxhighlight lang="s-lang">private variable mx, mxkey, modedat; |
|||
define find_max(key) { |
|||
if (modedat[key] > mx) { |
|||
mx = modedat[key]; |
|||
mxkey = {key}; |
|||
} |
|||
else if (modedat[key] == mx) { |
|||
list_append(mxkey, key); |
|||
} |
|||
} |
|||
define find_mode(indat) |
|||
{ |
|||
% reset [file/module-scope] globals: |
|||
mx = 0, mxkey = {}, modedat = Assoc_Type[Int_Type, 0]; |
|||
foreach $1 (indat) |
|||
modedat[string($1)]++; |
|||
array_map(Void_Type, &find_max, assoc_get_keys(modedat)); |
|||
if (length(mxkey) > 1) { |
|||
$2 = 0; |
|||
() = printf("{"); |
|||
foreach $1 (mxkey) { |
|||
() = printf("%s%s", $2 ? ", " : "", $1); |
|||
$2 = 1; |
|||
} |
|||
() = printf("} each have "); |
|||
} |
|||
else |
|||
() = printf("%s has ", mxkey[0], mx); |
|||
() = printf("the most entries (%d).\n", mx); |
|||
} |
|||
find_mode({"Hungadunga", "Hungadunga", "Hungadunga", "Hungadunga", "McCormick"}); |
|||
find_mode({"foo", "2.3", "bar", "foo", "foobar", "quality", 2.3, "strnen"});</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Hungadunga has the most entries (4). |
|||
{foo, 2.3} each have the most entries (2).</pre> |
|||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
{{works with|Scala|2.8}} |
{{works with|Scala|2.8}} |
||
Receiving any collection is easy. Returning the result in the same collection takes some doing. |
Receiving any collection is easy. Returning the result in the same collection takes some doing. |
||
<syntaxhighlight lang="scala">import scala.collection.breakOut |
|||
<lang scala>import scala.collection.breakOut |
|||
import scala.collection.generic.CanBuildFrom |
import scala.collection.generic.CanBuildFrom |
||
def mode |
def mode |
||
Line 1,156: | Line 3,381: | ||
val max = grouped.map(_._2).max |
val max = grouped.map(_._2).max |
||
grouped.filter(_._2 == max).map(_._1)(breakOut) |
grouped.filter(_._2 == max).map(_._1)(breakOut) |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Scheme}}== |
|||
{{works with|Berkeley Scheme}} |
|||
<syntaxhighlight lang="scheme">(define (mode collection) |
|||
(define (helper collection counts) |
|||
(if (null? collection) |
|||
counts |
|||
(helper (remove (car collection) collection) |
|||
(cons (cons (car collection) |
|||
(appearances (car collection) collection)) counts)))) |
|||
(map car |
|||
(filter (lambda (x) (= (cdr x) (apply max (map cdr (helper collection '()))))) |
|||
(helper collection '())))</syntaxhighlight> |
|||
=={{header|Seed7}}== |
|||
The example below defines the template function <code>createModeFunction</code>, which defines the function <code>mode</code>. |
|||
The template <code>createModeFunction</code> is instantiated explicit with <code>createModeFunction(integer)</code>. |
|||
Additionally to <code>mode</code> the function <code>str</code> is defined. |
|||
The function <code>str</code> is used by the template function |
|||
[http://seed7.sourceforge.net/libraries/enable_output.htm#enable_output%28in_type%29 enable_output] to allow writing arrays. |
|||
This way the <code>main</code> function can just [http://seed7.sourceforge.net/libraries/enable_output.htm#write%28in_aType%29 write] the mode. |
|||
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
|||
const proc: createModeFunction (in type: elemType) is func |
|||
begin |
|||
const func array elemType: mode (in array elemType: data) is func |
|||
result |
|||
var array elemType: maxElems is 0 times elemType.value; |
|||
local |
|||
var hash [elemType] integer: counts is (hash [elemType] integer).value; |
|||
var elemType: aValue is elemType.value; |
|||
var integer: maximum is 0; |
|||
begin |
|||
for aValue range data do |
|||
if aValue in counts then |
|||
incr(counts[aValue]); |
|||
else |
|||
counts @:= [aValue] 1; |
|||
end if; |
|||
if counts[aValue] > maximum then |
|||
maximum := counts[aValue]; |
|||
maxElems := [] (aValue); |
|||
elsif counts[aValue] = maximum then |
|||
maxElems &:= aValue; |
|||
end if; |
|||
end for; |
|||
end func; |
|||
const func string: str (in array elemType: data) is func |
|||
result |
|||
var string: stri is ""; |
|||
local |
|||
var elemType: anElement is elemType.value; |
|||
begin |
|||
for anElement range data do |
|||
stri &:= " " & str(anElement); |
|||
end for; |
|||
stri := stri[2 ..]; |
|||
end func; |
|||
enable_output(array elemType); |
|||
end func; |
|||
createModeFunction(integer); |
|||
const proc: main is func |
|||
begin |
|||
writeln(mode([] (1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17))); |
|||
writeln(mode([] (1, 1, 2, 4, 4))); |
|||
end func;</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
6 |
|||
1 4 |
|||
</pre> |
|||
=={{header|Sidef}}== |
|||
<syntaxhighlight lang="ruby">func mode(array) { |
|||
var c = Hash.new; |
|||
array.each{|i| c{i} := 0 ++}; |
|||
var max = c.values.max; |
|||
c.keys.grep{|i| c{i} == max}; |
|||
}</syntaxhighlight> |
|||
'''Calling the function''' |
|||
<syntaxhighlight lang="ruby">say mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]).join(' '); |
|||
say mode([1, 1, 2, 4, 4]).join(' ');</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
6 |
|||
1 4 |
|||
</pre> |
|||
If you just want one mode (instead of all of them), here's a one-liner for that: |
|||
<syntaxhighlight lang="ruby">func one_mode(arr) { |
|||
arr.max_by{|i| arr.count(i)}; |
|||
}</syntaxhighlight> |
|||
=={{header|Slate}}== |
=={{header|Slate}}== |
||
<syntaxhighlight lang="slate">s@(Sequence traits) mode |
|||
<lang Slate> |
|||
s@(Sequence traits) mode |
|||
[| sortedCounts | |
[| sortedCounts | |
||
sortedCounts: (s as: Bag) sortedCounts. |
sortedCounts: (s as: Bag) sortedCounts. |
||
(sortedCounts mapSelect: [| :count :elem | sortedCounts last count = count]) valueSet |
(sortedCounts mapSelect: [| :count :elem | sortedCounts last count = count]) valueSet |
||
].</syntaxhighlight> |
|||
]. |
|||
</lang> |
|||
=={{header|Smalltalk}}== |
=={{header|Smalltalk}}== |
||
{{works with|GNU Smalltalk}} |
{{works with|GNU Smalltalk}} |
||
This code is able to find the mode of any collection of any kind of object. |
This code is able to find the mode of any collection of any kind of object. |
||
< |
<syntaxhighlight lang="smalltalk">OrderedCollection extend [ |
||
mode [ |s| |
mode [ |s| |
||
s := self asBag sortedByCount. |
s := self asBag sortedByCount. |
||
Line 1,181: | Line 3,506: | ||
mode displayNl. |
mode displayNl. |
||
#( 1 1 2 4 4) asOrderedCollection |
#( 1 1 2 4 4) asOrderedCollection |
||
mode displayNl.</ |
mode displayNl.</syntaxhighlight> |
||
=={{header|SQL}}== |
|||
Some databases have a built-in function. In Oracle you can say <code>select stats_mode(val) from...</code> but that returns one value, so doesn't handle non-unique modes. Other databases don't have a built-in. So here's a way to do this in a query.<syntaxhighlight lang="sql">-- setup |
|||
create table averages (val integer); |
|||
insert into averages values (1); |
|||
insert into averages values (2); |
|||
insert into averages values (3); |
|||
insert into averages values (1); |
|||
insert into averages values (2); |
|||
insert into averages values (4); |
|||
insert into averages values (2); |
|||
insert into averages values (5); |
|||
insert into averages values (2); |
|||
insert into averages values (3); |
|||
insert into averages values (3); |
|||
insert into averages values (1); |
|||
insert into averages values (3); |
|||
insert into averages values (6); |
|||
-- find the mode |
|||
with |
|||
counts as |
|||
( |
|||
select |
|||
val, |
|||
count(*) as num |
|||
from |
|||
averages |
|||
group by |
|||
val |
|||
) |
|||
select |
|||
val as mode_val |
|||
from |
|||
counts |
|||
where |
|||
num in (select max(num) from counts);</syntaxhighlight> |
|||
{{out}} |
|||
<pre> MODE_VAL |
|||
---------- |
|||
2 |
|||
3</pre> |
|||
=={{header|Swift}}== |
|||
{{works with|Swift|4}} |
|||
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. |
|||
<syntaxhighlight lang="swift"> |
|||
// 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 { |
|||
/// Return a Mode of the function, or nil if none exist. |
|||
func mode() -> Element? { |
|||
var frequencies = [Element: Int]() |
|||
// Standard for loop. Can also use the forEach(_:) or reduce(into:) methods on self. |
|||
for element in self { |
|||
frequencies[element] = (frequencies[element] ?? 0) + 1 |
|||
} |
|||
// The max(by:) method used here to find one of the elements with the highest associated count. |
|||
if let ( mode, _ ) = frequencies.max(by: { $0.value < $1.value }) { |
|||
return mode |
|||
} else { |
|||
return nil |
|||
} |
|||
} |
|||
} |
|||
["q", "a", "a", "a", "a", "b", "b", "z", "c", "c", "c"].mode() // returns "a" |
|||
[1, 1, 2, 3, 3, 3, 3, 4, 4, 4].mode() // returns 3 |
|||
let emptyArray: [Int] = [] |
|||
emptyArray.mode() // returns nil |
|||
</syntaxhighlight> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
{{works with|Tcl|8.6}} |
{{works with|Tcl|8.6}} |
||
< |
<syntaxhighlight lang="tcl"># Can find the modal value of any vector of values |
||
proc mode {n args} { |
proc mode {n args} { |
||
foreach n [list $n {*}$args] { |
foreach n [list $n {*}$args] { |
||
Line 1,202: | Line 3,604: | ||
# Testing |
# Testing |
||
puts [mode 1 3 6 6 6 6 7 7 12 12 17]; # --> 6 |
puts [mode 1 3 6 6 6 6 7 7 12 12 17]; # --> 6 |
||
puts [mode 1 1 2 4 4]; # --> 1 4</ |
puts [mode 1 1 2 4 4]; # --> 1 4</syntaxhighlight> |
||
Note that this works for any kind of value. |
Note that this works for any kind of value. |
||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
{{works with|bash|4.0}} |
{{works with|bash|4.0}} |
||
< |
<syntaxhighlight lang="bash">#!/bin/bash |
||
function mode { |
function mode { |
||
Line 1,220: | Line 3,623: | ||
done |
done |
||
echo |
echo |
||
}</ |
}</syntaxhighlight> |
||
< |
<syntaxhighlight lang="bash">mode 1 2 1 2 a b a b a 2 |
||
a 2</ |
a 2</syntaxhighlight> |
||
=={{header|Ursala}}== |
=={{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. |
|||
<syntaxhighlight lang="ursala">#import std |
|||
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. |
|||
<lang Ursala>#import std |
|||
mode = ~&hS+ leql$^&h+ eql|=@K2 |
mode = ~&hS+ leql$^&h+ eql|=@K2 |
||
Line 1,238: | Line 3,635: | ||
#cast %nLW |
#cast %nLW |
||
examples = mode~~ (<1,3,6,6,6,7,7,12,12,17>,<1,1,2,4,4>)</ |
examples = mode~~ (<1,3,6,6,6,7,7,12,12,17>,<1,1,2,4,4>)</syntaxhighlight> |
||
The function is tested on a pair of lists, one with a unique mode |
The function is tested on a pair of lists, one with a unique mode and one with multiple modes. |
||
{{out}} |
|||
and one with multiple modes. Here is the output. |
|||
<pre>(<6>,<4,1>)</pre> |
<pre>(<6>,<4,1>)</pre> |
||
=={{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. |
|||
<syntaxhighlight lang="vb">Public Sub main() |
|||
s = [{1,2,3,3,3,4,4,4,5,5,6}] |
|||
t = WorksheetFunction.Mode_Mult(s) |
|||
For Each x In t |
|||
Debug.Print x; |
|||
Next x |
|||
End Sub</syntaxhighlight>{{out}} |
|||
<pre> 3 4</pre> |
|||
=={{header|Vedit macro language}}== |
=={{header|Vedit macro language}}== |
||
Line 1,250: | Line 3,658: | ||
The "mode" item and it's count are displayed on status line. |
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. |
If there are multiple items with the same count, the smallest one is displayed. |
||
<syntaxhighlight lang="vedit">BOF // Copy all data to a new buffer |
|||
<lang vedit> |
|||
BOF // Copy all data to a new buffer |
|||
Reg_Copy(10, ALL) |
Reg_Copy(10, ALL) |
||
Buf_Switch(Buf_Free) |
Buf_Switch(Buf_Free) |
||
Line 1,275: | Line 3,682: | ||
Reg_Copy_Block(10, CP, EOL_pos) |
Reg_Copy_Block(10, CP, EOL_pos) |
||
Buf_Quit(OK) |
Buf_Quit(OK) |
||
Statline_Message(@10) |
Statline_Message(@10)</syntaxhighlight> |
||
</lang> |
|||
=={{header|V (Vlang)}}== |
|||
<syntaxhighlight lang="v (vlang)">fn main() { |
|||
println(mode([2, 7, 1, 8, 2])) |
|||
println(mode([2, 7, 1, 8, 2, 8])) |
|||
} |
|||
fn mode(a []int) []int { |
|||
mut m := map[int]int{} |
|||
for v in a { |
|||
m[v]++ |
|||
} |
|||
mut mode := []int{} |
|||
mut n := 0 |
|||
for k, v in m { |
|||
match true { |
|||
v > n { |
|||
n = v |
|||
mode = [k] |
|||
} |
|||
v<n{} |
|||
else { |
|||
mode << k |
|||
} |
|||
} |
|||
} |
|||
return mode |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[2] |
|||
[2, 8] |
|||
</pre> |
|||
Or using `math.stats` module |
|||
<syntaxhighlight lang="vlang">import math.stats |
|||
fn main() { |
|||
println(stats.mode<int>([2, 7, 1, 8, 2])) |
|||
println(stats.mode<int>([2, 7, 1, 8, 2, 8])) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2 |
|||
2 |
|||
</pre> |
|||
=={{header|Wren}}== |
|||
<syntaxhighlight lang="wren">class Arithmetic { |
|||
static mode(arr) { |
|||
var map = {} |
|||
for (e in arr) { |
|||
if (map[e] == null) map[e] = 0 |
|||
map[e] = map[e] + 1 |
|||
} |
|||
var max = map.values.reduce {|x, y| x > y ? x : y} |
|||
return map.keys.where {|x| map[x] == max}.toList |
|||
} |
|||
} |
|||
System.print(Arithmetic.mode([1,2,3,4,5,5,51,2,3]))</syntaxhighlight> |
|||
{{out}} |
|||
[2, 3, 5] |
|||
Order may differ |
|||
=={{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. |
|||
<syntaxhighlight lang="xelisp">(defun mode ( predicate &rest values) |
|||
"Finds the mode of all values passed in. |
|||
Uses `predicate' to compare items." |
|||
(let ((modes nil) ; Declare local variables |
|||
(mode-count 0) |
|||
(value-list nil) |
|||
current-value) |
|||
(loop for value in values do |
|||
(if (setq current-value (assoc* value value-list :test predicate)) ; Construct a linked list of cons cells, (value . count) |
|||
(incf (cdr current-value)) |
|||
(push (cons value 1) value-list))) |
|||
(loop for (value . count) in value-list do ; Find modes in linked list |
|||
(if (> count mode-count) |
|||
(setq modes (list value) |
|||
mode-count count) |
|||
(when (eq count mode-count) |
|||
(push value modes)))) |
|||
modes))</syntaxhighlight> |
|||
=={{header|XPL0}}== |
|||
<syntaxhighlight lang "XPL0">proc Mode(Size, Array); \Show the mode(s) of Array |
|||
int Size, Array; |
|||
int List, Count I, J, K, Max; |
|||
[List:= Reserve(Size*4); \4 bytes per integer |
|||
Count:= Reserve(Size*4); |
|||
K:= 0; |
|||
for I:= 0 to Size-1 do |
|||
[for J:= 0 to K-1 do |
|||
if List(J) = Array(I) then \item is in List |
|||
[Count(J):= Count(J)+1; \ so increment its count |
|||
J:= Size; |
|||
]; |
|||
if J = K then \not already in List |
|||
[List(K):= Array(I); |
|||
Count(K):= 1; |
|||
K:= K+1; |
|||
]; |
|||
]; |
|||
Max:= 0; \find maximum count |
|||
for J:= 0 to K-1 do |
|||
if Count(J) > Max then |
|||
Max:= Count(J); |
|||
for J:= 0 to K-1 do \show Array item(s) with Max Count |
|||
if Count(J) = Max then |
|||
[IntOut(0, List(J)); ChOut(0, ^ )]; |
|||
]; |
|||
Mode(9, [1,2,3,4,5,5,5123,2,3]) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 3 5 </pre> |
|||
=={{header|Yabasic}}== |
|||
<syntaxhighlight lang="yabasic">sub floor(x) |
|||
return int(x + .05) |
|||
end sub |
|||
SUB ASort$(matriz$()) |
|||
local last, gap, first, tempi$, tempj$, i, j |
|||
last = arraysize(matriz$(), 1) |
|||
gap = floor(last / 10) + 1 |
|||
while(TRUE) |
|||
first = gap + 1 |
|||
for i = first to last |
|||
tempi$ = matriz$(i) |
|||
j = i - gap |
|||
while(TRUE) |
|||
tempj$ = matriz$(j) |
|||
if (tempi$ >= tempj$) then |
|||
j = j + gap |
|||
break |
|||
end if |
|||
matriz$(j+gap) = tempj$ |
|||
if j <= gap then |
|||
break |
|||
end if |
|||
j = j - gap |
|||
wend |
|||
matriz$(j) = tempi$ |
|||
next i |
|||
if gap = 1 then |
|||
return |
|||
else |
|||
gap = floor(gap / 3.5) + 1 |
|||
end if |
|||
wend |
|||
END SUB |
|||
sub getMode$(list$) // returns mode and count |
|||
local m$(1), n, i, mode$, count, maxM$, maxC |
|||
n = token(list$, m$(), ", ") |
|||
ASort$(m$()) |
|||
for i = 1 to n |
|||
if m$(i) <> mode$ then |
|||
if count > maxC then |
|||
maxM$ = mode$ |
|||
maxC = count |
|||
end if |
|||
count = 1 |
|||
mode$ = m$(i) |
|||
else |
|||
count = count + 1 |
|||
end if |
|||
next i |
|||
return maxM$ + "," + str$(maxC) |
|||
end sub |
|||
result$ = getMode$("1,3,6,6,6,6,7,7,12,12,17") |
|||
n = instr(result$, ",") |
|||
print "mode ", left$(result$, n - 1), " occur(s) ", right$(result$, len(result$) - n), " times." |
|||
result$ = getMode$("a, a, b, d, d") |
|||
print "mode ", left$(result$, n - 1), " occur(s) ", right$(result$, len(result$) - n), " times."</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
mode 6 occur(s) 4 times. |
|||
mode a occur(s) 2 times.</pre> |
|||
=={{header|zkl}}== |
|||
This is a bit funky in that modes are returned as strings. |
|||
{{trans|D}} |
|||
<syntaxhighlight lang="zkl">fcn mode(items){ |
|||
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> |
|||
<syntaxhighlight lang="zkl">data:=T(1, 2, 3, 1, 2, 4, 2, 5, 3, 3, 1, 3, 6); |
|||
println("Mode: ", mode(data)); |
|||
println("Mode: ", mode(data.append(2))); |
|||
println("Mode: ", mode("this is a test".split("")));</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Mode: L("3") |
|||
Mode: L("2","3") |
|||
Mode: L("s","t"," ") |
|||
</pre> |
Latest revision as of 10:22, 29 December 2023
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Write a program to find the mode value of a collection.
The case where the collection is empty may be ignored. Care must be taken to handle the case where the mode is non-unique.
If it is not appropriate or possible to support a general collection, use a vector (array), if possible. If it is not appropriate or possible to support an unspecified value type, use integers.
|
11l
F modes(values)
DefaultDict[Int, Int] count
L(v) values
count[v]++
V best = max(count.values())
R count.filter(kv -> kv[1] == @best).map(kv -> kv[0])
print(modes([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]))
print(modes([1, 1, 2, 4, 4]))
- Output:
[6] [1, 4]
Action!
DEFINE MAX="100"
INT ARRAY keys(MAX)
INT ARRAY values(MAX)
BYTE count
PROC PrintArray(INT ARRAY a INT size)
INT i
Put('[)
FOR i=0 TO size-1
DO
IF i>0 THEN Put(' ) FI
PrintI(a(i))
OD
Put(']) PutE()
RETURN
PROC ClearMap()
count=0
RETURN
PROC AddToMap(INT a)
INT i,index
index=-1
IF count>0 THEN
FOR i=0 TO count-1
DO
IF keys(i)=a THEN
index=i EXIT
FI
OD
FI
IF index=-1 THEN
keys(count)=a
values(count)=1
count==+1
ELSE
values(index)==+1
FI
RETURN
PROC Mode(INT ARRAY a INT aSize INT ARRAY m INT POINTER mSize)
INT i,mx
ClearMap()
FOR i=0 TO aSize-1
DO
AddToMap(a(i))
OD
mx=0
FOR i=0 TO count-1
DO
IF values(i)>mx THEN
mx=values(i)
FI
OD
mSize^=0
FOR i=0 TO count-1
DO
IF values(i)=mx THEN
m(mSize^)=keys(i)
mSize^==+1
FI
OD
RETURN
PROC Test(INT ARRAY a INT size)
INT ARRAY m(MAX)
INT mSize
PrintE("Array:") PrintArray(a,size)
Mode(a,size,m,@mSize)
PrintE("Mode:") PrintArray(m,mSize)
PutE()
RETURN
PROC Main()
INT ARRAY a=[1 3 5 7 3 1 3 7 7 3 3]
INT ARRAY b=[7 13 5 13 7 2 7 10 13]
INT ARRAY c=[5]
Test(a,11)
Test(b,9)
Test(c,1)
RETURN
- Output:
Screenshot from Atari 8-bit computer
Array: [1 3 5 7 3 1 3 7 7 3 3] Mode: [3] Array: [7 13 5 13 7 2 7 10 13] Mode: [7 13] Array: [5] Mode: [5]
ActionScript
This implementation does not work with arbitrary collections. However, it works with arrays containing mixed data, including strings and other arrays.
function Mode(arr:Array):Array {
//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.
var count:Array = new Array();
var modeList:Array;
var maxCount:uint=0;
for (var i:String in arr) {
//Record how many times an element has occurred. Note that each element in the cuont array
//has to be initialized explicitly, since it is an associative array.
if (count[arr[i]]==undefined) {
count[arr[i]]=1;
} else {
count[arr[i]]++;
}
//If this is now the most common element, clear the list of modes, and add this element.
if(count[arr[i]] > maxCount)
{
maxCount=count[arr[i]];
modeList = new Array();
modeList.push(arr[i]);
}
//If this is a mode, add it to the list.
else if(count[arr[i]] == maxCount){
modeList.push(arr[i]);
}
}
return modeList;
}
Ada
mode.ads:
generic
type Element_Type is private;
type Element_Array is array (Positive range <>) of Element_Type;
package Mode is
function Get_Mode (Set : Element_Array) return Element_Array;
end Mode;
mode.adb:
with Ada.Containers.Indefinite_Vectors;
package body Mode is
-- map Count to Elements
package Count_Vectors is new Ada.Containers.Indefinite_Vectors
(Element_Type => Element_Array,
Index_Type => Positive);
procedure Add (To : in out Count_Vectors.Vector; Item : Element_Type) is
use type Count_Vectors.Cursor;
Position : Count_Vectors.Cursor := To.First;
Found : Boolean := False;
begin
while not Found and then Position /= Count_Vectors.No_Element loop
declare
Elements : Element_Array := Count_Vectors.Element (Position);
begin
for I in Elements'Range loop
if Elements (I) = Item then
Found := True;
end if;
end loop;
end;
if not Found then
Position := Count_Vectors.Next (Position);
end if;
end loop;
if Position /= Count_Vectors.No_Element then
-- element found, remove it and insert to next count
declare
New_Position : Count_Vectors.Cursor :=
Count_Vectors.Next (Position);
begin
-- remove from old position
declare
Old_Elements : Element_Array :=
Count_Vectors.Element (Position);
New_Elements : Element_Array (1 .. Old_Elements'Length - 1);
New_Index : Positive := New_Elements'First;
begin
for I in Old_Elements'Range loop
if Old_Elements (I) /= Item then
New_Elements (New_Index) := Old_Elements (I);
New_Index := New_Index + 1;
end if;
end loop;
To.Replace_Element (Position, New_Elements);
end;
-- new position not already there?
if New_Position = Count_Vectors.No_Element then
declare
New_Array : Element_Array (1 .. 1) := (1 => Item);
begin
To.Append (New_Array);
end;
else
-- add to new position
declare
Old_Elements : Element_Array :=
Count_Vectors.Element (New_Position);
New_Elements : Element_Array (1 .. Old_Elements'Length + 1);
begin
New_Elements (1 .. Old_Elements'Length) := Old_Elements;
New_Elements (New_Elements'Last) := Item;
To.Replace_Element (New_Position, New_Elements);
end;
end if;
end;
else
-- element not found, add to count 1
Position := To.First;
if Position = Count_Vectors.No_Element then
declare
New_Array : Element_Array (1 .. 1) := (1 => Item);
begin
To.Append (New_Array);
end;
else
declare
Old_Elements : Element_Array :=
Count_Vectors.Element (Position);
New_Elements : Element_Array (1 .. Old_Elements'Length + 1);
begin
New_Elements (1 .. Old_Elements'Length) := Old_Elements;
New_Elements (New_Elements'Last) := Item;
To.Replace_Element (Position, New_Elements);
end;
end if;
end if;
end Add;
function Get_Mode (Set : Element_Array) return Element_Array is
Counts : Count_Vectors.Vector;
begin
for I in Set'Range loop
Add (Counts, Set (I));
end loop;
return Counts.Last_Element;
end Get_Mode;
end Mode;
example use:
with Ada.Text_IO;
with Mode;
procedure Main is
type Int_Array is array (Positive range <>) of Integer;
package Int_Mode is new Mode (Integer, Int_Array);
Test_1 : Int_Array := (1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6);
Result : Int_Array := Int_Mode.Get_Mode (Test_1);
begin
Ada.Text_IO.Put ("Input: ");
for I in Test_1'Range loop
Ada.Text_IO.Put (Integer'Image (Test_1 (I)));
if I /= Test_1'Last then
Ada.Text_IO.Put (",");
end if;
end loop;
Ada.Text_IO.New_Line;
Ada.Text_IO.Put ("Result:");
for I in Result'Range loop
Ada.Text_IO.Put (Integer'Image (Result (I)));
if I /= Result'Last then
Ada.Text_IO.Put (",");
end if;
end loop;
Ada.Text_IO.New_Line;
end Main;
- Output:
Input: 1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6 Result: 2, 3
ALGOL 68
This sample defines an operator to return the mode(s) of an integer array. Additional operators cound be defined for other array types.
Note the source of rows.incl.a68 (containing the QUICKSORT and SHOW operators) is available on a page in Rosetta Code, see the above link.
BEGIN # find the mode (most frequent value) of a set of items #
PR read "rows.incl.a68" PR # include row (array) utilities #
# returns the mode(s) of a - similar operators could be defined for #
# types other than INT #
OP MODEOF = ( []INT a )[]INT:
IF LWB a > UPB a THEN []INT() # no data #
ELSE # have data #
[ LWB a : UPB a ]INT sorted data := a;
QUICKSORT sorted data FROMELEMENT LWB sorted data TOELEMENT UPB sorted data;
INT distinct count = BEGIN # count the number of distinct values #
INT count := 1;
INT value := sorted data[ LWB sorted data ];
FOR i FROM LWB sorted data + 1 TO UPB sorted data DO
IF value /= sorted data[ i ] THEN
count +:= 1;
value := sorted data[ i ]
FI
OD;
count
END;
INT current value := sorted data[ LWB sorted data ];
INT max count := 0;
INT current count := 1;
INT s pos := LWB sorted data + 1;
# allow for the maximum possible number of modes #
[ 1 : distinct count ]INT modes;
INT mode count := 1;
modes[ 1 ] := current value;
WHILE s pos <= UPB sorted data DO
s pos +:= 1;
WHILE IF s pos > UPB sorted data
THEN FALSE
ELSE sorted data[ s pos ] = current value
FI
DO
current count +:= 1;
s pos +:= 1
OD;
IF current count > max count THEN
max count := current count;
modes[ mode count := 1 ] := sorted data[ s pos - 1 ]
ELIF current count = max count THEN
modes[ mode count +:= 1 ] := sorted data[ s pos - 1 ]
FI;
current count := 0;
IF s pos <= UPB sorted data THEN
current value := sorted data[ s pos ]
FI
OD;
modes[ 1 : mode count ]
FI # MODEOF # ;
# test cases as in the 11l sample #
SHOW MODEOF []INT( 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17 );print( ( newline ) );
SHOW MODEOF []INT( 1, 1, 2, 4, 4 ) ;print( ( newline ) );
# test cases as in the Action! sample #
SHOW MODEOF []INT( 1, 3, 5, 7, 3, 1, 3, 7, 7, 3, 3 ) ;print( ( newline ) );
SHOW MODEOF []INT( 7, 13, 5, 13, 7, 2, 7, 10, 13 ) ;print( ( newline ) );
SHOW MODEOF []INT( 5 ) ;print( ( newline ) );
# additional test case #
SHOW MODEOF []INT( 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 ) ;print( ( newline )
END
- Output:
6 1 4 3 7 13 5 9
APL
mode←{{s←⌈/⍵[;2]⋄⊃¨(↓⍵)∩{⍵,s}¨⍵[;1]}{⍺,≢⍵}⌸⍵}
AppleScript
This works with both lists and records containing numbers and/or text values.
use AppleScript version "2.3.1" -- Mac OS X 10.9 (Mavericks) or later (for these 'use' commands).
use sorter : script "Shell sort" -- https://www.rosettacode.org/wiki/Sorting_algorithms/Shell_sort#AppleScript
on modeOf(listOrRecord)
-- Extract and sort numbers and text separately, then concatenate the results to get a single list of values.
set theNumbers to listOrRecord's numbers
tell sorter to sort(theNumbers, 1, -1)
set theTexts to listOrRecord's text
tell sorter to sort(theTexts, 1, -1)
script o
property values : theNumbers & theTexts
property mode : {}
end script
-- Identify the most frequently occurring value(s).
if (o's values is not {}) then
set i to 1
set currentValue to beginning of o's values
set maxCount to 1
repeat with j from 2 to (count o's values)
set thisValue to item j of o's values
if (thisValue is not currentValue) then
set thisCount to j - i
if (thisCount > maxCount) then
set o's mode to {currentValue}
set maxCount to thisCount
else if (thisCount = maxCount) then
set end of o's mode to currentValue
end if
set i to j
set currentValue to thisValue
end if
end repeat
if (j + 1 - i > maxCount) then
set o's mode to {currentValue}
else if (j + 1 - i = maxCount) then
set end of o's mode to currentValue
end if
end if
return o's mode
end modeOf
-- Test code:
-- With a list:
modeOf({12, 4, "rhubarb", 88, "rhubarb", 17, "custard", 4.0, 4, 88, "rhubarb"})
--> {4, "rhubarb"}
-- With a record:
modeOf({a:12, b:4, c:"rhubarb", d:88, e:"rhubarb", f:17, g:"custard", h:4.0, i:4, j:88})
--> {4}
Arturo
getMode: function [arr][
freqs: new #[]
loop arr 'i [
k: to :string i
if not? key? freqs k -> set freqs k 0
freqs\[k]: (freqs\[k]) + 1
]
maximum: max values freqs
select keys freqs 'i -> maximum = freqs\[i]
]
print getMode [1 3 6 6 6 6 7 7 12 12 17]
print getMode [1 1 2 4 4]
- Output:
6 1 4
AutoHotkey
Search autohotkey.com: [1]
Source: AutoHotkey forum by Laszlo
MsgBox % Mode("1 2 3")
MsgBox % Mode("1 2 0 3 0.0")
MsgBox % Mode("0.1 2.2 -0.1 0.22e1 2.20 0.1")
Mode(a, d=" ") { ; the number that occurs most frequently in a list delimited by d (space)
Sort a, ND%d%
Loop Parse, a, %d%
If (V != A_LoopField) {
If (Ct > MxCt)
MxV := V, MxCt := Ct
V := A_LoopField, Ct := 1
}
Else Ct++
Return Ct>MxCt ? V : MxV
}
AWK
#!/usr/bin/gawk -f
{
# compute histogram
histo[$1] += 1;
};
function mode(HIS) {
# Computes the mode from Histogram A
max = 0;
n = 0;
for (k in HIS) {
val = HIS[k];
if (HIS[k] > max) {
max = HIS[k];
n = 1;
List[n] = k;
} else if (HIS[k] == max) {
List[++n] = k;
}
}
for (k=1; k<=n; k++) {
o = o""OFS""List[k];
}
return o;
}
END {
print mode(histo);
};
cat modedata.txt 0 3 6 aa 3 6 aa 3 aa 6 7 1 as@mini10:~/src/RosettaCode$ ./mode.awk modedata.txt 6 aa 3
BBC BASIC
DIM a(10), b(4)
a() = 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17
b() = 1, 2, 4, 4, 1
DIM modes(10)
PRINT "Mode(s) of a() = " ;
FOR i% = 1 TO FNmodes(a(), modes())
PRINT ; modes(i%) " " ;
NEXT
PRINT
PRINT "Mode(s) of b() = " ;
FOR i% = 1 TO FNmodes(b(), modes())
PRINT ; modes(i%) " " ;
NEXT
PRINT
END
DEF FNmodes(a(), m())
LOCAL I%, J%, N%, c%(), max%
N% = DIM(a(),1)
IF N% = 0 THEN m(1) = a(0) : = 1
DIM c%(N%)
FOR I% = 0 TO N%-1
FOR J% = I%+1 TO N%
IF a(I%) = a(J%) c%(I%) += 1
NEXT
IF c%(I%) > max% max% = c%(I%)
NEXT I%
J% = 0
FOR I% = 0 TO N%
IF c%(I%) = max% J% += 1 : m(J%) = a(I%)
NEXT
= J%
- Output:
Mode(s) of a() = 6 Mode(s) of b() = 1 4
BQN
BQNcrate lists two functions for mode. Of these, the first is faster.
Mode1 ← ⌈´⊸=∘⊒⊸/ Mode2 ← ⊏∘⊑˘·(⌈´⊸=≠¨)⊸/⊐⊸⊔ arr ← 1‿1‿1‿1‿2‿2‿2‿3‿3‿3‿3‿4‿4‿3‿2‿4‿4‿4‿5‿5‿5‿5‿5 •Show Mode1 arr •Show Mode2 arr
⟨ 3 4 5 ⟩ ⟨ 3 4 5 ⟩
C
Using an array of doubles. If another data type is desired, the cmp_dbl
and vcount
definitions should be changed accordingly.
#include <stdio.h>
#include <stdlib.h>
typedef struct { double v; int c; } vcount;
int cmp_dbl(const void *a, const void *b)
{
double x = *(const double*)a - *(const double*)b;
return x < 0 ? -1 : x > 0;
}
int vc_cmp(const void *a, const void *b)
{
return ((const vcount*)b)->c - ((const vcount*)a)->c;
}
int get_mode(double* x, int len, vcount **list)
{
int i, j;
vcount *vc;
/* sort values */
qsort(x, len, sizeof(double), cmp_dbl);
/* count occurence of each value */
for (i = 0, j = 1; i < len - 1; i++, j += (x[i] != x[i + 1]));
*list = vc = malloc(sizeof(vcount) * j);
vc[0].v = x[0];
vc[0].c = 1;
/* generate list value-count pairs */
for (i = j = 0; i < len - 1; i++, vc[j].c++)
if (x[i] != x[i + 1]) vc[++j].v = x[i + 1];
/* sort that by count in descending order */
qsort(vc, j + 1, sizeof(vcount), vc_cmp);
/* the number of entries with same count as the highest */
for (i = 0; i <= j && vc[i].c == vc[0].c; i++);
return i;
}
int main()
{
double values[] = { 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 12, 12, 17 };
# define len sizeof(values)/sizeof(double)
vcount *vc;
int i, n_modes = get_mode(values, len, &vc);
printf("got %d modes:\n", n_modes);
for (i = 0; i < n_modes; i++)
printf("\tvalue = %g, count = %d\n", vc[i].v, vc[i].c);
free(vc);
return 0;
}
- Output:
got 2 modes: value = 6, count = 4 value = 12, count = 4
C#
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();
}
}
}
C++
#include <iterator>
#include <utility>
#include <algorithm>
#include <list>
#include <iostream>
// helper struct
template<typename T> struct referring
{
referring(T const& t): value(t) {}
template<typename Iter>
bool operator()(std::pair<Iter, int> const& p) const
{
return *p.first == value;
}
T const& value;
};
// requires:
// FwdIterator is a ForwardIterator
// The value_type of FwdIterator is EqualityComparable
// OutIterator is an output iterator
// the value_type of FwdIterator is convertible to the value_type of OutIterator
// [first, last) is a valid range
// provides:
// the mode is written to result
template<typename FwdIterator, typename OutIterator>
void mode(FwdIterator first, FwdIterator last, OutIterator result)
{
typedef typename std::iterator_traits<FwdIterator>::value_type value_type;
typedef std::list<std::pair<FwdIterator, int> > count_type;
typedef typename count_type::iterator count_iterator;
// count elements
count_type counts;
while (first != last)
{
count_iterator element = std::find_if(counts.begin(), counts.end(),
referring<value_type>(*first));
if (element == counts.end())
counts.push_back(std::make_pair(first, 1));
else
++element->second;
++first;
}
// find maximum
int max = 0;
for (count_iterator i = counts.begin(); i != counts.end(); ++i)
if (i->second > max)
max = i->second;
// copy corresponding elements to output sequence
for (count_iterator i = counts.begin(); i != counts.end(); ++i)
if (i->second == max)
*result++ = *i->first;
}
// example usage
int main()
{
int values[] = { 1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6 };
median(values, values + sizeof(values)/sizeof(int),
std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
return 0;
}
- Output:
2 3
Clojure
(defn modes [coll]
(let [distrib (frequencies coll)
[value freq] [first second] ; name the key/value pairs in the distrib (map) entries
sorted (sort-by (comp - freq) distrib)
maxfq (freq (first sorted))]
(map value (take-while #(= maxfq (freq %)) sorted))))
Or a one-liner solution
(defn modes [coll]
(->> coll frequencies (sort-by val >) (partition-by val) first (map key)))
CoffeeScript
mode = (arr) ->
# returns an array with the modes of arr, i.e. the
# elements that appear most often in arr
counts = {}
for elem in arr
counts[elem] ||= 0
counts[elem] += 1
max = 0
for key, cnt of counts
max = cnt if cnt > max
(key for key, cnt of counts when cnt == max)
console.log mode [1, 2, 2, 2, 3, 3, 3, 4, 4]
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., (mode '(a b c d a b c a b))
produces (A B)
and 3
. hash-table-options can be used to customize the hash table, e.g., to specify the test by which elements are compared.
(defun mode (sequence &rest hash-table-options)
(let ((frequencies (apply #'make-hash-table hash-table-options)))
(map nil (lambda (element)
(incf (gethash element frequencies 0)))
sequence)
(let ((modes '())
(hifreq 0 ))
(maphash (lambda (element frequency)
(cond ((> frequency hifreq)
(setf hifreq frequency
modes (list element)))
((= frequency hifreq)
(push element modes))))
frequencies)
(values modes hifreq))))
D
The mode function returns a range of all the mode items:
import std.stdio, std.algorithm, std.array;
auto mode(T)(T[] items) pure /*nothrow @safe*/ {
int[T] aa;
foreach (item; items)
aa[item]++;
immutable m = aa.byValue.reduce!max;
return aa.byKey.filter!(k => aa[k] == m);
}
void main() /*@safe*/ {
auto data = [1, 2, 3, 1, 2, 4, 2, 5, 3, 3, 1, 3, 6];
writeln("Mode: ", data.mode);
data ~= 2;
writeln("Mode: ", data.mode);
}
- Output:
Mode: [3] Mode: [2, 3]
Delphi
program AveragesMode;
{$APPTYPE CONSOLE}
uses
System.SysUtils,
System.Generics.Collections,
System.Generics.Defaults;
type
TCounts = TDictionary<Integer, Integer>;
TPair = record
value, count: Integer;
constructor Create(value, count: Integer);
end;
TPairs = TArray<TPair>;
var
dict: TCounts;
Pairs: TPairs;
list: TArray<Integer>;
i, key, max: Integer;
p: TPair;
{ TPair }
constructor TPair.Create(value, count: Integer);
begin
self.value := value;
self.count := count;
end;
function SortByCount(const left, right: TPair): Integer;
begin
Result := right.count - left.count;
end;
begin
list := [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 12, 12, 17];
dict := TCounts.Create;
for i in list do
begin
if dict.ContainsKey(i) then
dict[i] := dict[i] + 1
else
begin
dict.Add(i, 1);
end;
end;
SetLength(Pairs, dict.Count);
i := 0;
for key in dict.Keys do
begin
Pairs[i] := TPair.Create(key, dict[key]);
inc(i);
end;
TArray.Sort<TPair>(Pairs, TComparer<TPair>.Construct(SortByCount));
Writeln('Modes:');
max := Pairs[0].count;
for p in Pairs do
if p.count = max then
Writeln(' Value: ', p.value, ', Count: ', p.count);
dict.Free;
Readln;
end.
- Output:
Modes: Value: 6, Count: 4 Value: 12, Count: 4
E
pragma.enable("accumulator")
def mode(values) {
def counts := [].asMap().diverge()
var maxCount := 0
for v in values {
maxCount max= (counts[v] := counts.fetch(v, fn{0}) + 1)
}
return accum [].asSet() for v => ==maxCount in counts { _.with(v) }
}
? mode([1,1,2,2,3,3,4,4,4,5,5,6,6,7,8,8,9,9,0,0,0])
# value: [4, 0].asSet()
In the line "maxCount max= (counts[v] := counts.fetch(v, fn{0}) + 1)
", max=
is an update-assignment operation like +=
. (The parentheses are unnecessary.) A more verbose version would be:
def newCount := counts.fetch(v, fn { 0 }) + 1
counts[v] := newCount
maxCount := maxCount.max(newCount)
In for loops, each key and value from the collection are pattern matched against the specified key pattern => value pattern
. In "for v => ==maxCount in counts
", the ==
is a pattern-match operator which fails unless the value examined is equal to the specified value; so this selects only the input values (keys in counts
) whose counts are equal to the maximum count.
EasyLang
proc modes . in[] r[] .
r[] = [ ]
for v in in[]
for i to len vals[]
if v = vals[i]
cnt[i] += 1
max = higher cnt[i] max
break 1
.
.
vals[] &= v
cnt[] &= 0
.
for i to len cnt[]
if cnt[i] = max
r[] &= vals[i]
.
.
.
in[] = [ 1 3 6 6 6 6 7 7 12 12 17 ]
modes in[] mods[]
print mods[]
in[] = [ 1 1 2 4 4 ]
modes in[] mods[]
print mods[]
EchoLisp
(define (modes L)
(define G (group* L)) ;; sorts and group equal items
(define cardmax (for/max [(g G)] (length g)))
(map first (filter (lambda(g) (= cardmax (length g))) G)))
(modes '( a b c a d e f))
→ (a)
(modes (iota 6))
→ (0 1 2 3 4 5)
(modes '(x))
→ (x)
(modes '(🎾 🏉 ☕️ 🎾 🎲 🎯 🎺 ☕️ 🎲 🎸 🎻 🏆 ☕️ 🏁 🎾 🎲 🎻 🏉 ))
→ (🎾 ☕️ 🎲)
(modes '())
😖️ error: group : expected list : null 🔎 'modes'
Elena
ELENA 6.x:
import system'routines;
import system'collections;
import extensions;
extension op
{
get Mode()
{
var countMap := Dictionary.new(0);
self.forEach::(item)
{
countMap[item] := countMap[item] + 1
};
countMap := countMap.Values.sort::(p,n => p > n);
var max := countMap.FirstMember;
^ countMap
.filterBy::(kv => max.equal(kv.Value))
.selectBy::(kv => kv.Key)
.toArray()
}
}
public program()
{
var array1 := new int[]{1, 1, 2, 4, 4};
var array2 := new int[]{1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17};
var array3 := new object[]{1, "blue", 2, 7.5r, 5, "green", "red", 5, 2, "blue", "white"};
console
.printLine("mode of (",array1.asEnumerable(),") is (",array1.Mode,")")
.printLine("mode of (",array2.asEnumerable(),") is (",array2.Mode,")")
.printLine("mode of (",array3.asEnumerable(),") is (",array3.Mode,")")
.readChar()
}
- Output:
mode of (1,1,2,4,4) is (4,1) mode of (1,3,6,6,6,6,7,7,12,12,17) is (6) mode of (1,blue,2,7.5,5,green,red,5,2,blue,white) is (5,2,blue)
Elixir
defmodule Average do
def mode(list) do
gb = Enum.group_by(list, &(&1))
max = Enum.map(gb, fn {_,val} -> length(val) end) |> Enum.max
for {key,val} <- gb, length(val)==max, do: key
end
end
lists = [[3,1,4,1,5,9,2,6,5,3,5,8,9],
[1, 2, "qwe", "asd", 1, 2, "qwe", "asd", 2, "qwe"]]
Enum.each(lists, fn list ->
IO.puts "mode: #{inspect list}"
IO.puts " => #{inspect Average.mode(list)}"
end)
- Output:
mode: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9] => [5] mode: [1, 2, "qwe", "asd", 1, 2, "qwe", "asd", 2, "qwe"] => [2, "qwe"]
Erlang
-module( mode ).
-export( [example/0, values/1] ).
example() ->
Set = [1, 2, "qwe", "asd", 1, 2, "qwe", "asd", 2, "qwe"],
io:fwrite( "In ~p the mode(s) is(are): ~p~n", [Set, values(Set)] ).
values( Set ) ->
Dict = lists:foldl( fun values_count/2, dict:new(), Set ),
[X || {X, _Y} <- dict:fold( fun keep_maxs/3, [{0, 0}], Dict )].
keep_maxs( Key, Value, [{_Max_key, Max_value} | _] ) when Value > Max_value ->
[{Key, Value}];
keep_maxs( Key, Value, [{_Max_key, Max_value} | _]=Maxs ) when Value =:= Max_value ->
[{Key, Value} | Maxs];
keep_maxs( _Key, _Value, Maxs ) ->
Maxs.
values_count( Value, Dict ) -> dict:update_counter( Value, 1, Dict ).
- Output:
12> mode:example(). In [1, 2, "qwe", "asd", 1, 2, "qwe", "asd", 2, "qwe"] the mode(s) is(are): ["qwe", 2]
ERRE
PROGRAM MODE_AVG
!$INTEGER
DIM A[10],B[10],Z[10]
PROCEDURE SORT(Z[],P->Z[])
LOCAL N,FLIPS
FLIPS=TRUE
WHILE FLIPS DO
FLIPS=FALSE
FOR N=0 TO P-1 DO
IF Z[N]>Z[N+1] THEN SWAP(Z[N],Z[N+1]) FLIPS=TRUE
END FOR
END WHILE
END PROCEDURE
PROCEDURE CALC_MODE(Z[],P->MODES$)
LOCAL I,OCCURRENCE,MAXOCCURRENCE,OLDVAL
SORT(Z[],P->Z[])
OCCURENCE=1
MAXOCCURENCE=0
OLDVAL=Z[0]
MODES$=""
FOR I=1 TO P DO
IF Z[I]=OLDVAL THEN
OCCURENCE=OCCURENCE+1
ELSE
IF OCCURENCE>MAXOCCURENCE THEN
MAXOCCURENCE=OCCURENCE
MODES$=STR$(OLDVAL)
ELSIF OCCURENCE=MAXOCCURENCE THEN
MODES$=MODES$+STR$(OLDVAL)
ELSE
!$NULL
END IF
OCCURENCE=1
END IF
OLDVAL=Z[I]
END FOR
!check after loop
IF OCCURENCE>MAXOCCURENCE THEN
MAXOCCURENCE=OCCURENCE
MODES$=STR$(OLDVAL)
ELSIF OCCURENCE=MAXOCCURENCE THEN
MODES$=MODES$+STR$(OLDVAL)
ELSE
!$NULL
END IF
END PROCEDURE
BEGIN
A[]=(1,3,6,6,6,6,7,7,12,12,17)
B[]=(1,2,4,4,1)
PRINT("Modes for array A (1,3,6,6,6,6,7,7,12,12,17)";)
CALC_MODE(A[],10->MODES$)
PRINT(MODES$)
PRINT("Modes for array B (1,2,4,4,1)";)
CALC_MODE(B[],4->MODES$)
PRINT(MODES$)
END PROGRAM
- Output:
Modes for array A (1,3,6,6,6,6,7,7,12,12,17) 6 Modes for array B (1,2,4,4,1) 1 4
Euphoria
include misc.e
function mode(sequence s)
sequence uniques, counts, modes
integer j,max
uniques = {}
counts = {}
for i = 1 to length(s) do
j = find(s[i], uniques)
if j then
counts[j] += 1
else
uniques = append(uniques, s[i])
counts = append(counts, 1)
end if
end for
max = counts[1]
for i = 2 to length(counts) do
if counts[i] > max then
max = counts[i]
end if
end for
j = 1
modes = {}
while j <= length(s) do
j = find_from(max, counts, j)
if j = 0 then
exit
end if
modes = append(modes, uniques[j])
j += 1
end while
return modes
end function
constant s = { 1, "blue", 2, 7.5, 5, "green", "red", 5, 2, "blue", "white" }
pretty_print(1,mode(s),{3})
- Output:
{ "blue", 2, 5 }
F#
The Unchecked.defaultof became available in version 1.9.4 I think.
let mode (l:'a seq) =
l
|> Seq.countBy (fun item -> item) // Count individual items
|> Seq.fold // Find max counts
(fun (cp, lst) (item, c) -> // State is (count, list of items with that count)
if c > cp then (c, [item]) // New max - keep count and a list of the single item
elif c = cp then (c, item :: lst) // New element with max count - prepend it to the list
else (cp,lst)) // else just keep old count/list
(0, [Unchecked.defaultof<'a>]) // Start with a count of 0 and a dummy item
|> snd // From (count, list) we just want the second item (the list)
Example usage:
> mode ["a"; "b"; "c"; "c"];;
val it : string list = ["c"]
> mode ["a"; "b"; "c"; "c";"a"];;
val it : string list = ["c"; "a"]
> mode [1;2;1;3;2;0;0];;
val it : int list = [0; 2; 1]
Factor
Factor has the word mode
in math.statistics
vocabulary.
{ 11 9 4 9 4 9 } mode ! 9
Fortran
For the Qsort_Module see Sorting_algorithms/Quicksort#Fortran
program mode_test
use Qsort_Module only Qsort => sort
implicit none
integer, parameter :: S = 10
integer, dimension(S) :: a1 = (/ -1, 7, 7, 2, 2, 2, -1, 7, -3, -3 /)
integer, dimension(S) :: a2 = (/ 1, 1, 1, 1, 1, 0, 2, 2, 2, 2 /)
integer, dimension(S) :: a3 = (/ 0, 0, -1, -1, 9, 9, 3, 3, 7, 7 /)
integer, dimension(S) :: o
integer :: l, trash
print *, stat_mode(a1)
trash = stat_mode(a1, o, l)
print *, o(1:l)
trash = stat_mode(a2, o, l)
print *, o(1:l)
trash = stat_mode(a3, o, l)
print *, o(1:l)
contains
! stat_mode returns the lowest (if not unique) mode
! others can hold other modes, if the mode is not unique
! if others is provided, otherslen should be provided too, and
! it says how many other modes are there.
! ok can be used to know if the return value has a meaning
! or the mode can't be found (void arrays)
integer function stat_mode(a, others, otherslen, ok)
integer, dimension(:), intent(in) :: a
logical, optional, intent(out) :: ok
integer, dimension(size(a,1)), optional, intent(out) :: others
integer, optional, intent(out) :: otherslen
! ta is a copy of a, we sort ta modifying it, freq
! holds the frequencies and idx the index (for ta) so that
! the value appearing freq(i)-time is ta(idx(i))
integer, dimension(size(a, 1)) :: ta, freq, idx
integer :: rs, i, tm, ml, tf
if ( present(ok) ) ok = .false.
select case ( size(a, 1) )
case (0) ! no mode... ok is false
return
case (1)
if ( present(ok) ) ok = .true.
stat_mode = a(1)
return
case default
if ( present(ok) ) ok = .true.
ta = a ! copy the array
call sort(ta) ! sort it in place (cfr. sort algos on RC)
freq = 1
idx = 0
rs = 1 ! rs will be the number of different values
do i = 2, size(ta, 1)
if ( ta(i-1) == ta(i) ) then
freq(rs) = freq(rs) + 1
else
idx(rs) = i-1
rs = rs + 1
end if
end do
idx(rs) = i-1
ml = maxloc(freq(1:rs), 1) ! index of the max value of freq
tf = freq(ml) ! the max frequency
tm = ta(idx(ml)) ! the value with that freq
! if we want all the possible modes, we provide others
if ( present(others) ) then
i = 1
others(1) = tm
do
freq(ml) = 0
ml = maxloc(freq(1:rs), 1)
if ( tf == freq(ml) ) then ! the same freq
i = i + 1 ! as the max one
others(i) = ta(idx(ml))
else
exit
end if
end do
if ( present(otherslen) ) then
otherslen = i
end if
end if
stat_mode = tm
end select
end function stat_mode
end program mode_test
FreeBASIC
' FB 1.05.0 Win64
Sub quicksort(a() As Integer, first As Integer, last As Integer)
Dim As Integer length = last - first + 1
If length < 2 Then Return
Dim pivot As Integer = a(first + length\ 2)
Dim lft As Integer = first
Dim rgt As Integer = last
While lft <= rgt
While a(lft) < pivot
lft +=1
Wend
While a(rgt) > pivot
rgt -= 1
Wend
If lft <= rgt Then
Swap a(lft), a(rgt)
lft += 1
rgt -= 1
End If
Wend
quicksort(a(), first, rgt)
quicksort(a(), lft, last)
End Sub
' The modal value(s) is/are stored in 'm'.
' The function returns the modal count.
Function mode(a() As Integer, m() As Integer, sorted As Boolean = false) As Integer
Dim lb As Integer = LBound(a)
Dim ub As Integer = UBound(a)
If ub = -1 Then Return 0 '' empty array
If Not sorted Then quicksort(a(), lb, ub)
Dim cValue As Integer = a(lb)
Dim cCount As Integer = 1
Dim cMax As Integer = 0
'' We iterate to the end of the array plus 1 to ensure the
'' final value is dealt with properly
For i As Integer = lb + 1 To ub + 1
If i <= ub AndAlso a(i) = cValue Then
cCount += 1
Else
If cCount > cMax Then
Erase m
Redim m(1 To 1)
m(1) = cValue
cMax = cCount
ElseIf cCount = cMax Then
Redim Preserve m(1 To UBound(m) + 1)
m(UBound(m)) = cValue
End If
If i = ub + 1 Then Exit For
cValue = a(i)
cCount = 1
End If
Next
Return cMax
End Function
Dim a(1 To 14) As Integer = {1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6}
Dim m() As Integer '' to store the mode(s)
Dim mCount As Integer = mode(a(), m())
Print "The following are the modes which occur"; mCount; " times : "
For i As Integer = LBound(m) To UBound(m) : Print m(i); " "; : Next
Print
Print "Press any key to quit"
Sleep
- Output:
c:\FreeBasic>mode The following are the modes which occur 4 times : 2 3
Frink
modes[vals] :=
{
count = countToArray[vals]
biggest = count@0@1
result = new array
for i = rangeOf[count]
if count@i@1 < biggest
break // count is sorted so we can bail out when numbers decrease
else
result.push[count@i@0]
return result
}
println[modes[[1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]]]
println[modes[[1, 1, 2, 4, 4]]]
- Output:
[6] [1, 4]
As of the 2022-07-31 release of Frink, the function can be rewritten as:
modes[vals] := mostCommon[vals]@0
FutureBasic
FB has a native function for an array of mode averages.
local fn ModeAverage( arguments as CFArrayRef ) as CFStringRef
ExpressionRef expRef = fn ExpressionForFunction( @"mode:", @[fn ExpressionForConstantValue( arguments )] )
CFArrayRef modeArray = fn ExpressionValueWithObject( expRef, NULL, NULL )
CFNumberRef number
CFMutableStringRef modeStr = fn MutableStringNew
for number in modeArray
MutableStringAppendFormat( modeStr, @"value = %@\n", number )
next
end fn = modeStr
print fn ModeAverage( @[@1, @3, @6, @6, @6, @6, @7, @7, @12, @12, @12, @12, @17] )
HandleEvents
- Output:
value = 6 value = 12
GAP
mode := function(v)
local c, m;
c := Collected(SortedList(v));
m := Maximum(List(c, x -> x[2]));
return List(Filtered(c, x -> x[2] = m), y -> y[1]);
end;
mode([ 7, 5, 6, 1, 5, 5, 7, 12, 17, 6, 6, 5, 12, 3, 6 ]);
# [ 5, 6 ]
Go
Fixed collection type, fixed value type. In Go it is appropriate to program directly with built in types when possible.
package main
import "fmt"
func main() {
fmt.Println(mode([]int{2, 7, 1, 8, 2}))
fmt.Println(mode([]int{2, 7, 1, 8, 2, 8}))
}
func mode(a []int) []int {
m := make(map[int]int)
for _, v := range a {
m[v]++
}
var mode []int
var n int
for k, v := range m {
switch {
case v < n:
case v > n:
n = v
mode = append(mode[:0], k)
default:
mode = append(mode, k)
}
}
return mode
}
- Output:
[2] [2 8]
Fixed collection type, unspecified value type. An empty interface can hold any type. A slice []interface can hold a mix of types. It's not too much more source code, although there is some overhead to support this generality.
package main
import "fmt"
func main() {
fmt.Println(mode([]interface{}{.2, .7, .1, .8, .2}))
fmt.Println(mode([]interface{}{"two", 7, 1, 8, "two", 8}))
}
func mode(a []interface{}) []interface{} {
m := make(map[interface{}]int)
for _, v := range a {
m[v]++
}
var mode []interface{}
var n int
for k, v := range m {
switch {
case v < n:
case v > n:
n = v
mode = append(mode[:0], k)
default:
mode = append(mode, k)
}
}
return mode
}
- Output:
[0.2] [two 8]
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.
package main
import "fmt"
// interface type
type intCollection interface {
iterator() func() (int, bool)
}
// concrete type implements interface
type intSlice []int
// method on concrete type satisfies interface method
func (s intSlice) iterator() func() (int, bool) {
i := 0
return func() (int, bool) {
if i >= len(s) {
return 0, false
}
v := s[i]
i++
return v, true
}
}
func main() {
fmt.Println(mode(intSlice{2, 7, 1, 8, 2}))
fmt.Println(mode(intSlice{2, 7, 1, 8, 2, 8}))
}
// mode is now a generic function, in a sense.
// It knows what to do with an intCollection,
// but does not know the underlying concrete type.
func mode(a intCollection) []int {
m := make(map[int]int)
i := a.iterator()
for {
v, ok := i()
if !ok {
break
}
m[v]++
}
var mode []int
var n int
for k, v := range m {
switch {
case v < n:
case v > n:
n = v
mode = append(mode[:0], k)
default:
mode = append(mode, k)
}
}
return mode
}
- Output:
[2] [8 2]
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 interface{} instead of int. runeList is added to illustrate how multiple types can satisfy the same interface.
package main
import "fmt"
type collection interface {
iterator() func() (interface{}, bool)
}
type intSlice []int
func (s intSlice) iterator() func() (interface{}, bool) {
i := 0
return func() (interface{}, bool) {
if i >= len(s) {
return 0, false
}
v := s[i]
i++
return v, true
}
}
type runeList string
func (s runeList) iterator() func() (interface{}, bool) {
c := make(chan rune)
go func() {
for _, r := range s {
c <- r
}
close(c)
}()
return func() (interface{}, bool) {
r, ok := <-c
return string(r), ok
}
}
func main() {
fmt.Println(mode(intSlice{2, 7, 1, 8, 2}))
fmt.Println(mode(runeList("Enzyklopädie")))
}
func mode(a collection) []interface{} {
m := make(map[interface{}]int)
i := a.iterator()
for {
v, ok := i()
if !ok {
break
}
m[v]++
}
var mode []interface{}
var n int
for k, v := range m {
switch {
case v < n:
case v > n:
n = v
mode = append(mode[:0], k)
default:
mode = append(mode, k)
}
}
return mode
}
- Output:
("Enzyklopädie" has no repeated letters. All are modal.)
[2] [e d i k l o n p y z E ä]
Groovy
Solution, both "collection type" and "element type" agnostic:
def mode(Iterable col) {
assert col
def m = [:]
col.each {
m[it] = m[it] == null ? 1 : m[it] + 1
}
def keys = m.keySet().sort { -m[it] }
keys.findAll { m[it] == m[keys[0]] }
}
Test:
def random = new Random()
def sourceList = [ 'Lamp', 42.0, java.awt.Color.RED, new Date(), ~/pattern/]
(0..10).each {
def a = (0..10).collect { sourceList[random.nextInt(5)] }
println "${mode(a)} == mode(${a})"
}
- Output:
[pattern] == mode([pattern, pattern, pattern, Lamp, pattern, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], Lamp, Lamp, Lamp, pattern]) [Lamp] == mode([Lamp, Fri Oct 28 23:43:20 CDT 2011, Lamp, java.awt.Color[r=255,g=0,b=0], 42.0, java.awt.Color[r=255,g=0,b=0], Fri Oct 28 23:43:20 CDT 2011, Lamp, pattern, pattern, 42.0]) [java.awt.Color[r=255,g=0,b=0]] == mode([java.awt.Color[r=255,g=0,b=0], java.awt.Color[r=255,g=0,b=0], 42.0, 42.0, Fri Oct 28 23:43:20 CDT 2011, Fri Oct 28 23:43:20 CDT 2011, 42.0, java.awt.Color[r=255,g=0,b=0], pattern, pattern, java.awt.Color[r=255,g=0,b=0]]) [Fri Oct 28 23:43:20 CDT 2011] == mode([Fri Oct 28 23:43:20 CDT 2011, pattern, 42.0, Fri Oct 28 23:43:20 CDT 2011, Lamp, pattern, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], 42.0, 42.0, Fri Oct 28 23:43:20 CDT 2011]) [Fri Oct 28 23:43:20 CDT 2011, Lamp] == mode([42.0, Fri Oct 28 23:43:20 CDT 2011, Lamp, Lamp, Fri Oct 28 23:43:20 CDT 2011, Fri Oct 28 23:43:20 CDT 2011, 42.0, Lamp, java.awt.Color[r=255,g=0,b=0], Lamp, Fri Oct 28 23:43:20 CDT 2011]) [java.awt.Color[r=255,g=0,b=0]] == mode([Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], java.awt.Color[r=255,g=0,b=0], pattern, 42.0, java.awt.Color[r=255,g=0,b=0], java.awt.Color[r=255,g=0,b=0], 42.0, pattern, Fri Oct 28 23:43:20 CDT 2011, pattern]) [42.0, java.awt.Color[r=255,g=0,b=0]] == mode([42.0, java.awt.Color[r=255,g=0,b=0], pattern, Fri Oct 28 23:43:20 CDT 2011, Lamp, java.awt.Color[r=255,g=0,b=0], Lamp, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], 42.0, 42.0]) [Fri Oct 28 23:43:20 CDT 2011] == mode([java.awt.Color[r=255,g=0,b=0], pattern, Fri Oct 28 23:43:20 CDT 2011, Lamp, 42.0, Fri Oct 28 23:43:20 CDT 2011, Fri Oct 28 23:43:20 CDT 2011, pattern, java.awt.Color[r=255,g=0,b=0], Lamp, Fri Oct 28 23:43:20 CDT 2011]) [Fri Oct 28 23:43:20 CDT 2011] == mode([Fri Oct 28 23:43:20 CDT 2011, pattern, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], pattern, Fri Oct 28 23:43:20 CDT 2011, 42.0, java.awt.Color[r=255,g=0,b=0], Lamp, Fri Oct 28 23:43:20 CDT 2011, 42.0]) [pattern] == mode([42.0, pattern, pattern, Lamp, 42.0, Lamp, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], pattern, 42.0, pattern]) [Lamp, 42.0] == mode([Fri Oct 28 23:43:20 CDT 2011, pattern, Lamp, Lamp, Lamp, java.awt.Color[r=255,g=0,b=0], Fri Oct 28 23:43:20 CDT 2011, 42.0, 42.0, pattern, 42.0])
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
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:
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)
Another version that does not require an orderable type:
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
Icon and Unicon
The mode procedure generates all n mode values if the collection is n-modal.
- Sample outputs:
->am 3 1 4 1 5 9 7 6 1 ->am 3 1 4 1 5 9 7 6 3 3 1 ->
J
mode=: ~. #~ ( = >./ )@( #/.~ )
Literally: select from the unique values the values which appear the most often.
Example:
mode 1 1 2 2 3 3 4 4 4 5 5 6 6 7 8 8 9 9 0 0 0 4 0 mode 1 3 6 6 6 6 7 7 12 12 17 6 mode 1 2 4 4 1 1 4
Jakt
An empty set is returned if the iterable is empty.
fn mode<T, U>(anon iterable: U) throws -> {T} {
mut dictionary = Dictionary<T, u64>()
for item in iterable {
if dictionary.contains(item) {
dictionary[item]++
} else {
dictionary[item] = 1
}
}
mut items = dictionary.iterator()
let mode = items.next()
if not mode.has_value() {
let empty_set: {T} = {}
return empty_set
}
mut modes = [mode.value()]
for item in items {
if item.1 > modes[0].1 {
modes = [item]
} else if item.1 == modes[0].1 {
modes.push(item)
}
}
mut mode_set: {T} = {}
for mode in modes {
mode_set.add(mode.0)
}
return mode_set
}
fn main() {
println("{}", mode<i64>([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]))
println("{}", mode<i64>([1, 1, 2, 4, 4]))
let empty_array: [i64] = []
println("{}", mode<i64>(empty_array))
let test_string = "abcabbcaca"
println("{}", mode<u32>(test_string.code_points()))
}
Java
import java.util.*;
public class Mode {
public static <T> List<T> mode(List<? extends T> coll) {
Map<T, Integer> seen = new HashMap<T, Integer>();
int max = 0;
List<T> maxElems = new ArrayList<T>();
for (T value : coll) {
if (seen.containsKey(value))
seen.put(value, seen.get(value) + 1);
else
seen.put(value, 1);
if (seen.get(value) > max) {
max = seen.get(value);
maxElems.clear();
maxElems.add(value);
} else if (seen.get(value) == max) {
maxElems.add(value);
}
}
return maxElems;
}
public static void main(String[] args) {
System.out.println(mode(Arrays.asList(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17))); // prints [6]
System.out.println(mode(Arrays.asList(1, 1, 2, 4, 4))); // prints [1, 4]
}
}
JavaScript
function mode(ary) {
var counter = {};
var mode = [];
var max = 0;
for (var i in ary) {
if (!(ary[i] in counter))
counter[ary[i]] = 0;
counter[ary[i]]++;
if (counter[ary[i]] == max)
mode.push(ary[i]);
else if (counter[ary[i]] > max) {
max = counter[ary[i]];
mode = [ary[i]];
}
}
return mode;
}
mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]); // [6]
mode([1, 2, 4, 4, 1]); // [1,4]
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.
jq's sort is very fast in any case.
# modes/0 produces an array of [value, count]
# in increasing order of count:
def modes:
sort | reduce .[] as $i ([];
# state variable is an array of [value, count]
if length == 0 then [ [$i, 1] ]
elif .[-1][0] == $i then setpath([-1,1]; .[-1][1] + 1)
else . + [[$i,1]]
end )
| sort_by( .[1] );
# mode/0 outputs a stream of the modal values;
# if the input array is empty, the output stream is also empty.
def mode:
if length == 0 then empty
else modes as $modes
| $modes[-1][1] as $count
| $modes[] | select( .[1] == $count) | .[0]
end;
Examples:
[1,2,3,1,2,1] | mode # => 1
[1,2,3,1,2,1,2] | mode # => 1 2
[1.1, 1.2, 1.3, 1.1, 1.2, 1.1] | mode) # => 1.1
Julia
function modes(values)
dict = Dict() # Values => Number of repetitions
modesArray = typeof(values[1])[] # Array of the modes so far
max = 0 # Max of repetitions so far
for v in values
# Add one to the dict[v] entry (create one if none)
if v in keys(dict)
dict[v] += 1
else
dict[v] = 1
end
# Update modesArray if the number of repetitions
# of v reaches or surpasses the max value
if dict[v] >= max
if dict[v] > max
empty!(modesArray)
max += 1
end
append!(modesArray, [v])
end
end
return modesArray
end
println(modes([1,3,6,6,6,6,7,7,12,12,17]))
println(modes((1,1,2,4,4)))
K
mode: {(?x)@&n=|/n:#:'=x}
mode 1 1 1 1 2 2 2 3 3 3 3 4 4 3 2 4 4 4
3 4
Kotlin
fun <T> modeOf(a: Array<T>) {
val sortedByFreq = a.groupBy { it }.entries.sortedByDescending { it.value.size }
val maxFreq = sortedByFreq.first().value.size
val modes = sortedByFreq.takeWhile { it.value.size == maxFreq }
if (modes.size == 1)
println("The mode of the collection is ${modes.first().key} which has a frequency of $maxFreq")
else {
print("There are ${modes.size} modes with a frequency of $maxFreq, namely : ")
println(modes.map { it.key }.joinToString(", "))
}
}
fun main(args: Array<String>) {
val a = arrayOf(7, 1, 1, 6, 2, 4, 2, 4, 2, 1, 5)
println("[" + a.joinToString(", ") + "]")
modeOf(a)
println()
val b = arrayOf(true, false, true, false, true, true)
println("[" + b.joinToString(", ") + "]")
modeOf(b)
}
- Output:
[7, 1, 1, 6, 2, 4, 2, 4, 2, 1, 5] There are 2 modes with a frequency of 3, namely : 1, 2 [true, false, true, false, true, true] The mode of the collection is true which has a frequency of 4
Lasso
define getmode(a::array)::array => {
local(mmap = map, maxv = 0, modes = array)
// store counts
with e in #a do => { #mmap->keys >> #e ? #mmap->find(#e) += 1 | #mmap->insert(#e = 1) }
// get max value
with e in #mmap->keys do => { #mmap->find(#e) > #maxv ? #maxv = #mmap->find(#e) }
// get modes with max value
with e in #mmap->keys where #mmap->find(#e) == #maxv do => { #modes->insert(#e) }
return #modes
}
getmode(array(1,3,6,6,6,6,7,7,12,12,17))
getmode(array(1,3,6,3,4,8,9,1,2,3,2,2))
- Output:
array(6) array(2, 3)
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"
print "Modes for ";a$
print modes$(a$)
print "Modes for ";b$
print modes$(b$)
function modes$(a$)
'get array size
n=0
t$ = "*"
while t$<>""
n=n+1
t$=word$(a$, n)
'print n, t$
wend
n=n-1
'print "n=", n
'dim array
'read in array
redim a(n)
for i = 1 to n
a(i)=val(word$(a$, i))
'print i, a(i)
next
'sort
sort a(), 1, n
'get the modes
occurence = 1
maxOccurence = 0
oldVal = a(1)
modes$ = ""
for i = 2 to n
'print i, a(i)
if a(i) = oldVal then
occurence = occurence + 1
else
select case
case occurence > maxOccurence
maxOccurence = occurence
modes$ = oldVal; " "
case occurence = maxOccurence
modes$ = modes$; oldVal; " "
end select
occurence = 1
end if
oldVal = a(i)
next
'check after loop
select case
case occurence > maxOccurence
maxOccurence = occurence
modes$ = oldVal; " "
case occurence = maxOccurence
modes$ = modes$; oldVal; " "
end select
end function
- Output:
Modes for 1 3 6 6 6 6 7 7 12 12 17 6 Modes for 1 2 4 4 1 1 4
Lua
function mode(tbl) -- returns table of modes and count
assert(type(tbl) == 'table')
local counts = { }
for _, val in pairs(tbl) do
-- see http://lua-users.org/wiki/TernaryOperator
counts[val] = counts[val] and counts[val] + 1 or 1
end
local modes = { }
local modeCount = 0
for key, val in pairs(counts) do
if val > modeCount then
modeCount = val
modes = {key}
elseif val == modeCount then
table.insert(modes, key)
end
end
return modes, modeCount
end
modes, count = mode({1,3,6,6,6,6,7,7,12,12,17})
for _, val in pairs(modes) do io.write(val..' ') end
print("occur(s) ", count, " times")
modes, count = mode({'a', 'a', 'b', 'd', 'd'})
for _, val in pairs(modes) do io.write(val..' ') end
print("occur(s) ", count, " times")
M2000 Interpreter
We use Inventory with keys as numbers (internal are strings). Inventories work with hash function. So searching is very fast.
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
Function GetMode {
Inventory N
Inventory ALLMODES
m=1
While not empty {
if islet then {
Read A$
if Exist(N, A$) then {
k=Eval(N)
k++
if m=k then {
Append ALLMODES, A$
}
if m<k then m=k : Clear ALLMODES : Append ALLMODES, A$
return N, A$:=k
} Else Append N, A$:=1 : if m=1 then Append ALLMODES, A$
} else {
Read A
if Exist(N, A) then {
k=Eval(N)
k++
if m=k then {
Append ALLMODES, A
}
if m<k then m=k : Clear ALLMODES : Append ALLMODES, A
return N, A:=k
} Else Append N, A:=1 : if m=1 then Append ALLMODES, A
}
}
=ALLMODES
}
Print GetMode(1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6) ' print 2 3
Dim A()
A()=(1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6)
\\ get a pointer from A
m=A()
Print GetMode(!m) ' print 2 3
z=stack:=1, 2,"B", 3, 1, 2, "B", 4, 2, 5,"B", 2, 3, 3, 1, 3, 6, "B"
Print GetMode(!z) ' print 2 3 B
}
Checkit
Using idea from BBC BASIC. Function GetMode return array. As Array get bigger function run slower exponential. Previous example using inventory, has linear response (double data, double time to run). Eacb function has a mew stack of value. This one line function Def AllStack()=[] get all arguments and place them in a stack object, and a pointer to stack returned. This function return an array: Def AllArray=Array([]). We can use (,) for empty array, (1,) for one item array, (1,2,3) for three item. We can use ((1,2),(3,4)) for an array with two arrays as items. We can use Stack for empty stack, or Stack:=1,2,3 for a stack with 3 items. Stacks are linked lists. A=Stack : Stack A { push 1,2,3 } : Print A ' print 3 2 1 where 3 is the top. Stack A (Data 0} : Print A ' print 3 2 1 0 (data push to bottom to stack). Functions and Modules always have a "current stack". So M2000 is like basic but is a stack oriented language, but for expressions use infix notation.
Module Checkit {
Function GetMode(&a()){
Local max%
if len(a())=0 then =(,)
link a() to a$()
n%=len(a())
dim c%(n%)
if type$(a(0))="String" then {
For i%=0 to n%-2
For j%=i%+1 to n%-1
if order(a$(i%), a$(j%))=0 then c%(i%)++
Next j%
If c%(i%)>max% Then max%=c%(i%)
Next i%
For i%=0 to n%-1
If c%(i%) = max% Then Data a$(i%)
Next i%
} Else {
For i%=0 to n%-2
For j%=i%+1 to n%-1
if a(i%)==a(j%) then c%(i%)++
Next j%
If c%(i%)>max% Then max%=c%(i%)
Next i%
For i%=0 to n%-1
If c%(i%) = max% Then Data a(i%)
Next i%
}
=Array([])
}
Dim m()
m()=(2,3,43,234,234,3,324)
Print GetMode(&m()) ' 3 234
k=(1,2,1,2,1,2,3)
n=GetMode(&k)
' iterate backward
i=each(n, -1, 1)
While i {
Print Array(i),
}
Print
k=("A","B","A","B", "B","C","D","A")
? GetMode(&k) ' A B
}
Checkit
Maple
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]);
Statistics:-Mode([1, 2.1, 2.1, 3.2, 3.2, 5]);
- Output:
2.1 {2.1, 3.2}
Mathematica / 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[{b, a, c, 2, a, b, 1, 2, 3}]
Commonest[{1, 3, 2, 3}]
- Output:
{b,a,2} {3}
MATLAB
function modeValue = findmode(setOfValues)
modeValue = mode(setOfValues);
end
MUMPS
MODE(X)
;X is assumed to be a list of numbers separated by "^"
;I is a loop index
;L is the length of X
;Y is a new array
;ML is the list of modes
;LOC is a placeholder to shorten the statement
Q:'$DATA(X) "No data"
Q:X="" "Empty Set"
NEW Y,I,L,LOC
SET L=$LENGTH(X,"^"),ML=""
FOR I=1:1:L SET LOC=+$P(X,"^",I),Y(LOC)=$S($DATA(Y(LOC)):Y(LOC)+1,1:1)
SET I="",I=$O(Y(I)),ML=I ;Prime the pump, rather than test for no data
FOR S I=$O(Y(I)) Q:I="" S ML=$SELECT(Y($P(ML,"^"))>Y(I):ML,Y($P(ML,"^"))<Y(I):I,Y($P(ML,"^"))=Y(I):ML_"^"_I)
QUIT ML
USER>W $$MODE^ROSETTA("1^2^3^2") 2 USER>W $$MODE^ROSETTA("1^2^3^2^3") 2^3 USER>W $$MODE^ROSETTA("") Empty Set
NetRexx
/* NetRexx */
options replace format comments java crossref symbols nobinary
run_samples()
return
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method mode(lvector = java.util.List) public static returns java.util.List
seen = 0
modes = ''
modeMax = 0
loop v_ = 0 to lvector.size() - 1
mv = Rexx lvector.get(v_)
seen[mv] = seen[mv] + 1
select
when seen[mv] > modeMax then do
modeMax = seen[mv]
modes = ''
nx = 1
modes[0] = nx
modes[nx] = mv
end
when seen[mv] = modeMax then do
nx = modes[0] + 1
modes[0] = nx
modes[nx] = mv
end
otherwise do
nop
end
end
end v_
modeList = ArrayList(modes[0])
loop v_ = 1 to modes[0]
val = modes[v_]
modeList.add(val)
end v_
return modeList
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method mode(rvector = Rexx[]) public static returns java.util.List
return mode(ArrayList(Arrays.asList(rvector)))
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method show_mode(lvector = java.util.List) public static returns java.util.List
modes = mode(lvector)
say 'Vector:' (Rexx lvector).space(0)', Mode(s):' (Rexx modes).space(0)
return modes
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method show_mode(rvector = Rexx[]) public static returns java.util.List
return show_mode(ArrayList(Arrays.asList(rvector)))
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method run_samples() public static
show_mode([Rexx 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) -- 10 9 8 7 6 5 4 3 2 1
show_mode([Rexx 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0.11]) -- 0
show_mode([Rexx 30, 10, 20, 30, 40, 50, -100, 4.7, -11e+2]) -- 30
show_mode([Rexx 30, 10, 20, 30, 40, 50, -100, 4.7, -11e+2, -11e+2]) -- 30 -11e2
show_mode([Rexx 1, 8, 6, 0, 1, 9, 4, 6, 1, 9, 9, 9]) -- 9
show_mode([Rexx 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) -- 1 2 3 4 5 6 7 8 9 10 11
show_mode([Rexx 8, 8, 8, 2, 2, 2]) -- 8 2
show_mode([Rexx 'cat', 'kat', 'Cat', 'emu', 'emu', 'Kat']) -- emu
show_mode([Rexx 0, 1, 2, 3, 3, 3, 4, 4, 4, 4, 1, 0]) -- 4
show_mode([Rexx 2, 7, 1, 8, 2]) -- 2
show_mode([Rexx 2, 7, 1, 8, 2, 8]) -- 8 2
show_mode([Rexx 'E', 'n', 'z', 'y', 'k', 'l', 'o', 'p', 'ä', 'd', 'i', 'e']) -- E n z y k l o p ä d i e
show_mode([Rexx 'E', 'n', 'z', 'y', 'k', 'l', 'o', 'p', 'ä', 'd', 'i', 'e', 'ä']) -- ä
show_mode([Rexx 3, 1, 4, 1, 5, 9, 7, 6]) -- 1
show_mode([Rexx 3, 1, 4, 1, 5, 9, 7, 6, 3]) -- 3, 1
show_mode([Rexx 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]) -- 6
show_mode([Rexx 1, 1, 2, 4, 4]) -- 4 1
return
Output:
Vector: [10,9,8,7,6,5,4,3,2,1], Mode(s): [10,9,8,7,6,5,4,3,2,1] Vector: [10,9,8,7,6,5,4,3,2,1,0,0,0,0,0.11], Mode(s): [0] Vector: [30,10,20,30,40,50,-100,4.7,-1100], Mode(s): [30] Vector: [30,10,20,30,40,50,-100,4.7,-1100,-1100], Mode(s): [30,-1100] Vector: [1,8,6,0,1,9,4,6,1,9,9,9], Mode(s): [9] Vector: [1,2,3,4,5,6,7,8,9,10,11], Mode(s): [1,2,3,4,5,6,7,8,9,10,11] Vector: [8,8,8,2,2,2], Mode(s): [8,2] Vector: [cat,kat,Cat,emu,emu,Kat], Mode(s): [emu] Vector: [0,1,2,3,3,3,4,4,4,4,1,0], Mode(s): [4] Vector: [2,7,1,8,2], Mode(s): [2] Vector: [2,7,1,8,2,8], Mode(s): [2,8] Vector: [E,n,z,y,k,l,o,p,ä,d,i,e], Mode(s): [E,n,z,y,k,l,o,p,ä,d,i,e] Vector: [E,n,z,y,k,l,o,p,ä,d,i,e,ä], Mode(s): [ä] Vector: [3,1,4,1,5,9,7,6], Mode(s): [1] Vector: [3,1,4,1,5,9,7,6,3], Mode(s): [1,3] Vector: [1,3,6,6,6,6,7,7,12,12,17], Mode(s): [6] Vector: [1,1,2,4,4], Mode(s): [1,4]
Nim
import tables
proc modes[T](xs: openArray[T]): T =
var count = initCountTable[T]()
for x in xs:
count.inc(x)
largest(count).key
echo modes(@[1,3,6,6,6,6,7,7,12,12,17])
echo modes(@[1,1,2,4,4])
Output:
6 1
Oberon-2
MODULE Mode;
IMPORT
Object:Boxed,
ADT:Dictionary,
ADT:LinkedList,
Out := NPCT:Console;
TYPE
Key = Boxed.LongInt;
Val = Boxed.LongInt;
VAR
x: ARRAY 11 OF LONGINT;
y: ARRAY 5 OF LONGINT;
z: ARRAY 8 OF LONGINT;
PROCEDURE Show(ll: LinkedList.LinkedList(Key));
VAR
iter: LinkedList.Iterator(Key);
i: LONGINT;
k: Key;
BEGIN
iter := ll.GetIterator(NIL);
FOR i := 0 TO ll.Size() - 1 DO;
k := iter.Next();
Out.Int(k.value,0);Out.Ln;
END;
END Show;
PROCEDURE Mode(x: ARRAY OF LONGINT): LinkedList.LinkedList(Key);
VAR
d: Dictionary.Dictionary(Key,Val);
i: LONGINT;
k: Key; v: Val;
iter: Dictionary.IterKeys(Key,Val);
resp: LinkedList.LinkedList(Key);
max: Boxed.LongInt;
BEGIN
d := NEW(Dictionary.Dictionary(Key,Val));
FOR i := 0 TO LEN(x) - 1 DO
k := NEW(Key,x[i]);
IF d.Lookup(k,v) THEN
d.Set(k,NEW(Val,v.value + 1));
ELSE
d.Set(k,NEW(Val,1))
END
END;
max := NEW(Boxed.LongInt,0);
resp := NEW(LinkedList.LinkedList(Key));
iter := d.IterKeys();
WHILE (iter.Next(k)) DO
v := d.Get(k);
IF v.Cmp(max) > 0 THEN
resp.Clear();
resp.Append(k);max := v
ELSIF v.Cmp(max) = 0 THEN
resp.Append(k);max := v
END
END;
RETURN resp
END Mode;
BEGIN
x[0] := 1; x[1] := 3; x[2] := 6; x[3] := 6;
x[4] := 6; x[5] := 6; x[6] := 7; x[7] := 7;
x[8] := 12; x[9] := 12; x[10] := 17;
Show(Mode(x));Out.Ln;
y[0] := 1; y[1] := 2; y[2] := 4; y[3] := 4; y[4] := 1;
Show(Mode(y));Out.Ln;
z[0] := 1; z[1] := 2; z[2] := 4; z[3] := 4; z[4] := 1; z[5] := 5; z[6] := 5; z[7] := 5;
Show(Mode(z));Out.Ln;
END Mode.
{{out}
6 4 1 5
Objeck
use Collection;
class Mode {
function : Main(args : String[]) ~ Nil {
Print(Mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]));
Print(Mode([1, 2, 4, 4, 1]));
}
function : Mode(coll : Int[]) ~ IntVector {
seen := IntMap->New();
max := 0;
maxElems := IntVector->New();
each(i : coll) {
value := coll[i];
featched := seen->Find(value)->As(IntHolder);
if(featched <> Nil) {
seen->Remove(value);
seen->Insert(value, IntHolder->New(featched->Get() + 1));
}
else {
seen->Insert(value, IntHolder->New(1));
};
featched := seen->Find(value)->As(IntHolder);
if(featched->Get() > max) {
max := featched->Get();
maxElems->Empty();
maxElems->AddBack(value);
}
else if(featched->Get() = max) {
maxElems->AddBack(value);
};
};
return maxElems;
}
function : Print(out : IntVector) ~ Nil {
'['->Print();
each(i : out) {
out->Get(i)->Print();
if(i + 1 < out->Size()) {
", "->Print();
};
};
']'->PrintLine();
}
}
Objective-C
#import <Foundation/Foundation.h>
@interface NSArray (Mode)
- (NSArray *)mode;
@end
@implementation NSArray (Mode)
- (NSArray *)mode {
NSCountedSet *seen = [NSCountedSet setWithArray:self];
int max = 0;
NSMutableArray *maxElems = [NSMutableArray array];
for ( obj in seen ) {
int count = [seen countForObject:obj];
if (count > max) {
max = count;
[maxElems removeAllObjects];
[maxElems addObject:obj];
} else if (count == max) {
[maxElems addObject:obj];
}
}
return maxElems;
}
@end
OCaml
let mode lst =
let seen = Hashtbl.create 42 in
List.iter (fun x ->
let old = if Hashtbl.mem seen x then
Hashtbl.find seen x
else 0 in
Hashtbl.replace seen x (old + 1))
lst;
let best = Hashtbl.fold (fun _ -> max) seen 0 in
Hashtbl.fold (fun k v acc ->
if v = best then k :: acc
else acc)
seen []
# mode [1;3;6;6;6;6;7;7;12;12;17];; - : int list = [6] # mode [1;1;2;4;4];; - : int list = [4; 1]
Octave
Of course Octave has the mode function; but it returns only the "lowest" mode if multiple modes are available.
function m = mode2(v)
sv = sort(v);
% build two vectors, vals and c, so that
% c(i) holds how many times vals(i) appears
i = 1; c = []; vals = [];
while (i <= numel(v) )
tc = sum(sv==sv(i)); % it would be faster to count
% them "by hand", since sv is sorted...
c = [c, tc];
vals = [vals, sv(i)];
i += tc;
endwhile
% stack vals and c building a 2-rows matrix x
x = cat(1,vals,c);
% sort the second row (frequencies) into t (most frequent
% first) and take the "original indices" i ...
[t, i] = sort(x(2,:), "descend");
% ... so that we can use them to sort columns according
% to frequencies
nv = x(1,i);
% at last, collect into m (the result) all the values
% having the same bigger frequency
r = t(1); i = 1;
m = [];
while ( t(i) == r )
m = [m, nv(i)];
i++;
endwhile
endfunction
a = [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17];
mode2(a)
mode(a)
a = [1, 1, 2, 4, 4];
mode2(a) % returns 1 and 4
mode(a) % returns 1 only
ooRexx
See the example at 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)
call testMode .list~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11)
call testMode .queue~of(30, 10, 20, 30, 40, 50, -100, 4.7, -11e2)
::routine testMode
use arg list
say "list =" list~makearray~toString("l", ", ")
say "mode =" mode(list)
say
::routine mode
use arg list
-- this is a good application for a bag
-- add all of the items to the bag
collector = .bag~new
collector~putAll(list)
-- now get a list of unique items
indexes = .set~new~~putall(collector)
count = 0 -- this is used to keep track of the maximums
-- now see how many of each element we ended up with
loop index over indexes
items = collector~allat(index)
newCount = items~items
if newCount > count then do
mode = items[1]
count = newCount
end
end
return mode
Oz
declare
fun {Mode Xs}
Freq = {Dictionary.new}
for X in Xs do
Freq.X := {CondSelect Freq X 0} + 1
end
MaxCount = {FoldL {Dictionary.items Freq} Max 0}
in
for Value#Count in {Dictionary.entries Freq} collect:C do
if Count == MaxCount then
{C Value}
end
end
end
in
{Show {Mode [1 2 3 3 2 1 1]}}
{Show {Mode [1 2 3 3 2 1]}}
PARI/GP
mode(v)={
my(count=1,r=1,b=v[1]);
v=vecsort(v);
for(i=2,#v,
if(v[i]==v[i-1],
count++
,
if(count>r,
r=count;
b=v[i-1]
);
count=1
)
);
if(count>r,v[#v],b)
};
Perl
use strict;
use List::Util qw(max);
sub mode
{
my %c;
foreach my $e ( @_ ) {
$c{$e}++;
}
my $best = max(values %c);
return grep { $c{$_} == $best } keys %c;
}
print "$_ " foreach mode(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17);
print "\n";
print "$_ " foreach mode(1, 1, 2, 4, 4);
print "\n";
Phix
function mode(sequence s) -- returns a list of the most common values, each of which occurs the same number of times integer nxt = 1, count = 1, maxc = 1 sequence res = {} if length(s)!=0 then s = sort(s) object prev = s[1] for i=2 to length(s) do if s[i]!=prev then s[nxt] = {count,prev} nxt += 1 prev = s[i] count = 1 else count += 1 if count>maxc then maxc = count end if end if end for s[nxt] = {count,prev} res = "" for i=1 to nxt do if s[i][1]=maxc then res = append(res,s[i][2]) end if end for end if return res end function ?mode({1, 2, 5, -5, -9.5, 3.14159}) ?mode({ 1, "blue", 2, 7.5, 5, "green", "red", 5, 2, "blue", "white" }) ?mode({1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6}) ?mode({.2, .7, .1, .8, .2}) ?mode({"two", 7, 1, 8, "two", 8}) ?mode("Hello there world") ?mode({}) {} = wait_key()
- Output:
{-9.5,-5,1,2,3.14159,5} {2,5,"blue"} {2,3} {0.2} {8,"two"} "el" {}
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.
<?php
function mode($arr) {
$count = array_count_values($arr);
$best = max($count);
return array_keys($count, $best);
}
print_r(mode(array(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17)));
print_r(mode(array(1, 1, 2, 4, 4)));
?>
PicoLisp
(de modes (Lst)
(let A NIL
(for X Lst
(accu 'A X 1) )
(mapcar car
(maxi cdar
(by cdr group A) ) ) ) )
- Output:
: (modes (1 3 6 6 6 6 7 7 12 12 17)) -> (6) : (modes (1 1 2 4 4)) -> (4 1) : (modes (chop "ABRAHAMASANTACLARA")) -> ("A") : (modes (1 4 A 3 2 7 1 B B 3 6 2 4 C C 5 2 5 B A 3 2 C 3 5 5 4 C 7 7)) -> (5 C 2 3)
PL/I
av: procedure options (main); /* 28 October 2013 */
declare x(10) fixed binary static initial (1, 4, 2, 6, 2, 5, 6, 2, 4, 2);
declare f(32767) fixed binary;
declare (j, n, max, value) fixed binary;
declare i fixed;
n = hbound(x,1);
do i = 1 to n;
j = x(i);
f(j) = f(j) + 1;
end;
max = 0;
do i = 1 to hbound(f,1);
if max < f(i) then do; max = f(i); value = i; end;
end;
put list ('The mode value is ' || value || ' occurred ' ||
max || ' times.');
end av;
Results:
The mode value is 2 occurred 4 times.
PowerShell
$data = @(1,1,1,2,3,4,5,5,6,7,7,7)
$groups = $data | group-object | sort-object count -Descending
$groups | ? {$_.Count -eq $groups[0].Count}
- Output:
Count Name Group ----- ---- ----- 3 7 {7, 7, 7} 3 1 {1, 1, 1}
PureBasic
Procedure mean(Array InArray(1))
Structure MyMean
Value.i
Cnt.i
EndStructure
Protected i, max, found
Protected NewList MyDatas.MyMean()
Repeat
found=#False
ForEach MyDatas()
If InArray(i)=MyDatas()\Value
MyDatas()\Cnt+1
found=#True
Break
EndIf
Next
If Not found
AddElement(MyDatas())
MyDatas()\Value=InArray(i)
MyDatas()\cnt+1
EndIf
If MyDatas()\Cnt>max
max=MyDatas()\Cnt
EndIf
i+1
Until i>ArraySize(InArray())
ForEach MyDatas()
If MyDatas()\Cnt=max
For i=1 To max
Print(Str(MyDatas()\Value)+" ")
Next
EndIf
Next
EndProcedure
Python
The following solutions require that the elements be hashable.
>>> from collections import defaultdict
>>> def modes(values):
count = defaultdict(int)
for v in values:
count[v] +=1
best = max(count.values())
return [k for k,v in count.items() if v == best]
>>> modes([1,3,6,6,6,6,7,7,12,12,17])
[6]
>>> modes((1,1,2,4,4))
[1, 4]
>>> from collections import Counter
>>> def modes(values):
count = Counter(values)
best = max(count.values())
return [k for k,v in count.items() if v == best]
>>> modes([1,3,6,6,6,6,7,7,12,12,17])
[6]
>>> modes((1,1,2,4,4))
[1, 4]
If you just want one mode (instead of all of them), here's a one-liner for that:
def onemode(values):
return max(set(values), key=values.count)
Q
mode:{(key x) where value x=max x} count each group @
Quackery
[ sort
[] [] rot
dup 0 peek temp put
witheach
[ dup temp share = iff
join
else
[ dup temp replace
dip [ nested join ]
[] join ] ]
nested join
temp release ] is bunch ( [ --> [ )
[ sortwith [ size dip size < ]
[] swap
dup 0 peek size temp put
witheach
[ dup size temp share = iff
[ nested join ]
else
[ drop conclude ] ]
temp release
[] swap
witheach
[ 0 peek join ] ] is largest ( [ --> [ )
[ bunch largest ] is mode ( [ --> [ )
' [ 1 3 5 7 3 1 3 7 7 3 3 ] mode echo cr
' [ 7 13 5 13 7 2 7 10 13 ] mode echo cr
' [ 5 ] mode echo cr
- Output:
[ 3 ] [ 7 13 ] [ 5 ]
R
statmode <- function(v) {
a <- sort(table(v), decreasing=TRUE)
r <- c()
for(i in 1:length(a)) {
if ( a[[1]] == a[[i]] ) {
r <- c(r, as.integer(names(a)[i]))
} else break; # since it's sorted, once we find
# a different value, we can stop
}
r
}
print(statmode(c(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17)))
print(statmode(c(1, 1, 2, 4, 4)))
Racket
Returns values of list of modes and their frequencies of appearance.
#lang racket
(define (mode seq)
(define frequencies (make-hash))
(for ([s seq])
(hash-update! frequencies
s
(lambda (freq) (add1 freq))
0))
(for/fold ([ms null]
[freq 0])
([(k v) (in-hash frequencies)])
(cond [(> v freq)
(values (list k) v)]
[(= v freq)
(values (cons k ms) freq)]
[else
(values ms freq)])))
Raku
(formerly Perl 6)
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];
- Output:
6 (4 1)
Alternatively, a version that uses a single method chain with no temporary variables: (Same output with same input)
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];
REXX
version 1
Returns one mode value.
/*REXX program finds the mode (most occurring element) of a vector. */
/* ════════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
v= 1 2 3 4 5 6 7 8 9 11 10 ; say 'vector='v; say 'mode='mode(v); say
v= 8 8 8 2 2 2 ; say 'vector='v; say 'mode='mode(v); say
v='cat kat Cat emu emu Kat' ; say 'vector='v; say 'mode='mode(v); say
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
sort: procedure expose @.; parse arg # 1 h /* [↓] this is an exchange sort. */
do while h>1; h=h%2 /*In REXX, % is an integer divide.*/
do i=1 for #-h; j=i; k=h+i /* [↓] perform exchange for elements. */
do while @.k<@.j & h<j; _=@.j; @.j=@.k; @.k=_; j=j-h; k=k-h; end
end /*i*/
end /*while h>1*/; return
/*──────────────────────────────────────────────────────────────────────────────────────*/
mode: procedure expose @.; parse arg x; freq=1 /*function finds the MODE of a vector*/
#=words(x) /*#: the number of elements in vector.*/
do k=1 for #; @.k=word(x,k); end /* ◄──── make an array from the vector.*/
call Sort # /*sort the elements in the array. */
?=@.1 /*assume the first element is the mode.*/
do j=1 for #; _=j-freq /*traipse through the elements in array*/
if @.j==@._ then do; freq=freq+1 /*is this element the same as previous?*/
?=@.j /*this element is the mode (···so far).*/
end
end /*j*/
return ? /*return the mode of vector to invoker.*/
output
vector=1 8 6 0 1 9 4 6 1 9 9 9 mode=9 vector=1 2 3 4 5 6 7 8 9 11 10 mode=1 vector=8 8 8 2 2 2 mode=2 vector=cat kat Cat emu emu Kat mode=emu
version 2
and should work for every REXX.
/* Rexx */
/*-- ~~ main ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
call run_samples
return
exit
/*-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
/*-- returns a comma separated string of mode values from a comma separated input vector string */
mode:
procedure
parse arg lvector
drop vector.
vector. = ''
call makeStem lvector /*-- this call creates the "vector." stem from the input string */
seen. = 0
modes. = ''
modeMax = 0
do v_ = 1 to vector.0
mv = vector.v_
seen.mv = seen.mv + 1
select
when seen.mv > modeMax then do
modeMax = seen.mv
drop modes.
modes. = ''
nx = 1
modes.0 = nx
modes.nx = mv
end
when seen.mv = modeMax then do
nx = modes.0 + 1
modes.0 = nx
modes.nx = mv
end
otherwise do
nop
end
end
end v_
lmodes = ''
do e_ = 1 to modes.0
lmodes = lmodes modes.e_
end e_
lmodes = strip(space(lmodes, 1, ','))
return lmodes
/*-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
/*-- pretty-print */
show_mode:
procedure
parse arg lvector
lmodes = mode(lvector)
say 'Vector: ['space(lvector, 0)'], Mode(s): ['space(lmodes, 0)']'
return modes
/*-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
/*-- load the "vector." stem from the comma separated input vector string */
makeStem:
procedure expose vector.
vector.0 = 0
parse arg lvector
do v_ = 1 while lvector \= ''
parse var lvector val ',' lvector
vector.0 = v_
vector.v_ = strip(val)
vector = strip(lvector)
end v_
return vector.0
/*-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
run_samples:
procedure
call show_mode '10, 9, 8, 7, 6, 5, 4, 3, 2, 1' -- 10 9 8 7 6 5 4 3 2 1
call show_mode '10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0.11' -- 0
call show_mode '30, 10, 20, 30, 40, 50, -100, 4.7, -11e+2' -- 30
call show_mode '30, 10, 20, 30, 40, 50, -100, 4.7, -11e+2, -11e+2' -- 30 -11e2
call show_mode '1, 8, 6, 0, 1, 9, 4, 6, 1, 9, 9, 9' -- 9
call show_mode '1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11' -- 1 2 3 4 5 6 7 8 9 10 11
call show_mode '8, 8, 8, 2, 2, 2' -- 8 2
call show_mode 'cat, kat, Cat, emu, emu, Kat' -- emu
call show_mode '0, 1, 2, 3, 3, 3, 4, 4, 4, 4, 1, 0' -- 4
call show_mode '2, 7, 1, 8, 2' -- 2
call show_mode '2, 7, 1, 8, 2, 8' -- 8 2
call show_mode 'E, n, z, y, k, l, o, p, ä, d, i, e' -- E n z y k l o p ä d i e
call show_mode 'E, n, z, y, k, l, o, p, ä, d, i, e, ä' -- ä
call show_mode '3, 1, 4, 1, 5, 9, 7, 6' -- 1
call show_mode '3, 1, 4, 1, 5, 9, 7, 6, 3' -- 3, 1
call show_mode '1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17' -- 6
call show_mode '1, 1, 2, 4, 4' -- 4 1
return
- Output:
Vector: [10,9,8,7,6,5,4,3,2,1], Mode(s): [10,9,8,7,6,5,4,3,2,1] Vector: [10,9,8,7,6,5,4,3,2,1,0,0,0,0,0.11], Mode(s): [0] Vector: [30,10,20,30,40,50,-100,4.7,-11e+2], Mode(s): [30] Vector: [30,10,20,30,40,50,-100,4.7,-11e+2,-11e+2], Mode(s): [30,-11e+2] Vector: [1,8,6,0,1,9,4,6,1,9,9,9], Mode(s): [9] Vector: [1,2,3,4,5,6,7,8,9,10,11], Mode(s): [1,2,3,4,5,6,7,8,9,10,11] Vector: [8,8,8,2,2,2], Mode(s): [8,2] Vector: [cat,kat,Cat,emu,emu,Kat], Mode(s): [emu] Vector: [0,1,2,3,3,3,4,4,4,4,1,0], Mode(s): [4] Vector: [2,7,1,8,2], Mode(s): [2] Vector: [2,7,1,8,2,8], Mode(s): [2,8] Vector: [E,n,z,y,k,l,o,p,ä,d,i,e], Mode(s): [E,n,z,y,k,l,o,p,ä,d,i,e] Vector: [E,n,z,y,k,l,o,p,ä,d,i,e,ä], Mode(s): [ä] Vector: [3,1,4,1,5,9,7,6], Mode(s): [1] Vector: [3,1,4,1,5,9,7,6,3], Mode(s): [1,3] Vector: [1,3,6,6,6,6,7,7,12,12,17], Mode(s): [6] Vector: [1,1,2,4,4], Mode(s): [1,4]
Ring
# Project : Averages/Mode
a = [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]
b = [1, 2, 4, 4, 1]
amodes = list(12)
see "mode(s) of a() = " + nl
for i1 = 1 to modes(a,amodes)
see "" + amodes[i1] + " "
next
see nl
see "mode(s) of b() = " + nl
for i1 = 1 to modes(b,amodes)
see "" + amodes [i1] + " "
next
see nl
func modes(a,amodes)
max = 0
n = len(a)
if n = 0
amodes[1] = a[1]
return 1
ok
c = list(n)
for i = 1 to n
for j = i+1 to n
if a[i] = a[j]
c[i] = c[i] + 1
ok
next
if c[i] > max
max = c[i]
ok
next
j = 0
for i = 1 to n
if c[i] = max
j = j + 1
amodes[j] = a[i]
ok
next
return j
Output:
mode(s) of a() = 6 mode(s) of b() = 1 4
RPL
∑VAL and ∑CNT are global lists used to store rep. values and counters. Using the stack to handle potentially big amounts of data would slow down execution.
RPL code | Comment |
---|---|
≪ IF ∑VAL OVER POS THEN '∑CNT' LAST ∑CNT OVER GET 1 + PUT DROP ELSE ∑VAL SWAP + '∑VAL' STO ∑CNT 1 + '∑CNT' STO END ≫ '∑ADD' STO ≪ → data ≪ { } DUP '∑VAL' STO '∑CNT' STO 1 data SIZE FOR j data j GET ∑ADD NEXT ∑CNT LIST→ { } + →ARRY RNRM { } 1 ∑VAL SIZE FOR j IF OVER '∑CNT' j GET == THEN '∑VAL' j GET IF DUP2 POS NOT THEN + END END NEXT ≫ 'MODE' STO |
∑ADD ( n -- ) // update ∑VAL and ∑CNT if n already in ∑VAL then increment corresponding position in ∑CNT else create new in ∑VAL / ∑CNT entries MODE ( { data } -- { modal value(s) } ) initialize ∑VAL and ∑CNT for all input values count occurrences get max value in ∑CNT for all distinct values if count = max then get value and add it to output list if not already in |
{ 1 3 6 6 6 6 7 7 12 12 17 } MODE { 1 1 2 4 4 } MODE
- Output:
2: { 6 } 1: { 1 4 }
Ruby
Here's two methods, the first more Ruby-ish, the second perhaps a bit more efficient.
def mode(ary)
seen = Hash.new(0)
ary.each {|value| seen[value] += 1}
max = seen.values.max
seen.find_all {|key,value| value == max}.map {|key,value| key}
end
def mode_one_pass(ary)
seen = Hash.new(0)
max = 0
max_elems = []
ary.each do |value|
seen[value] += 1
if seen[value] > max
max = seen[value]
max_elems = [value]
elsif seen[value] == max
max_elems << value
end
end
max_elems
end
p mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]) # => [6]
p mode([1, 1, 2, 4, 4]) # => [1, 4]
p mode_one_pass([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]) # => [6]
p mode_one_pass([1, 1, 2, 4, 4]) # => [1, 4]
If you just want one mode (instead of all of them), here's a one-liner for that:
def one_mode(ary)
ary.max_by { |x| ary.count(x) }
end
Rust
use std::collections::HashMap;
fn main() {
let mode_vec1 = mode(vec![ 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]);
let mode_vec2 = mode(vec![ 1, 1, 2, 4, 4]);
println!("Mode of vec1 is: {:?}", mode_vec1);
println!("Mode of vec2 is: {:?}", mode_vec2);
assert!( mode_vec1 == [6], "Error in mode calculation");
assert!( (mode_vec2 == [1, 4]) || (mode_vec2 == [4,1]), "Error in mode calculation" );
}
fn mode(vs: Vec<i32>) -> Vec<i32> {
let mut vec_mode = Vec::new();
let mut seen_map = HashMap::new();
let mut max_val = 0;
for i in vs{
let ctr = seen_map.entry(i).or_insert(0);
*ctr += 1;
if *ctr > max_val{
max_val = *ctr;
}
}
for (key, val) in seen_map {
if val == max_val{
vec_mode.push(key);
}
}
vec_mode
}
- Output:
Mode of vec1 is: [6] Mode of vec2 is: [1,4] // may also print [4, 1], vector has no order guarantee
S-lang
I'm accepting strings and numbers, although I'm converting numbers to strings, as S-Lang Assoc_Type only accepts strings as keys.
private variable mx, mxkey, modedat;
define find_max(key) {
if (modedat[key] > mx) {
mx = modedat[key];
mxkey = {key};
}
else if (modedat[key] == mx) {
list_append(mxkey, key);
}
}
define find_mode(indat)
{
% reset [file/module-scope] globals:
mx = 0, mxkey = {}, modedat = Assoc_Type[Int_Type, 0];
foreach $1 (indat)
modedat[string($1)]++;
array_map(Void_Type, &find_max, assoc_get_keys(modedat));
if (length(mxkey) > 1) {
$2 = 0;
() = printf("{");
foreach $1 (mxkey) {
() = printf("%s%s", $2 ? ", " : "", $1);
$2 = 1;
}
() = printf("} each have ");
}
else
() = printf("%s has ", mxkey[0], mx);
() = printf("the most entries (%d).\n", mx);
}
find_mode({"Hungadunga", "Hungadunga", "Hungadunga", "Hungadunga", "McCormick"});
find_mode({"foo", "2.3", "bar", "foo", "foobar", "quality", 2.3, "strnen"});
- Output:
Hungadunga has the most entries (4). {foo, 2.3} each have the most entries (2).
Scala
Receiving any collection is easy. Returning the result in the same collection takes some doing.
import scala.collection.breakOut
import scala.collection.generic.CanBuildFrom
def mode
[T, CC[X] <: Seq[X]](coll: CC[T])
(implicit o: T => Ordered[T], cbf: CanBuildFrom[Nothing, T, CC[T]])
: CC[T] = {
val grouped = coll.groupBy(x => x).mapValues(_.size).toSeq
val max = grouped.map(_._2).max
grouped.filter(_._2 == max).map(_._1)(breakOut)
}
Scheme
(define (mode collection)
(define (helper collection counts)
(if (null? collection)
counts
(helper (remove (car collection) collection)
(cons (cons (car collection)
(appearances (car collection) collection)) counts))))
(map car
(filter (lambda (x) (= (cdr x) (apply max (map cdr (helper collection '())))))
(helper collection '())))
Seed7
The example below defines the template function createModeFunction
, which defines the function mode
.
The template createModeFunction
is instantiated explicit with createModeFunction(integer)
.
Additionally to mode
the function str
is defined.
The function str
is used by the template function
enable_output to allow writing arrays.
This way the main
function can just write the mode.
$ include "seed7_05.s7i";
const proc: createModeFunction (in type: elemType) is func
begin
const func array elemType: mode (in array elemType: data) is func
result
var array elemType: maxElems is 0 times elemType.value;
local
var hash [elemType] integer: counts is (hash [elemType] integer).value;
var elemType: aValue is elemType.value;
var integer: maximum is 0;
begin
for aValue range data do
if aValue in counts then
incr(counts[aValue]);
else
counts @:= [aValue] 1;
end if;
if counts[aValue] > maximum then
maximum := counts[aValue];
maxElems := [] (aValue);
elsif counts[aValue] = maximum then
maxElems &:= aValue;
end if;
end for;
end func;
const func string: str (in array elemType: data) is func
result
var string: stri is "";
local
var elemType: anElement is elemType.value;
begin
for anElement range data do
stri &:= " " & str(anElement);
end for;
stri := stri[2 ..];
end func;
enable_output(array elemType);
end func;
createModeFunction(integer);
const proc: main is func
begin
writeln(mode([] (1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17)));
writeln(mode([] (1, 1, 2, 4, 4)));
end func;
- Output:
6 1 4
Sidef
func mode(array) {
var c = Hash.new;
array.each{|i| c{i} := 0 ++};
var max = c.values.max;
c.keys.grep{|i| c{i} == max};
}
Calling the function
say mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]).join(' ');
say mode([1, 1, 2, 4, 4]).join(' ');
- Output:
6 1 4
If you just want one mode (instead of all of them), here's a one-liner for that:
func one_mode(arr) {
arr.max_by{|i| arr.count(i)};
}
Slate
s@(Sequence traits) mode
[| sortedCounts |
sortedCounts: (s as: Bag) sortedCounts.
(sortedCounts mapSelect: [| :count :elem | sortedCounts last count = count]) valueSet
].
Smalltalk
This code is able to find the mode of any collection of any kind of object.
OrderedCollection extend [
mode [ |s|
s := self asBag sortedByCount.
^ (s select: [ :k | ((s at: 1) key) = (k key) ]) collect: [:k| k value]
]
].
#( 1 3 6 6 6 6 7 7 12 12 17 ) asOrderedCollection
mode displayNl.
#( 1 1 2 4 4) asOrderedCollection
mode displayNl.
SQL
Some databases have a built-in function. In Oracle you can say select stats_mode(val) from...
but that returns one value, so doesn't handle non-unique modes. Other databases don't have a built-in. So here's a way to do this in a query.
-- setup
create table averages (val integer);
insert into averages values (1);
insert into averages values (2);
insert into averages values (3);
insert into averages values (1);
insert into averages values (2);
insert into averages values (4);
insert into averages values (2);
insert into averages values (5);
insert into averages values (2);
insert into averages values (3);
insert into averages values (3);
insert into averages values (1);
insert into averages values (3);
insert into averages values (6);
-- find the mode
with
counts as
(
select
val,
count(*) as num
from
averages
group by
val
)
select
val as mode_val
from
counts
where
num in (select max(num) from counts);
- Output:
MODE_VAL ---------- 2 3
Swift
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 {
/// Return a Mode of the function, or nil if none exist.
func mode() -> Element? {
var frequencies = [Element: Int]()
// Standard for loop. Can also use the forEach(_:) or reduce(into:) methods on self.
for element in self {
frequencies[element] = (frequencies[element] ?? 0) + 1
}
// The max(by:) method used here to find one of the elements with the highest associated count.
if let ( mode, _ ) = frequencies.max(by: { $0.value < $1.value }) {
return mode
} else {
return nil
}
}
}
["q", "a", "a", "a", "a", "b", "b", "z", "c", "c", "c"].mode() // returns "a"
[1, 1, 2, 3, 3, 3, 3, 4, 4, 4].mode() // returns 3
let emptyArray: [Int] = []
emptyArray.mode() // returns nil
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
Note that this works for any kind of value.
UNIX Shell
#!/bin/bash
function mode {
declare -A map
max=0
for x in "$@"; do
tmp=$((${map[$x]} + 1))
map[$x]=$tmp
((tmp > max)) && max=$tmp
done
for x in "${!map[@]}"; do
[[ ${map[$x]} == $max ]] && echo -n "$x "
done
echo
}
mode 1 2 1 2 a b a b a 2
a 2
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.
#import std
mode = ~&hS+ leql$^&h+ eql|=@K2
#cast %nLW
examples = mode~~ (<1,3,6,6,6,7,7,12,12,17>,<1,1,2,4,4>)
The function is tested on a pair of lists, one with a unique mode and one with multiple modes.
- Output:
(<6>,<4,1>)
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.
Public Sub main()
s = [{1,2,3,3,3,4,4,4,5,5,6}]
t = WorksheetFunction.Mode_Mult(s)
For Each x In t
Debug.Print x;
Next x
End Sub
- Output:
3 4
Vedit macro language
Current edit buffer stores the collection. Each line is an item in the collection. The items can be any type (ascii text, numeric values in ascii, binary values). However, binary file with fixed record length would require some modifications to the code.
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.
BOF // Copy all data to a new buffer
Reg_Copy(10, ALL)
Buf_Switch(Buf_Free)
Reg_Ins(10)
Sort(0, File_Size) // Sort the data
BOF
repeat(ALL) { // Count & delete duplicate lines
#1 = 1
while(Match("^{.*}\N\1$", REGEXP)==0) {
Del_Line(1)
#1++
}
Num_Ins(#1, NOCR) // Insert item count at the beginning of line
Ins_Char(9) // TAB
Line(1, ERRBREAK) // Next (different) line
}
Sort(0, File_Size, REVERSE) // Sort according to the count
BOF // Display the results
Reg_Copy_Block(10, CP, EOL_pos)
Buf_Quit(OK)
Statline_Message(@10)
V (Vlang)
fn main() {
println(mode([2, 7, 1, 8, 2]))
println(mode([2, 7, 1, 8, 2, 8]))
}
fn mode(a []int) []int {
mut m := map[int]int{}
for v in a {
m[v]++
}
mut mode := []int{}
mut n := 0
for k, v in m {
match true {
v > n {
n = v
mode = [k]
}
v<n{}
else {
mode << k
}
}
}
return mode
}
- Output:
[2] [2, 8]
Or using `math.stats` module
import math.stats
fn main() {
println(stats.mode<int>([2, 7, 1, 8, 2]))
println(stats.mode<int>([2, 7, 1, 8, 2, 8]))
}
- Output:
2 2
Wren
class Arithmetic {
static mode(arr) {
var map = {}
for (e in arr) {
if (map[e] == null) map[e] = 0
map[e] = map[e] + 1
}
var max = map.values.reduce {|x, y| x > y ? x : y}
return map.keys.where {|x| map[x] == max}.toList
}
}
System.print(Arithmetic.mode([1,2,3,4,5,5,51,2,3]))
- Output:
[2, 3, 5]
Order may differ
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.
(defun mode ( predicate &rest values)
"Finds the mode of all values passed in.
Uses `predicate' to compare items."
(let ((modes nil) ; Declare local variables
(mode-count 0)
(value-list nil)
current-value)
(loop for value in values do
(if (setq current-value (assoc* value value-list :test predicate)) ; Construct a linked list of cons cells, (value . count)
(incf (cdr current-value))
(push (cons value 1) value-list)))
(loop for (value . count) in value-list do ; Find modes in linked list
(if (> count mode-count)
(setq modes (list value)
mode-count count)
(when (eq count mode-count)
(push value modes))))
modes))
XPL0
proc Mode(Size, Array); \Show the mode(s) of Array
int Size, Array;
int List, Count I, J, K, Max;
[List:= Reserve(Size*4); \4 bytes per integer
Count:= Reserve(Size*4);
K:= 0;
for I:= 0 to Size-1 do
[for J:= 0 to K-1 do
if List(J) = Array(I) then \item is in List
[Count(J):= Count(J)+1; \ so increment its count
J:= Size;
];
if J = K then \not already in List
[List(K):= Array(I);
Count(K):= 1;
K:= K+1;
];
];
Max:= 0; \find maximum count
for J:= 0 to K-1 do
if Count(J) > Max then
Max:= Count(J);
for J:= 0 to K-1 do \show Array item(s) with Max Count
if Count(J) = Max then
[IntOut(0, List(J)); ChOut(0, ^ )];
];
Mode(9, [1,2,3,4,5,5,5123,2,3])
- Output:
2 3 5
Yabasic
sub floor(x)
return int(x + .05)
end sub
SUB ASort$(matriz$())
local last, gap, first, tempi$, tempj$, i, j
last = arraysize(matriz$(), 1)
gap = floor(last / 10) + 1
while(TRUE)
first = gap + 1
for i = first to last
tempi$ = matriz$(i)
j = i - gap
while(TRUE)
tempj$ = matriz$(j)
if (tempi$ >= tempj$) then
j = j + gap
break
end if
matriz$(j+gap) = tempj$
if j <= gap then
break
end if
j = j - gap
wend
matriz$(j) = tempi$
next i
if gap = 1 then
return
else
gap = floor(gap / 3.5) + 1
end if
wend
END SUB
sub getMode$(list$) // returns mode and count
local m$(1), n, i, mode$, count, maxM$, maxC
n = token(list$, m$(), ", ")
ASort$(m$())
for i = 1 to n
if m$(i) <> mode$ then
if count > maxC then
maxM$ = mode$
maxC = count
end if
count = 1
mode$ = m$(i)
else
count = count + 1
end if
next i
return maxM$ + "," + str$(maxC)
end sub
result$ = getMode$("1,3,6,6,6,6,7,7,12,12,17")
n = instr(result$, ",")
print "mode ", left$(result$, n - 1), " occur(s) ", right$(result$, len(result$) - n), " times."
result$ = getMode$("a, a, b, d, d")
print "mode ", left$(result$, n - 1), " occur(s) ", right$(result$, len(result$) - n), " times."
- Output:
mode 6 occur(s) 4 times. mode a occur(s) 2 times.
zkl
This is a bit funky in that modes are returned as strings.
fcn mode(items){
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);
}
data:=T(1, 2, 3, 1, 2, 4, 2, 5, 3, 3, 1, 3, 6);
println("Mode: ", mode(data));
println("Mode: ", mode(data.append(2)));
println("Mode: ", mode("this is a test".split("")));
- Output:
Mode: L("3") Mode: L("2","3") Mode: L("s","t"," ")
- Programming Tasks
- Probability and statistics
- 11l
- Action!
- ActionScript
- Ada
- ALGOL 68
- ALGOL 68-rows
- APL
- AppleScript
- Arturo
- AutoHotkey
- AWK
- BBC BASIC
- BQN
- C
- C sharp
- C++
- Clojure
- CoffeeScript
- Common Lisp
- D
- Delphi
- System.Generics.Collections
- System.Generics.Defaults
- E
- EasyLang
- EchoLisp
- Elena
- Elixir
- Erlang
- ERRE
- Euphoria
- F Sharp
- Factor
- Fortran
- FreeBASIC
- Frink
- FutureBasic
- GAP
- Go
- Groovy
- Haskell
- Icon
- Unicon
- J
- Jakt
- Java
- JavaScript
- Jq
- Julia
- K
- Kotlin
- Lasso
- Liberty BASIC
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- MUMPS
- NetRexx
- Nim
- Oberon-2
- Objeck
- Objective-C
- OCaml
- Octave
- OoRexx
- Oz
- PARI/GP
- Perl
- Phix
- PHP
- PicoLisp
- PL/I
- PowerShell
- PureBasic
- Python
- Q
- Quackery
- R
- Racket
- Raku
- REXX
- Ring
- RPL
- Ruby
- Rust
- S-lang
- Scala
- Scheme
- Seed7
- Sidef
- Slate
- Smalltalk
- SQL
- Swift
- Tcl
- UNIX Shell
- Ursala
- VBA
- Vedit macro language
- V (Vlang)
- Wren
- XEmacs Lisp
- XPL0
- Yabasic
- Zkl