Averages/Mode: Difference between revisions

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

{{trans|Python}}

DefaultDict[Int, Int] count

L(v) values

 

print(modes([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]))

{{out}}

<pre>

 

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

INT ARRAY keys(MAX)

INT ARRAY values(MAX)

Test(b,9)

Test(c,1)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Mode.png Screenshot from Atari 8-bit computer]

=={{header|ActionScript}}==

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

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

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

}

return modeList;

 

=={{header|Ada}}==

{{works with|Ada 2005}}

mode.ads:

type Element_Type is private;

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

function Get_Mode (Set : Element_Array) return Element_Array;

 

mode.adb:

 

package body Mode is

end Get_Mode;

 

example use:

with Mode;

procedure Main is

end loop;

Ada.Text_IO.New_Line;

{{out}}

<pre>Input: 1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6

 

=={{header|APL}}==

 

=={{header|AppleScript}}==

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

 

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

 

-- 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})

 

=={{header|Arturo}}==

 

freqs: new #[]

loop arr 'i [

print getMode [1 3 6 6 6 6 7 7 12 12 17]

 

{{out}}

{{AutoHotkey case}}

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

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

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

Else Ct++

Return Ct>MxCt ? V : MxV

 

=={{header|AWK}}==

{

# compute histogram

END {

print mode(histo);

 

<pre>cat modedata.txt

 

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

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

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

NEXT

= J%

{{out}}

<pre>Mode(s) of a() = 6

=={{header|C}}==

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

#include <stdlib.h>

 

free(vc);

return 0;

{{out}}

<pre>got 2 modes:

 

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

using System.Collections;

using System.Collections.Generic;

}

 

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

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

#include <utility>

#include <algorithm>

std::cout << std::endl;

return 0;

{{out}}

2 3

 

=={{header|Clojure}}==

(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))]

Or a one-liner solution

 

=={{header|CoffeeScript}}==

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

# elements that appear most often in arr

(key for key, cnt of counts when cnt == max)

 

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

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

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

(map nil (lambda (element)

(push element modes))))

frequencies)

 

=={{header|D}}==

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

 

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

data ~= 2;

writeln("Mode: ", data.mode);

{{out}}

<pre>Mode: [3]

{{libheader| System.Generics.Collections}}

{{libheader| System.Generics.Defaults}}

program AveragesMode;

 

dict.Free;

Readln;

{{out}}

<pre>Modes:

Value: 12, Count: 4</pre>

=={{header|E}}==

def mode(values) {

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

}

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

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

counts[v] := newCount

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|EchoLisp}}==

(define (modes L)

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

(modes '())

😖️ error: group : expected list : null 🔎 'modes'

 

=={{header|Elena}}==

ELENA 5.0:

import system'collections;

import extensions;

.printLine("mode of (",array3.asEnumerable(),") is (",array3.Mode,")")

.readChar()

{{out}}

<pre>

 

=={{header|Elixir}}==

def mode(list) do

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

IO.puts "mode: #{inspect list}"

IO.puts " => #{inspect Average.mode(list)}"

 

{{out}}

 

=={{header|Erlang}}==

-module( mode ).

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

 

values_count( Value, Dict ) -> dict:update_counter( Value, 1, Dict ).

{{out}}

<pre>

 

=={{header|ERRE}}==

 

!$INTEGER

CALC_MODE(B[],4->MODES$)

PRINT(MODES$)

{{out}}

<pre>

 

=={{header|Euphoria}}==

 

function mode(sequence s)

 

constant s = { 1, "blue", 2, 7.5, 5, "green", "red", 5, 2, "blue", "white" }

{{out}}

<pre>{

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

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

l

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

else (cp,lst)) // else just keep old count/list

(0, [Unchecked.defaultof<'a>]) // Start with a count of 0 and a dummy item

Example usage:

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];;

 

=={{header|Factor}}==

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

 

=={{header|Fortran}}==

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

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

use Qsort_Module only Qsort => sort

implicit none

end function stat_mode

 

 

=={{header|FreeBASIC}}==

 

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

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Frink}}==

{

count = countToArray[vals]

 

println[modes[[1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]]]

{{out}}

<pre>

</pre>

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

 

=={{header|GAP}}==

local c, m;

c := Collected(SortedList(v));

 

mode([ 7, 5, 6, 1, 5, 5, 7, 12, 17, 6, 6, 5, 12, 3, 6 ]);

 

=={{header|Go}}==

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

 

import "fmt"

}

return mode

{{out}}

<pre>

</pre>

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

 

import "fmt"

}

return mode

{{out}}

<pre>

</pre>

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

 

import "fmt"

}

return mode

{{out}}

<pre>

</pre>

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

 

import "fmt"

}

return mode

{{out}}

("Enzyklopädie" has no repeated letters. All are modal.)

=={{header|Groovy}}==

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

assert col

def m = [:]

def keys = m.keySet().sort { -m[it] }

keys.findAll { m[it] == m[keys[0]] }

Test:

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})"

{{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])

 

=={{header|Haskell}}==

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

 

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

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

''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,2,3]

Alternately:

 

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

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

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

Another version that does not require an orderable type:

 

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

| otherwise = (best, x:modes)

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

 

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

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

every write(!mode(args))

end

else fail

}

{{out|Sample outputs}}

<pre>->am 3 1 4 1 5 9 7 6

 

=={{header|J}}==

 

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

 

=={{header|Java}}==

 

public class Mode {

System.out.println(mode(Arrays.asList(1, 1, 2, 4, 4))); // prints [1, 4]

}

 

=={{header|JavaScript}}==

var counter = {};

var mode = [];

 

mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]); // [6]

 

=={{header|jq}}==

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

# in increasing order of count:

def modes:

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

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

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

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

 

=={{header|Julia}}==

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

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

 

println(modes([1,3,6,6,6,6,7,7,12,12,17]))

 

=={{header|K}}==

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

 

=={{header|Kotlin}}==

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

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

println("[" + b.joinToString(", ") + "]")

modeOf(b)

 

{{out}}

 

=={{header|Lasso}}==

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

// store counts

}

getmode(array(1,3,6,6,6,6,7,7,12,12,17))

 

{{out}}

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

Using string of integers instead collection.

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

b$ = "1 2 4 4 1"

modes$ = modes$; oldVal; " "

end select

 

{{out}}

 

=={{header|Lua}}==

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

local counts = { }

for _, val in pairs(modes) do io.write(val..' ') end

print("occur(s) ", count, " times")

 

=={{header|M2000 Interpreter}}==

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

}

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()){

}

Checkit

 

=={{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:

 

{{out}}

=={{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:

{{out}}

<pre> {b,a,2}

 

=={{header|MATLAB}}==

modeValue = mode(setOfValues);

 

=={{header|MUMPS}}==

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

;I is a loop index

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)

<pre>USER>W $$MODE^ROSETTA("1^2^3^2")

2

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

show_mode([Rexx 1, 1, 2, 4, 4]) -- 4 1

return

'''Output:'''

<pre>

 

=={{header|Nim}}==

 

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

 

echo modes(@[1,3,6,6,6,6,7,7,12,12,17])

Output:

<pre>6

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

{{Works with|oo2c version2}}

MODULE Mode;

IMPORT

Show(Mode(z));Out.Ln;

END Mode.

{{out}

<pre>

 

=={{header|Objeck}}==

use Collection;

 

}

}

 

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

@interface NSArray (Mode)

return maxElems;

}

 

=={{header|OCaml}}==

let seen = Hashtbl.create 42 in

List.iter (fun x ->

if v = best then k :: acc

else acc)

# mode [1;3;6;6;6;6;7;7;12;12;17];;

- : int list = [6]

=={{header|Octave}}==

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

sv = sort(v);

% build two vectors, vals and c, so that

i++;

endwhile

mode2(a)

mode(a)

a = [1, 1, 2, 4, 4];

mode2(a) % returns 1 and 4

 

=={{header|ooRexx}}==

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

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

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

 

return mode

 

=={{header|Oz}}==

fun {Mode Xs}

Freq = {Dictionary.new}

in

{Show {Mode [1 2 3 3 2 1 1]}}

 

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

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

v=vecsort(v);

);

if(count>r,v[#v],b)

 

=={{header|Perl}}==

use List::Util qw(max);

 

my $best = max(values %c);

return grep { $c{$_} == $best } keys %c;

 

print "\n";

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

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">mode</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #000080;font-style:italic;">-- returns a list of the most common values, each of which occurs the same number of times</span>

<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>

{{out}}

<pre>

=={{header|PHP}}==

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

function mode($arr) {

$count = array_count_values($arr);

print_r(mode(array(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17)));

print_r(mode(array(1, 1, 2, 4, 4)));

 

=={{header|PicoLisp}}==

(let A NIL

(for X Lst

(mapcar car

(maxi cdar

{{out}}

<pre>: (modes (1 3 6 6 6 6 7 7 12 12 17))

 

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

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

declare f(32767) fixed binary;

max || ' times.');

 

Results:

<pre>

 

=={{header|PowerShell}}==

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

{{out}}

<pre>Count Name Group

 

=={{header|PureBasic}}==

 

Structure MyMean

EndIf

Next

 

=={{header|Python}}==

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

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

>>> def modes(values):

count = defaultdict(int)

[6]

>>> modes((1,1,2,4,4))

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

>>> def modes(values):

count = Counter(values)

[6]

>>> modes((1,1,2,4,4))

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

 

=={{header|Q}}==

 

=={{header|Quackery}}==

 

[] [] rot

dup 0 peek temp put

' [ 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

 

{{out}}

 

=={{header|R}}==

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

r <- c()

 

print(statmode(c(1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17)))

 

=={{header|Racket}}==

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

 

(define (mode seq)

(values (cons k ms) freq)]

[else

 

=={{header|Raku}}==

 

{{works with|Rakudo|2019.03.1}}

my %counts := @a.Bag;

my $max = %counts.values.max;

# Testing with arrays:

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

 

{{out}}

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

 

@a.Bag # count elements

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

 

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

 

=={{header|REXX}}==

===version 1===

Returns one mode value.

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

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

end

end /*j*/

'''output'''

<pre>

{{works with|Regina}}

and should work for every REXX.

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

call run_samples

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

{{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]

 

=={{header|Ring}}==

# Project : Averages/Mode

 

next

return j

Output:

<pre>

=={{header|Ruby}}==

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

seen = Hash.new(0)

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

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]

{{works with|Ruby|1.8.7}}

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

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

 

=={{header|Rust}}==

 

fn main() {

vec_mode

}

{{out}}

<pre>

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

as S-Lang Assoc_Type only accepts strings as keys.

 

define find_max(key) {

find_mode({"Hungadunga", "Hungadunga", "Hungadunga", "Hungadunga", "McCormick"});

 

{{out}}

<pre>Hungadunga has the most entries (4).

{{works with|Scala|2.8}}

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

import scala.collection.generic.CanBuildFrom

def mode

val max = grouped.map(_._2).max

grouped.filter(_._2 == max).map(_._1)(breakOut)

 

=={{header|Scheme}}==

{{works with|Berkeley Scheme}}

(define (helper collection counts)

(if (null? collection)

(map car

(filter (lambda (x) (= (cdr x) (apply max (map cdr (helper collection '())))))

 

=={{header|Seed7}}==

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

 

 

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

writeln(mode([] (1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17)));

writeln(mode([] (1, 1, 2, 4, 4)));

 

{{out}}

 

=={{header|Sidef}}==

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'''

 

{{out}}

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

 

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

 

=={{header|Slate}}==

[| sortedCounts |

sortedCounts: (s as: Bag) sortedCounts.

(sortedCounts mapSelect: [| :count :elem | sortedCounts last count = count]) valueSet

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

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

mode [ |s|

s := self asBag sortedByCount.

mode displayNl.

#( 1 1 2 4 4) asOrderedCollection

 

=={{header|SQL}}==

create table averages (val integer);

insert into averages values (1);

counts

where

{{out}}

<pre> MODE_VAL

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 {

emptyArray.mode() // returns nil

 

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

proc mode {n args} {

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

# Testing

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

Note that this works for any kind of value.

 

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

{{works with|bash|4.0}}

 

function mode {

done

echo

 

=={{header|Ursala}}==

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

 

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

#cast %nLW

 

The function is tested on a pair of lists, one with a unique mode and one with multiple modes.

{{out}}

=={{header|VBA}}==

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

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

t = WorksheetFunction.Mode_Mult(s)

Debug.Print x;

Next x

<pre> 3 4</pre>

 

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

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

Reg_Copy(10, ALL)

Buf_Switch(Buf_Free)

Reg_Copy_Block(10, CP, EOL_pos)

Buf_Quit(OK)

 

=={{header|Vlang}}==

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

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

}

return mode

{{out}}

<pre>[2]

</pre>

Or using `math.stats` module

fn main() {

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

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

{{out}}

<pre>2

 

=={{header|Wren}}==

static mode(arr) {

var map = {}

}

 

{{out}}

[2, 3, 5]

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

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

"Finds the mode of all values passed in.

Uses `predicate' to compare items."

(when (eq count mode-count)

(push value modes))))

 

=={{header|Yabasic}}==

return int(x + .05)

end sub

 

result$ = getMode$("a, a, b, d, d")

 

{{out}}

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

{{trans|D}}

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

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

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

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

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

{{out}}

<pre>