Anonymous user
Averages/Mode: Difference between revisions
m
→{{header|Elena}}
(Jakt) |
imported>Arakov |
||
| (7 intermediate revisions by 4 users not shown) | |||
Line 315:
<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}}==
Line 860 ⟶ 939:
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.
=={{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}}==
Line 882 ⟶ 990:
=={{header|Elena}}==
ELENA
<syntaxhighlight lang="elena">import system'routines;
import system'collections;
Line 892 ⟶ 1,000:
{
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()
}
Line 910 ⟶ 1,018:
public program()
{
}</syntaxhighlight>
{{out}}
Line 1,322 ⟶ 1,430:
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>
=={{header|GAP}}==
Line 3,595 ⟶ 3,727:
=={{header|Wren}}==
<syntaxhighlight lang="
static mode(arr) {
var map = {}
| |||