Greatest element of a list: Difference between revisions
→{{header|Euphoria}}: added more trivial example |
→Nu: add |
||
(388 intermediate revisions by more than 100 users not shown) | |||
Line 1: | Line 1: | ||
{{task|Arithmetic operations}} |
|||
{{task|Arithmetic operations}}Create a function that returns the maximum value in a provided set of values, where the number of values isn't known until runtime. |
|||
[[Category:Simple]] |
|||
;Task: |
|||
Create a function that returns the maximum value in a provided set of values, |
|||
<br>where the number of values may not be known until run-time. |
|||
<br><br> |
|||
=={{header|11l}}== |
|||
11l already has a "Maximum Value" function. |
|||
<syntaxhighlight lang="11l">max(values)</syntaxhighlight> |
|||
=={{header|8th}}== |
|||
<syntaxhighlight lang="forth"> |
|||
[ 1.0, 2.3, 1.1, 5.0, 3, 2.8, 2.01, 3.14159 ] ' n:max 0 a:reduce . cr |
|||
</syntaxhighlight> |
|||
Output: 5 |
|||
=={{header|AArch64 Assembly}}== |
|||
{{works with|as|Raspberry Pi 3B version Buster 64 bits}} |
|||
<syntaxhighlight lang="aarch64 assembly"> |
|||
/* ARM assembly AARCH64 Raspberry PI 3B */ |
|||
/* program rechMax64.s */ |
|||
/*******************************************/ |
|||
/* Constantes file */ |
|||
/*******************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly*/ |
|||
.include "../includeConstantesARM64.inc" |
|||
/*********************************/ |
|||
/* Initialized data */ |
|||
/*********************************/ |
|||
.data |
|||
szMessResult: .ascii "Max number is = @ rank = @ address (hexa) = @ \n" // message result |
|||
tTableNumbers: .quad 50 |
|||
.quad 12 |
|||
.quad -1000 |
|||
.quad 40 |
|||
.quad 255 |
|||
.quad 60 |
|||
.quad 254 |
|||
.equ NBRANKTABLE, (. - tTableNumbers) / 8 // number table posts |
|||
/*********************************/ |
|||
/* UnInitialized data */ |
|||
/*********************************/ |
|||
.bss |
|||
sZoneConv: .skip 24 |
|||
/*********************************/ |
|||
/* code section */ |
|||
/*********************************/ |
|||
.text |
|||
.global main |
|||
main: // entry of program |
|||
ldr x1,qAdrtTableNumbers |
|||
mov x2,0 |
|||
ldr x4,[x1,x2,lsl #3] // load first number |
|||
mov x3,x2 // save first indice |
|||
add x2,x2,1 // increment indice |
|||
1: |
|||
cmp x2,#NBRANKTABLE // indice ? maxi |
|||
bge 2f // yes -> end search |
|||
ldr x0,[x1,x2,lsl #3] // load other number |
|||
cmp x0,x4 // > old number max |
|||
csel x4,x0,x4,gt // if > x4 = x0 else x4=x4 |
|||
csel x3,x2,x3,gt // if > x3 = x2 else x3=x3 |
|||
add x2,x2,1 // increment indice |
|||
b 1b // and loop |
|||
2: |
|||
mov x0,x4 |
|||
ldr x1,qAdrsZoneConv |
|||
bl conversion10S // decimal conversion |
|||
ldr x0,qAdrszMessResult |
|||
ldr x1,qAdrsZoneConv |
|||
bl strInsertAtCharInc // insert result at first @ character |
|||
mov x5,x0 // save address message |
|||
mov x0,x3 |
|||
ldr x1,qAdrsZoneConv // conversion rank maxi |
|||
bl conversion10S // decimal conversion |
|||
mov x0,x5 // message address |
|||
ldr x1,qAdrsZoneConv |
|||
bl strInsertAtCharInc // insert result at Second @ character |
|||
mov x5,x0 // save message address |
|||
ldr x0,qAdrtTableNumbers |
|||
lsl x3,x3,3 |
|||
add x0,x0,x3 |
|||
ldr x1,qAdrsZoneConv // conversion address maxi |
|||
bl conversion16 // hexa conversion |
|||
mov x0,x5 |
|||
ldr x1,qAdrsZoneConv |
|||
bl strInsertAtCharInc // insert result at third @ character |
|||
bl affichageMess // display message final |
|||
100: // standard end of the program |
|||
mov x0,0 // return code |
|||
mov x8,EXIT // request to exit program |
|||
svc 0 // perform the system call |
|||
qAdrtTableNumbers: .quad tTableNumbers |
|||
qAdrszMessResult: .quad szMessResult |
|||
qAdrsZoneConv: .quad sZoneConv |
|||
/******************************************************************/ |
|||
/* conversion hexadecimal register */ |
|||
/******************************************************************/ |
|||
/* x0 contains value and x1 address zone receptrice */ |
|||
conversion16: |
|||
stp x0,lr,[sp,-48]! // save registres |
|||
stp x1,x2,[sp,32] // save registres |
|||
stp x3,x4,[sp,16] // save registres |
|||
mov x2,#60 // start bit position |
|||
mov x4,#0xF000000000000000 // mask |
|||
mov x3,x0 // save entry value |
|||
1: // start loop |
|||
and x0,x3,x4 // value register and mask |
|||
lsr x0,x0,x2 // right shift |
|||
cmp x0,#10 // >= 10 ? |
|||
bge 2f // yes |
|||
add x0,x0,#48 // no is digit |
|||
b 3f |
|||
2: |
|||
add x0,x0,#55 // else is a letter A-F |
|||
3: |
|||
strb w0,[x1],#1 // load result and + 1 in address |
|||
lsr x4,x4,#4 // shift mask 4 bits left |
|||
subs x2,x2,#4 // decrement counter 4 bits <= zero ? |
|||
bge 1b // no -> loop |
|||
100: // fin standard de la fonction |
|||
ldp x3,x4,[sp,16] // restaur des 2 registres |
|||
ldp x1,x2,[sp,32] // restaur des 2 registres |
|||
ldp x0,lr,[sp],48 // restaur des 2 registres |
|||
ret |
|||
/********************************************************/ |
|||
/* File Include fonctions */ |
|||
/********************************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly */ |
|||
.include "../includeARM64.inc" |
|||
</syntaxhighlight> |
|||
{{Output}} |
|||
<pre> |
|||
Max number is = +255 rank = +4 address (hexa) = 000000000041051C |
|||
</pre> |
|||
=={{header|ACL2}}== |
|||
<syntaxhighlight lang="lisp">(defun maximum (xs) |
|||
(if (endp (rest xs)) |
|||
(first xs) |
|||
(max (first xs) |
|||
(maximum (rest xs)))))</syntaxhighlight> |
|||
=={{header|Action!}}== |
|||
<syntaxhighlight lang="action!">BYTE FUNC Max(BYTE ARRAY tab BYTE size) |
|||
BYTE i,res |
|||
res=tab(0) |
|||
FOR i=1 TO size-1 |
|||
DO |
|||
IF res<tab(i) THEN |
|||
res=tab(i) |
|||
FI |
|||
OD |
|||
RETURN (res) |
|||
PROC Main() |
|||
BYTE i,m,size=[20] |
|||
BYTE ARRAY tab(size) |
|||
FOR i=0 TO size-1 |
|||
DO |
|||
tab(i)=Rand(0) |
|||
OD |
|||
Print("Array:") |
|||
FOR i=0 TO size-1 |
|||
DO |
|||
PrintF(" %I",tab(i)) |
|||
OD |
|||
PutE() |
|||
m=Max(tab,size) |
|||
PrintF("Greatest: %I%E",m) |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Greatest_element_of_a_list.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
Array: 106 182 121 251 21 244 46 157 228 251 173 50 106 126 193 230 88 117 114 120 |
|||
Greatest: 251 |
|||
</pre> |
|||
=={{header|ActionScript}}== |
=={{header|ActionScript}}== |
||
< |
<syntaxhighlight lang="actionscript">function max(... args):Number |
||
{ |
{ |
||
var curMax:Number = -Infinity; |
var curMax:Number = -Infinity; |
||
Line 8: | Line 199: | ||
curMax = Math.max(curMax, args[i]); |
curMax = Math.max(curMax, args[i]); |
||
return curMax; |
return curMax; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
The keys for this task are initializing the compared value to the 'First value of the element type, and use of an unconstrained array type. |
The keys for this task are initializing the compared value to the 'First value of the element type, and use of an unconstrained array type. |
||
< |
<syntaxhighlight lang="ada">with Ada.Text_Io; |
||
procedure Max_Test |
procedure Max_Test isco |
||
-- substitute any array type with a scalar element |
-- substitute any array type with a scalar element |
||
type Flt_Array is array (Natural range <>) of Float; |
type Flt_Array is array (Natural range <>) of Float; |
||
Line 38: | Line 230: | ||
begin |
begin |
||
Ada.Text_IO.Put_Line(Float'Image(Max(Buf))); |
Ada.Text_IO.Put_Line(Float'Image(Max(Buf))); |
||
end Max_Test;</ |
end Max_Test;</syntaxhighlight> |
||
A generic function Max to deal with any floating-point type. |
A generic function Max to deal with any floating-point type. |
||
< |
<syntaxhighlight lang="ada">generic |
||
type Item is digits <>; |
type Item is digits <>; |
||
type Items_Array is array (Positive range <>) of Item; |
type Items_Array is array (Positive range <>) of Item; |
||
function Generic_Max (List : Items_Array) return Item;</ |
function Generic_Max (List : Items_Array) return Item;</syntaxhighlight> |
||
Implementation of: |
Implementation of: |
||
< |
<syntaxhighlight lang="ada">function Generic_Max (List : Items_Array) return Item is |
||
Result : Item := List (List'First); |
Result : Item := List (List'First); |
||
begin |
begin |
||
Line 52: | Line 244: | ||
end loop; |
end loop; |
||
return Result; |
return Result; |
||
end Generic_Max;</ |
end Generic_Max;</syntaxhighlight> |
||
When the argument array is empty, Constraint_Error exception is propagated, because array indexing is checked in Ada. Note also use of the floating-type attribute Max. |
When the argument array is empty, Constraint_Error exception is propagated, because array indexing is checked in Ada. Note also use of the floating-type attribute Max. |
||
=={{header|Aime}}== |
|||
<syntaxhighlight lang="aime">integer |
|||
lmax(list l) |
|||
{ |
|||
integer max, x; |
|||
max = l[0]; |
|||
for (, x in l) { |
|||
if (max < x) { |
|||
max = x; |
|||
} |
|||
} |
|||
max; |
|||
}</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="aime">integer |
|||
lmax(list l) |
|||
{ |
|||
integer max; |
|||
max = l[0]; |
|||
l.ucall(max_i, 1, max); |
|||
max; |
|||
}</syntaxhighlight> |
|||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
{{works with|ALGOL 68|Revision 1 - no extensions to language used}} |
{{works with|ALGOL 68|Revision 1 - no extensions to language used}} |
||
Line 59: | Line 280: | ||
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}} |
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}} |
||
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}} |
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}} |
||
< |
<syntaxhighlight lang="algol68"># substitute any array type with a scalar element # |
||
MODE FLT = REAL; |
MODE FLT = REAL; |
||
Line 88: | Line 309: | ||
except empty array: |
except empty array: |
||
SKIP |
SKIP |
||
)</ |
)</syntaxhighlight> |
||
{{out}} |
|||
Output: |
|||
<pre> |
<pre> |
||
+3.14159265358979e +0 |
+3.14159265358979e +0 |
||
</pre> |
</pre> |
||
=={{header|ALGOL W}}== |
|||
<syntaxhighlight lang="algolw">begin |
|||
% simple list type % |
|||
record IntList( integer val; reference(IntList) next ); |
|||
% find the maximum element of an IntList, returns 0 for an empty list % |
|||
integer procedure maxElement( reference(IntList) value list ) ; |
|||
begin |
|||
integer maxValue; |
|||
reference(IntList) listPos; |
|||
maxValue := 0; |
|||
listPos := list; |
|||
if listPos not = null then begin |
|||
% non-empty list % |
|||
maxValue := val(listPos); |
|||
listPos := next(listPos); |
|||
while listPos not = null do begin |
|||
if val(listPos) > maxValue then maxValue := val(listPos); |
|||
listPos := next(listPos) |
|||
end while_listPos_ne_null ; |
|||
end if_listPos_ne_null ; |
|||
maxValue |
|||
end maxElement ; |
|||
% test the maxElement procedure % |
|||
write( maxElement( IntList( -767, IntList( 2397, IntList( 204, null ) ) ) ) ) |
|||
end.</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2397 |
|||
</pre> |
|||
=={{header|Amazing Hopper}}== |
|||
Version 1: |
|||
<syntaxhighlight lang="amazing hopper"> |
|||
#include <hopper.h> |
|||
main: |
|||
lst=0 |
|||
max=0 |
|||
file="datos.txt" |
|||
{","} toksep |
|||
{file} statsfile |
|||
{file} load |
|||
mov (lst) |
|||
{0} reshape (lst) |
|||
{lst} array (SORT) |
|||
[end] get (lst) |
|||
mov (max) |
|||
{"Maximo = "} |
|||
{max} |
|||
{"\n"} print |
|||
exit(0) |
|||
</syntaxhighlight> |
|||
Version 2: |
|||
<syntaxhighlight lang="amazing hopper"> |
|||
#include <hopper.h> |
|||
#define SIZE_LIST 100000 |
|||
main: |
|||
lst=-1 |
|||
max=0 |
|||
{SIZE_LIST} rand array (lst) |
|||
mul by (SIZE_LIST) |
|||
mov (lst) |
|||
{lst} array (SORT) |
|||
[end] get (lst) |
|||
mov (max) |
|||
{"Maximo = "} |
|||
{max} |
|||
{"\n"} print |
|||
exit(0) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Maximo = 99999.8 |
|||
</pre> |
|||
=={{header|AntLang}}== |
|||
<syntaxhighlight lang="antlang">max|range[10]</syntaxhighlight> |
|||
=={{header|APL}}== |
=={{header|APL}}== |
||
< |
<syntaxhighlight lang="apl">LIST←2 4 6 3 8 |
||
⌈/LIST</ |
⌈/LIST</syntaxhighlight> |
||
{{out}} <pre>8</pre> |
|||
=={{header|AppleScript}}== |
=={{header|AppleScript}}== |
||
<syntaxhighlight lang="applescript"> |
|||
<lang AppleScript>on max(aList) |
|||
max({1, 2, 3, 4, 20, 6, 11, 3, 9, 7}) |
|||
on max(aList) |
|||
set _curMax to first item of aList |
set _curMax to first item of aList |
||
repeat with i in (rest of aList) |
repeat with i in (rest of aList) |
||
Line 106: | Line 411: | ||
end repeat |
end repeat |
||
return _curMax |
return _curMax |
||
end max |
end max |
||
</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
|||
<lang AutoHotkey>Loop Parse, list, `, |
|||
x := x < A_LoopField ? A_LoopField : x |
|||
MsgBox Max = %x%</lang> |
|||
To find the greatest elements of lists which may contain data types other than numbers, we can write a more generic '''maximumBy''' function, which returns the maximum value from an array containing a series of any consistent data type, and which takes a type-specific comparison function as an argument. |
|||
=={{header|AWK}}== |
|||
<lang awk>$ awk 'func max(a){for(i in a)if(a[i]>r)r=a[i];return r}BEGIN{a[0]=42;a[1]=33;a[2]=21;print max(a)}' |
|||
42</lang> |
|||
{{trans|JavaScript}} |
|||
=={{header|Batch File}}== |
|||
<lang dos>::max.cmd |
|||
@echo off |
|||
setlocal enabledelayedexpansion |
|||
set a=.%~1 |
|||
if "%a%" equ "." set /p a="Input stream: " |
|||
call :max res %a% |
|||
echo %res% |
|||
endlocal |
|||
goto :eof |
|||
<syntaxhighlight lang="applescript"> |
|||
:max |
|||
-- maximumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a |
|||
set %1=%2 |
|||
on maximumByMay(f, xs) |
|||
:loop |
|||
set cmp to mReturn(f) |
|||
shift /2 |
|||
script max |
|||
if "%2" equ "" goto :eof |
|||
on |λ|(a, b) |
|||
if %2 gtr !%1! set res=%2 |
|||
if cmp's |λ|(a, b) < 0 then |
|||
goto loop</lang> |
|||
b |
|||
else |
|||
a |
|||
end if |
|||
end |λ| |
|||
end script |
|||
foldl1May(max, xs) |
|||
end maximumByMay |
|||
-- TEST ----------------------------------------------------------------------- |
|||
''Invocation from command line or from internal prompt'' |
|||
on run |
|||
set lstWords to ["alpha", "beta", "gamma", "delta", "epsilon", ¬ |
|||
"zeta", "eta", "theta", "iota", "kappa", "|λ|", "mu"] |
|||
set lstCities to [{name:"Shanghai", population:24.15}, ¬ |
|||
{name:"Karachi", population:23.5}, ¬ |
|||
{name:"Beijing", population:21.5}, ¬ |
|||
{name:"Tianjin", population:14.7}, ¬ |
|||
{name:"Istanbul", population:14.4}, ¬ |
|||
{name:"Lagos", population:13.4}, ¬ |
|||
{name:"Tokyo", population:13.3}] |
|||
script population |
|||
on |λ|(x) |
|||
population of x |
|||
end |λ| |
|||
end script |
|||
return catMaybes({¬ |
|||
maximumByMay(comparing(|length|), lstWords), ¬ |
|||
maximumByMay(comparing(|length|), {}), ¬ |
|||
maximumByMay(comparing(population), lstCities)}) |
|||
--> {"epsilon", {name:"Shanghai", population:24.15}} |
|||
end run |
|||
<lang dos>>max "123 456 3 234243 12" |
|||
234243 |
|||
-- GENERIC FUNCTIONS ---------------------------------------------------------- |
|||
>max |
|||
Input stream: 5 4 3 2 67 1 |
|||
-- catMaybes :: [Maybe a] -> [a] |
|||
67</lang> |
|||
on catMaybes(mbs) |
|||
script emptyOrListed |
|||
on |λ|(m) |
|||
if nothing of m then |
|||
{} |
|||
else |
|||
{just of m} |
|||
end if |
|||
end |λ| |
|||
end script |
|||
concatMap(emptyOrListed, mbs) |
|||
end catMaybes |
|||
-- comparing :: (a -> b) -> (a -> a -> Ordering) |
|||
on comparing(f) |
|||
set mf to mReturn(f) |
|||
script |
|||
on |λ|(a, b) |
|||
set x to mf's |λ|(a) |
|||
set y to mf's |λ|(b) |
|||
if x < y then |
|||
-1 |
|||
else |
|||
if x > y then |
|||
1 |
|||
else |
|||
0 |
|||
end if |
|||
end if |
|||
end |λ| |
|||
end script |
|||
end comparing |
|||
-- concatMap :: (a -> [b]) -> [a] -> [b] |
|||
on concatMap(f, xs) |
|||
set acc to {} |
|||
tell mReturn(f) |
|||
repeat with x in xs |
|||
set acc to acc & |λ|(contents of x) |
|||
end repeat |
|||
end tell |
|||
return acc |
|||
end concatMap |
|||
-- foldl1May :: (a -> a -> a) -> [a] -> Maybe a |
|||
on foldl1May(f, xs) |
|||
set lng to length of xs |
|||
if lng > 0 then |
|||
if lng > 1 then |
|||
tell mReturn(f) |
|||
set v to item 1 of xs |
|||
set lng to length of xs |
|||
repeat with i from 2 to lng |
|||
set v to |λ|(v, item i of xs, i, xs) |
|||
end repeat |
|||
return just(v) |
|||
end tell |
|||
else |
|||
just(item 1 of xs) |
|||
end if |
|||
else |
|||
nothing("Empty list") |
|||
end if |
|||
end foldl1May |
|||
-- just :: a -> Just a |
|||
on just(x) |
|||
{nothing:false, just:x} |
|||
end just |
|||
-- length :: [a] -> Int |
|||
on |length|(xs) |
|||
length of xs |
|||
end |length| |
|||
-- max :: Ord a => a -> a -> a |
|||
on max(x, y) |
|||
if x > y then |
|||
x |
|||
else |
|||
y |
|||
end if |
|||
end max |
|||
-- nothing :: () -> Nothing |
|||
on nothing(msg) |
|||
{nothing:true, msg:msg} |
|||
end nothing |
|||
-- Lift 2nd class handler function into 1st class script wrapper |
|||
-- mReturn :: Handler -> Script |
|||
on mReturn(f) |
|||
if class of f is script then |
|||
f |
|||
else |
|||
script |
|||
property |λ| : f |
|||
end script |
|||
end if |
|||
end mReturn</syntaxhighlight> |
|||
{{Out}} |
|||
<syntaxhighlight lang="applescript">{"epsilon", {name:"Shanghai", population:24.15}}</syntaxhighlight> |
|||
=={{header|Applesoft BASIC}}== |
|||
<syntaxhighlight lang="applesoftbasic"> 100 REMMAX |
|||
110 R$ = "":E$ = "" |
|||
120 L = LEN (L$) |
|||
130 IF L = 0 THEN RETURN |
|||
140 FOR I = 1 TO L |
|||
150 C$ = MID$ (L$,I,1) |
|||
160 SP = C$ = " " |
|||
170 IF SP THEN GOSUB 200 |
|||
180 E$ = E$ + C$ |
|||
190 NEXT I |
|||
200 C$ = "" |
|||
210 IF E$ = "" THEN RETURN |
|||
220 V = VAL (E$):V$ = R$ |
|||
230 E$ = "":E = V$ = "" |
|||
240 IF E AND V = 0 THEN RETURN |
|||
250 R$ = STR$ (V) |
|||
260 IF E THEN RETURN |
|||
270 R = VAL (V$) |
|||
280 IF R < V THEN RETURN |
|||
290 R$ = V$: RETURN</syntaxhighlight> |
|||
<syntaxhighlight lang="applesoftbasic">L$ = "1 2 3 4 20 6 11 3 9 7" |
|||
GOSUB 100MAX |
|||
PRINT R$</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>20</pre> |
|||
=={{header|ARM Assembly}}== |
|||
{{works with|as|Raspberry Pi}} |
|||
<syntaxhighlight lang="arm assembly"> |
|||
/* ARM assembly Raspberry PI */ |
|||
/* program rechMax.s */ |
|||
/* Constantes */ |
|||
.equ STDOUT, 1 @ Linux output console |
|||
.equ EXIT, 1 @ Linux syscall |
|||
.equ WRITE, 4 @ Linux syscall |
|||
/*********************************/ |
|||
/* Initialized data */ |
|||
/*********************************/ |
|||
.data |
|||
szMessResult: .ascii "Max number is = " @ message result |
|||
sMessValeur: .fill 12, 1, ' ' |
|||
.ascii " rank = " |
|||
sMessRank: .fill 12, 1, ' ' |
|||
.ascii " address (hexa) = " |
|||
sMessAddress: .fill 12, 1, ' ' |
|||
.asciz "\n" |
|||
tTableNumbers: .int 50 |
|||
.int 12 |
|||
.int -1000 |
|||
.int 40 |
|||
.int 255 |
|||
.int 60 |
|||
.int 254 |
|||
.equ NBRANKTABLE, (. - tTableNumbers) / 4 @ number table posts |
|||
/*********************************/ |
|||
/* UnInitialized data */ |
|||
/*********************************/ |
|||
.bss |
|||
/*********************************/ |
|||
/* code section */ |
|||
/*********************************/ |
|||
.text |
|||
.global main |
|||
main: @ entry of program |
|||
push {fp,lr} @ saves 2 registers |
|||
ldr r1,iAdrtTableNumbers |
|||
mov r2,#0 |
|||
ldr r4,[r1,r2,lsl #2] |
|||
mov r3,r2 |
|||
add r2,#1 |
|||
1: |
|||
cmp r2,#NBRANKTABLE |
|||
bge 2f |
|||
ldr r0,[r1,r2,lsl #2] |
|||
cmp r0,r4 |
|||
movgt r4,r0 |
|||
movgt r3,r2 |
|||
add r2,#1 |
|||
b 1b |
|||
2: |
|||
mov r0,r4 |
|||
ldr r1,iAdrsMessValeur |
|||
bl conversion10S @ call conversion |
|||
mov r0,r3 |
|||
ldr r1,iAdrsMessRank |
|||
bl conversion10 @ call conversion |
|||
ldr r0,iAdrtTableNumbers |
|||
add r0,r3,lsl #2 |
|||
ldr r1,iAdrsMessAddress |
|||
bl conversion16 @ call conversion |
|||
ldr r0,iAdrszMessResult |
|||
bl affichageMess @ display message |
|||
100: @ standard end of the program |
|||
mov r0, #0 @ return code |
|||
pop {fp,lr} @restaur 2 registers |
|||
mov r7, #EXIT @ request to exit program |
|||
swi 0 @ perform the system call |
|||
iAdrtTableNumbers: .int tTableNumbers |
|||
iAdrsMessValeur: .int sMessValeur |
|||
iAdrsMessRank: .int sMessRank |
|||
iAdrsMessAddress: .int sMessAddress |
|||
iAdrszMessResult: .int szMessResult |
|||
/******************************************************************/ |
|||
/* display text with size calculation */ |
|||
/******************************************************************/ |
|||
/* r0 contains the address of the message */ |
|||
affichageMess: |
|||
push {fp,lr} /* save registres */ |
|||
push {r0,r1,r2,r7} /* save others registers */ |
|||
mov r2,#0 /* counter length */ |
|||
1: /* loop length calculation */ |
|||
ldrb r1,[r0,r2] /* read octet start position + index */ |
|||
cmp r1,#0 /* if 0 its over */ |
|||
addne r2,r2,#1 /* else add 1 in the length */ |
|||
bne 1b /* and loop */ |
|||
/* so here r2 contains the length of the message */ |
|||
mov r1,r0 /* address message in r1 */ |
|||
mov r0,#STDOUT /* code to write to the standard output Linux */ |
|||
mov r7, #WRITE /* code call system "write" */ |
|||
swi #0 /* call systeme */ |
|||
pop {r0,r1,r2,r7} /* restaur others registers */ |
|||
pop {fp,lr} /* restaur des 2 registres */ |
|||
bx lr /* return */ |
|||
/******************************************************************/ |
|||
/* Converting a register to hexadecimal */ |
|||
/******************************************************************/ |
|||
/* r0 contains value and r1 address area */ |
|||
conversion16: |
|||
push {r1-r4,lr} /* save registers */ |
|||
mov r2,#28 @ start bit position |
|||
mov r4,#0xF0000000 @ mask |
|||
mov r3,r0 @ save entry value |
|||
1: @ start loop |
|||
and r0,r3,r4 @value register and mask |
|||
lsr r0,r2 @ move right |
|||
cmp r0,#10 @ compare value |
|||
addlt r0,#48 @ <10 ->digit |
|||
addge r0,#55 @ >10 ->letter A-F |
|||
strb r0,[r1],#1 @ store digit on area and + 1 in area address |
|||
lsr r4,#4 @ shift mask 4 positions |
|||
subs r2,#4 @ counter bits - 4 <= zero ? |
|||
bge 1b @ no -> loop |
|||
@end |
|||
pop {r1-r4,lr} @ restaur registres |
|||
bx lr @return |
|||
/******************************************************************/ |
|||
/* Converting a register to a decimal */ |
|||
/******************************************************************/ |
|||
/* r0 contains value and r1 address area */ |
|||
conversion10: |
|||
push {r1-r4,lr} /* save registers */ |
|||
mov r3,r1 |
|||
mov r2,#10 |
|||
1: @ start loop |
|||
bl divisionpar10 @ r0 <- dividende. quotient ->r0 reste -> r1 |
|||
add r1,#48 @ digit |
|||
strb r1,[r3,r2] @ store digit on area |
|||
sub r2,#1 @ previous position |
|||
cmp r0,#0 @ stop if quotient = 0 */ |
|||
bne 1b @ else loop |
|||
@ and move spaves in first on area |
|||
mov r1,#' ' @ space |
|||
2: |
|||
strb r1,[r3,r2] @ store space in area |
|||
subs r2,#1 @ @ previous position |
|||
bge 2b @ loop if r2 >= zéro |
|||
100: |
|||
pop {r1-r4,lr} @ restaur registres |
|||
bx lr @return |
|||
/***************************************************/ |
|||
/* Converting a register to a signed decimal */ |
|||
/***************************************************/ |
|||
/* r0 contains value and r1 area address */ |
|||
conversion10S: |
|||
push {r0-r4,lr} @ save registers |
|||
mov r2,r1 /* debut zone stockage */ |
|||
mov r3,#'+' /* par defaut le signe est + */ |
|||
cmp r0,#0 @ negative number ? |
|||
movlt r3,#'-' @ yes |
|||
mvnlt r0,r0 @ number inversion |
|||
addlt r0,#1 |
|||
mov r4,#10 @ length area |
|||
1: @ start loop |
|||
bl divisionpar10 |
|||
add r1,#48 @ digit |
|||
strb r1,[r2,r4] @ store digit on area |
|||
sub r4,r4,#1 @ previous position |
|||
cmp r0,#0 @ stop if quotient = 0 |
|||
bne 1b |
|||
strb r3,[r2,r4] @ store signe |
|||
subs r4,r4,#1 @ previous position |
|||
blt 100f @ if r4 < 0 -> end |
|||
mov r1,#' ' @ space |
|||
2: |
|||
strb r1,[r2,r4] @store byte space |
|||
subs r4,r4,#1 @ previous position |
|||
bge 2b @ loop if r4 > 0 |
|||
100: |
|||
pop {r0-r4,lr} @ restaur registers |
|||
bx lr |
|||
/***************************************************/ |
|||
/* division par 10 signé */ |
|||
/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/* |
|||
/* and http://www.hackersdelight.org/ */ |
|||
/***************************************************/ |
|||
/* r0 dividende */ |
|||
/* r0 quotient */ |
|||
/* r1 remainder */ |
|||
divisionpar10: |
|||
/* r0 contains the argument to be divided by 10 */ |
|||
push {r2-r4} /* save registers */ |
|||
mov r4,r0 |
|||
ldr r3, .Ls_magic_number_10 /* r1 <- magic_number */ |
|||
smull r1, r2, r3, r0 /* r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0) */ |
|||
mov r2, r2, ASR #2 /* r2 <- r2 >> 2 */ |
|||
mov r1, r0, LSR #31 /* r1 <- r0 >> 31 */ |
|||
add r0, r2, r1 /* r0 <- r2 + r1 */ |
|||
add r2,r0,r0, lsl #2 /* r2 <- r0 * 5 */ |
|||
sub r1,r4,r2, lsl #1 /* r1 <- r4 - (r2 * 2) = r4 - (r0 * 10) */ |
|||
pop {r2-r4} |
|||
bx lr /* leave function */ |
|||
.align 4 |
|||
.Ls_magic_number_10: .word 0x66666667 |
|||
</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">arr: [5 4 2 9 7 3] |
|||
print max arr</syntaxhighlight> |
|||
{{out}} |
|||
<pre>9</pre> |
|||
=={{header|AutoHotkey}}== |
|||
=== CSV Data === |
|||
<syntaxhighlight lang="autohotkey">list = 1,5,17,-2 |
|||
Loop Parse, list, `, |
|||
x := x < A_LoopField ? A_LoopField : x |
|||
MsgBox Max = %x%</syntaxhighlight> |
|||
=== Pseudo-arrays === |
|||
<syntaxhighlight lang="ahk">list = 1,5,17,-2 |
|||
StringSplit, list, list,`, ; creates a pseudo-array |
|||
Loop % List0 |
|||
x := x < List%A_Index% ? List%A_Index% : x |
|||
MsgBox Max = %x%</syntaxhighlight> |
|||
=== True arrays === |
|||
{{works with|AutoHotkey_L}} |
|||
<syntaxhighlight lang="ahk">List := [1,5,17,-2] |
|||
For each, value in List |
|||
x := x < value ? value : x |
|||
MsgBox Max = %x%</syntaxhighlight> |
|||
=={{header|AWK}}== |
|||
One-liner: |
|||
<syntaxhighlight lang="awk">$ awk 'func max(a){for(i in a)if(a[i]>r)r=a[i];return r}BEGIN{a[0]=42;a[1]=33;a[2]=21;print max(a)}' |
|||
42</syntaxhighlight> |
|||
More readable version: |
|||
<syntaxhighlight lang="awk"> |
|||
# Usage: awk -f greatest_list_element.awk |
|||
# |
|||
function max(a) { |
|||
for(i in a) if(a[i]>r) r=a[i]; |
|||
return r |
|||
} |
|||
# |
|||
BEGIN { a[0]=42; |
|||
a[1]=33; |
|||
a[2]=21; |
|||
print max(a) |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Axe}}== |
|||
This example assumes the array is null-terminated so that the program can stop at the end of the data. |
|||
<syntaxhighlight lang="axe">Lbl MAX |
|||
0→M |
|||
While {r₁} |
|||
{r₁}>M?{r₁}→M |
|||
End |
|||
M |
|||
Return</syntaxhighlight> |
|||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
{{works with|QBasic}} |
{{works with|QBasic}} |
||
< |
<syntaxhighlight lang="qbasic">DECLARE SUB addVal (value AS INTEGER) |
||
DECLARE FUNCTION findMax% () |
DECLARE FUNCTION findMax% () |
||
Line 194: | Line 924: | ||
NEXT |
NEXT |
||
findMax = tmp2 |
findMax = tmp2 |
||
END FUNCTION</ |
END FUNCTION</syntaxhighlight> |
||
{{Out}} |
|||
Sample output: |
|||
<pre> |
|||
8162 5139 7004 7393 5151 4476 577 4419 3333 4649 : 8162 |
8162 5139 7004 7393 5151 4476 577 4419 3333 4649 : 8162 |
||
</pre> |
|||
==={{header|BaCon}}=== |
|||
<syntaxhighlight lang="freebasic">' Greatest element from list |
|||
' Populate sample array of numbers |
|||
READ elements |
|||
DECLARE numbers TYPE NUMBER ARRAY elements |
|||
FOR i = 0 TO elements - 1 |
|||
READ numbers[i] |
|||
NEXT |
|||
DATA 6 |
|||
DATA 100,-2,300,4,500,6 |
|||
' Demonstrate the function |
|||
PRINT greatest(elements, numbers) |
|||
END |
|||
' Return greatest element given count and list of numbers |
|||
FUNCTION greatest(n, NUMBER a[]) |
|||
LOCAL mx = a[0] |
|||
FOR i = 1 TO n - 1 |
|||
mx = MAX(mx, a[i]) |
|||
NEXT |
|||
RETURN mx |
|||
END FUNCTION</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ ./greatest-element |
|||
500</pre> |
|||
'''See also:''' [[#BBC BASIC|BBC BASIC]], [[#Liberty BASIC|Liberty BASIC]], [[#PowerBASIC|PowerBASIC]], [[#PureBasic|PureBasic]], [[#Run BASIC|Run BASIC]], [[#TI-89 BASIC|TI-89 BASIC]], [[#Visual Basic|Visual Basic]] |
|||
==={{header|BASIC256}}=== |
|||
{{trans|Yabasic}} |
|||
<syntaxhighlight lang="freebasic">l$ = "1,1234,62,234,12,34,6" |
|||
dim n$(1) |
|||
n$ = explode(l$, ",") |
|||
m$ = "" : m = 0 |
|||
for i = 1 to n$[?]-1 |
|||
t$ = n$[i] |
|||
if t$ > m$ then m$ = t$ |
|||
if int(t$) > m then m = int(t$) |
|||
next i |
|||
print "Alphabetic order: "; m$; ", numeric order: "; m</syntaxhighlight> |
|||
==={{header|Chipmunk Basic}}=== |
|||
The [[#GW-BASIC|GW-BASIC]] solution works without any changes. |
|||
==={{header|Minimal BASIC}}=== |
|||
{{trans|Quite BASIC}} |
|||
<syntaxhighlight lang="qbasic">10 PRINT "HOW MANY ITEMS? " |
|||
20 INPUT N |
|||
30 FOR J = 0 TO N-1 |
|||
40 PRINT "VALUE OF ITEM #";J |
|||
50 INPUT T |
|||
60 LET A(J) = T |
|||
70 NEXT J |
|||
80 LET C = A(0) |
|||
90 LET I = 0 |
|||
100 FOR J = 1 TO N-1 |
|||
110 IF A(J) > C THEN 130 |
|||
120 GOTO 150 |
|||
130 LET C = A(J) |
|||
140 LET I = J |
|||
150 NEXT J |
|||
160 PRINT "THE MAXIMUM VALUE WAS ";C;" AT INDEX ";I;"." |
|||
170 END</syntaxhighlight> |
|||
==={{header|IS-BASIC}}=== |
|||
<syntaxhighlight lang="is-basic">1000 DEF FINDMAX(REF ARR) |
|||
1010 LET MX=ARR(LBOUND(ARR)) |
|||
1020 FOR I=LBOUND(ARR)+1 TO UBOUND(ARR) |
|||
1030 LET MX=MAX(MX,ARR(I)) |
|||
1040 NEXT |
|||
1050 LET FINDMAX=MX |
|||
1060 END DEF</syntaxhighlight> |
|||
==={{header|MSX Basic}}=== |
|||
{{works with|MSX BASIC|any}} |
|||
{{trans|GW-BASIC}} |
|||
<syntaxhighlight lang="qbasic">10 INPUT "How many items"; N% |
|||
20 DIM ARR(N%) |
|||
30 FOR I% = 0 TO N% - 1 |
|||
40 PRINT "Value of item #"; I% |
|||
50 INPUT ARR(I%) |
|||
60 NEXT I% |
|||
70 CHAMP = ARR(0) : INDEX = 0 |
|||
80 FOR I% = 1 TO N% - 1 |
|||
90 IF ARR(I%) > CHAMP THEN CHAMP = ARR(I%): INDEX = I% |
|||
100 NEXT I% |
|||
110 PRINT "The maximum value was "; CHAMP; " at index "; INDEX; "." |
|||
120 END</syntaxhighlight> |
|||
==={{header|Quite BASIC}}=== |
|||
{{trans|GW-BASIC}} |
|||
<syntaxhighlight lang="qbasic">10 INPUT "How many items? "; n |
|||
20 ARRAY a |
|||
30 FOR j = 0 TO n-1 |
|||
40 PRINT "Value of item #"; j |
|||
50 INPUT ""; t |
|||
60 LET a(j) = t |
|||
70 NEXT j |
|||
80 LET c = a(0) |
|||
90 LET i = 0 |
|||
100 FOR j = 1 TO n-1 |
|||
110 IF a(j) > c THEN LET c = a(j) : LET i = j |
|||
120 NEXT j |
|||
130 PRINT "The maximum value was "; c; " at index "; i; "." |
|||
140 END</syntaxhighlight> |
|||
==={{header|SmallBASIC}}=== |
|||
<syntaxhighlight lang="qbasic"> |
|||
list = [1,1234,62,234,12,34,6] |
|||
print max(list) |
|||
</syntaxhighlight> |
|||
=={{header|Batch File}}== |
|||
<syntaxhighlight lang="dos">::max.cmd |
|||
@echo off |
|||
setlocal enabledelayedexpansion |
|||
set a=.%~1 |
|||
if "%a%" equ "." set /p a="Input stream: " |
|||
call :max res %a% |
|||
echo %res% |
|||
endlocal |
|||
goto :eof |
|||
:max |
|||
set %1=%2 |
|||
:loop |
|||
shift /2 |
|||
if "%2" equ "" goto :eof |
|||
if %2 gtr !%1! set res=%2 |
|||
goto loop</syntaxhighlight> |
|||
''Invocation from command line or from internal prompt'' |
|||
<syntaxhighlight lang="dos">>max "123 456 3 234243 12" |
|||
234243 |
|||
>max |
|||
Input stream: 5 4 3 2 67 1 |
|||
67</syntaxhighlight> |
|||
=={{header|BBC BASIC}}== |
|||
<syntaxhighlight lang="bbcbasic"> ListOfValues$ = "13, 0, -6, 2, 37, -10, 12" |
|||
PRINT "Maximum value = " ; FNmax(ListOfValues$) |
|||
END |
|||
DEF FNmax(list$) |
|||
LOCAL index%, number, max |
|||
max = VAL(list$) |
|||
REPEAT |
|||
index% = INSTR(list$, ",", index%+1) |
|||
number = VAL(MID$(list$, index%+1)) |
|||
IF number > max THEN max = number |
|||
UNTIL index% = 0 |
|||
= max</syntaxhighlight> |
|||
=={{header|bc}}== |
|||
<syntaxhighlight lang="bc">define m(a[], n) { |
|||
auto m, i |
|||
m = a[0] |
|||
for (i = 1; i < n; i++) { |
|||
if (a[i] > m) m = a[i] |
|||
} |
|||
return(m) |
|||
}</syntaxhighlight> |
|||
=={{header|Befunge}}== |
|||
<syntaxhighlight lang="befunge">001pv < |
|||
>&:01g`#v_1+#^_01g.@ |
|||
^p10 <</syntaxhighlight> |
|||
Only works with positive integers. List must be terminated with -1. |
|||
=={{header|BQN}}== |
|||
<syntaxhighlight lang="bqn">Max ← ⌈´</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Max ¯275‿¯111‿0‿¯1234568‿π‿¯π |
|||
3.141592653589793 |
|||
</pre> |
|||
=={{header|Bracmat}}== |
|||
When comparing two rational numbers, Bracmat compares numerically. In all other cases Bracmat compares lexically. |
|||
<syntaxhighlight lang="text"> ( biggest |
|||
= max |
|||
. !arg: |
|||
| !arg:%?max ?arg |
|||
& !arg:? (%@:>!max:?max) (?&~) |
|||
| !max |
|||
) |
|||
& out$("1:" biggest$(5 100000 -5 aap 3446 NOOT mies 0)) |
|||
& out$("2:" biggest$) |
|||
& out |
|||
$ ( "3:" |
|||
biggest |
|||
$ (5 100000 -5 43756243978569758/13 3365864921428443 87512487957139516/27 3446) |
|||
)</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>1: mies |
|||
2: |
|||
3: 3365864921428443</pre> |
|||
=={{header|Brat}}== |
|||
Arrays have a max function, but here's a manual implementation. |
|||
<syntaxhighlight lang="brat">max = { list | |
|||
list.reduce { n, max | |
|||
true? n > max |
|||
{ max = n } |
|||
{ max } |
|||
} |
|||
} |
|||
p max [3 4 1 2]</syntaxhighlight> |
|||
=={{header|Burlesque}}== |
|||
<syntaxhighlight lang="burlesque"> |
|||
blsq ) {88 99 77 66 55}>] |
|||
99 |
|||
</syntaxhighlight> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
This works well with floats. Replace with double, int or what-have-you before passing a different data type. |
This works well with floats. Replace with double, int or what-have-you before passing a different data type. |
||
< |
<syntaxhighlight lang="c">#include <assert.h> |
||
float max(unsigned int count, float values[]) { |
float max(unsigned int count, float values[]) { |
||
float themax = values[0]; |
|||
assert(count > 0); |
assert(count > 0); |
||
size_t idx; |
|||
for(unsigned int idx = 1; idx < count; ++idx) { |
|||
float themax = values[0]; |
|||
for(idx = 1; idx < count; ++idx) { |
|||
themax = values[idx] > themax ? values[idx] : themax; |
themax = values[idx] > themax ? values[idx] : themax; |
||
} |
} |
||
return themax; |
return themax; |
||
}</ |
}</syntaxhighlight> |
||
The following macro can be used with any number and type of arguments, provided that the arguments are ''simple'', i.e. must not contain subexpressions where commas appear (this is because of the way the arguments are counted; the macro can be modified so that it is up to the caller to count the number of arguments passed). <!-- You might wanna look at the macro from here which can count the number of arguments without parsing commas: http://groups.google.com/group/comp.std.c/browse_thread/thread/77ee8c8f92e4a3fb/346fc464319b1ee5 --> |
The following macro can be used with any number and type of arguments, provided that the arguments are ''simple'', i.e. must not contain subexpressions where commas appear (this is because of the way the arguments are counted; the macro can be modified so that it is up to the caller to count the number of arguments passed). <!-- You might wanna look at the macro from here which can count the number of arguments without parsing commas: http://groups.google.com/group/comp.std.c/browse_thread/thread/77ee8c8f92e4a3fb/346fc464319b1ee5 --> |
||
{{works with|GCC}} |
{{works with|GCC}} |
||
< |
<syntaxhighlight lang="c">#include <stdarg.h> |
||
#define MAX(A,...) ({ inline __typeof__ (A) _max_(__typeof__ (A) a, ...) {\ |
#define MAX(A,...) ({ inline __typeof__ (A) _max_(__typeof__ (A) a, ...) {\ |
||
Line 228: | Line 1,187: | ||
}\ |
}\ |
||
_max_((A),__VA_ARGS__);\ |
_max_((A),__VA_ARGS__);\ |
||
})</ |
})</syntaxhighlight> |
||
=={{header|C sharp|C#}}== |
|||
C# already has a "Maximum Value" function. |
|||
<syntaxhighlight lang="csharp">int[] values = new int[] {1,2,3,4,5,6,7,8,9,10}; |
|||
int max = values.Max();</syntaxhighlight> |
|||
=={{header|C++}}== |
=={{header|C++}}== |
||
A simple wrapper around the standard library function <tt>max_element()</tt>. |
|||
Requires C++17. |
|||
<lang cpp>#include <algorithm> |
|||
<syntaxhighlight lang="cpp">#include <algorithm> //std::max_element |
|||
#include <cassert> |
|||
#include <iterator> //std::begin and std::end |
|||
#include <functional> //std::less |
|||
template< |
template<class It, class Comp = std::less<>> |
||
//requires ForwardIterator<It> && Compare<Comp> |
|||
assert(count > 0); |
|||
constexpr auto max_value(It first, It last, Comp compare = std::less{}) |
|||
return *std::max_element(values, values + count); |
|||
{ |
|||
}</lang> |
|||
//Precondition: first != last |
|||
return *std::max_element(first, last, compare); |
|||
} |
|||
template<class C, class Comp = std::less<>> |
|||
=={{header|C sharp|C#}}== |
|||
//requires Container<C> && Compare<Comp> |
|||
constexpr auto max_value(const C& container, Comp compare = std::less{}) |
|||
{ |
|||
//Precondition: !container.empty() |
|||
using std::begin; using std::end; |
|||
return max_value(begin(container), end(container), compare); |
|||
}</syntaxhighlight> |
|||
=={{header|CFEngine}}== |
|||
C# already have a "Maximum Value" function. |
|||
Note: CFEngine bundles are NOT functions, however they can behave in some ways that are similar to functions. |
|||
<lang csharp>using System.Linq; |
|||
<syntaxhighlight lang="cfengine3"> |
|||
values.Max();</lang> |
|||
bundle agent __main__ |
|||
{ |
|||
vars: |
|||
"number_of_list_elements" |
|||
int => randomint( "0", 100 ), |
|||
unless => isvariable( "$(this.promiser)" ); |
|||
"idx" |
|||
slist => expandrange( "[0-$(number_of_list_elements)]", 1 ), |
|||
unless => isvariable( "$(this.promiser)" ); |
|||
"number[$(idx)]" |
|||
int => randomint( "0", "100" ), |
|||
unless => isvariable( "$(this.promiser)" ); |
|||
"numbers" slist => sort( getvalues( number ), int ); |
|||
methods: |
|||
"Get the greatest value" |
|||
usebundle => greatest_value( @(numbers) ), |
|||
useresult => "returned"; |
|||
reports: |
|||
"'$(returned[max])' is the largest number in $(with)" |
|||
with => join( ",", numbers ); |
|||
} |
|||
bundle agent greatest_value(list_of_values) |
|||
{ |
|||
reports: |
|||
"$(with)" |
|||
with => max( list_of_values, int ), |
|||
bundle_return_value_index => "max"; |
|||
} |
|||
</syntaxhighlight> |
|||
{{output}} |
|||
<pre> |
|||
R: '97' is the largest number in 3,5,6,13,15,30,34,37,47,49,49,53,54,59,59,59,60,62,64,67,78,83,95,97 |
|||
</pre> |
|||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
The Clojure.core function max |
The Clojure.core function max returns the max of its arguments. |
||
< |
<syntaxhighlight lang="clojure">(max 1 2 3 4) ; evaluates to 4 |
||
; |
;; If the values are already in a collection, use apply: |
||
(apply max [1 2 3 4]) ; evaluates to 4</ |
(apply max [1 2 3 4]) ; evaluates to 4</syntaxhighlight> |
||
=={{header|CLU}}== |
|||
<syntaxhighlight lang="clu">% This "maximum" procedure is fully general, as long as |
|||
% the container type has an elements iterator and the |
|||
% data type is comparable. |
|||
% It raises an exception ("empty") if there are no elements. |
|||
maximum = proc [T,U: type] (a: T) returns (U) |
|||
signals (empty) |
|||
where T has elements: itertype (T) yields (U), |
|||
U has gt: proctype (U,U) returns (bool) |
|||
max: U |
|||
seen: bool := false |
|||
for item: U in T$elements(a) do |
|||
if ~seen cor item > max then |
|||
max := item |
|||
seen := true |
|||
end |
|||
end |
|||
if (~seen) then |
|||
signal empty |
|||
else |
|||
return(max) |
|||
end |
|||
end maximum |
|||
start_up = proc () |
|||
po: stream := stream$primary_output() |
|||
% try it on an array of ints |
|||
ints: array[int] := array[int]$[1,5,17,2,53,99,61,3] |
|||
imax: int := maximum[array[int], int](ints) |
|||
stream$putl(po, "maximum int: " || int$unparse(imax)) |
|||
% try it on a sequence of reals |
|||
reals: sequence[real] := sequence[real]$[-0.5, 2.6, 3.14, 2.72] |
|||
rmax: real := maximum[sequence[real], real](reals) |
|||
stream$putl(po, "maximum real: " || real$unparse(rmax)) |
|||
end start_up</syntaxhighlight> |
|||
{{out}} |
|||
<pre>maximum int: 99 |
|||
maximum real: 3.140000e+00</pre> |
|||
=={{header|CMake}}== |
|||
Only for lists of integers. |
|||
<syntaxhighlight lang="cmake"># max(var [value1 value2...]) sets var to the maximum of a list of |
|||
# integers. If list is empty, sets var to NO. |
|||
function(max var) |
|||
set(first YES) |
|||
set(choice NO) |
|||
foreach(item ${ARGN}) |
|||
if(first) |
|||
set(choice ${item}) |
|||
set(first NO) |
|||
elseif(choice LESS ${item}) |
|||
set(choice ${item}) |
|||
endif() |
|||
endforeach(item) |
|||
set(${var} ${choice} PARENT_SCOPE) |
|||
endfunction(max) |
|||
set(list 33 11 44 22 66 55) |
|||
max(maximum ${list}) |
|||
message(STATUS "maximum of ${list} => ${maximum}")</syntaxhighlight> |
|||
<pre>-- maximum of 33;11;44;22;66;55 => 66</pre> |
|||
=={{header|COBOL}}== |
|||
This is already built into the language for tables of numbers. |
|||
<syntaxhighlight lang="cobol">DISPLAY FUNCTION MAX(nums (ALL))</syntaxhighlight> |
|||
A sample implementation: |
|||
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
|||
FUNCTION-ID. greatest-elt. |
|||
DATA DIVISION. |
|||
LOCAL-STORAGE SECTION. |
|||
01 idx USAGE INDEX. |
|||
01 Table-Len CONSTANT 50. |
|||
LINKAGE SECTION. |
|||
01 num-table-area. |
|||
03 num-table PIC 9(8) OCCURS Table-Len TIMES. |
|||
01 max-elt PIC 9(8). |
|||
PROCEDURE DIVISION USING VALUE num-table-area RETURNING max-elt. |
|||
PERFORM VARYING idx FROM 1 BY 1 UNTIL idx > Table-Len |
|||
IF num-table (idx) > max-elt |
|||
MOVE num-table (idx) TO max-elt |
|||
END-IF |
|||
END-PERFORM |
|||
GOBACK |
|||
. |
|||
END FUNCTION greatest-elt.</syntaxhighlight> |
|||
=={{header|CoffeeScript}}== |
|||
<syntaxhighlight lang="coffeescript"> |
|||
# using Math library |
|||
max1 = (list) -> |
|||
Math.max.apply null, list |
|||
# using no libraries |
|||
max2 = (list) -> |
|||
maxVal = list[0] |
|||
for value in list |
|||
maxVal = value if value > maxVal |
|||
maxVal |
|||
# Test it |
|||
a = [0,1,2,5,4]; |
|||
alert(max1(a)+". The answer is "+max2(a)); |
|||
</syntaxhighlight> |
|||
=={{header|ColdFusion}}== |
|||
<syntaxhighlight lang="cfm"> |
|||
<Cfset theList = '1, 1000, 250, 13'> |
|||
<Cfparam name="maxNum" default=0> |
|||
<Cfloop list="#theList#" index="i"> |
|||
<Cfif i gt maxNum><Cfset maxNum = i></Cfif> |
|||
</Cfloop> |
|||
<Cfoutput>#maxNum#</Cfoutput> |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="cfm"> |
|||
<Cfset theList = '1, 1000, 250, 13'> |
|||
<Cfset maxNum = ListFirst(ListSort(thelist, "numeric", "desc"))> |
|||
<Cfoutput>#maxNum#</Cfoutput> |
|||
</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
The built-in Common Lisp function <tt>max</tt> takes the max of all its arguments. |
The built-in Common Lisp function <tt>max</tt> takes the max of all its arguments. |
||
< |
<syntaxhighlight lang="lisp">(max 1 2 3 4) |
||
(reduce #'max values) ; find max of a list |
(reduce #'max values) ; find max of a list |
||
(loop for x in values |
(loop for x in values |
||
maximize x) ; alternative way to find max of a list</ |
maximize x) ; alternative way to find max of a list</syntaxhighlight> |
||
=={{header|Component Pascal}}== |
|||
BalckBox Component Builder |
|||
<syntaxhighlight lang="oberon2"> |
|||
MODULE Operations; |
|||
IMPORT StdLog,Args,Strings; |
|||
PROCEDURE Max(s: ARRAY OF INTEGER): INTEGER; |
|||
VAR |
|||
i: INTEGER; |
|||
max: INTEGER; |
|||
BEGIN |
|||
max := MIN(INTEGER); |
|||
FOR i := 0 TO LEN(s) - 1 DO |
|||
max := MAX(max,s[i]); |
|||
END; |
|||
RETURN max |
|||
END Max; |
|||
PROCEDURE DoMax*; |
|||
VAR |
|||
sq: POINTER TO ARRAY OF INTEGER; |
|||
p: Args.Params; |
|||
i,n,done: INTEGER; |
|||
BEGIN |
|||
Args.Get(p); |
|||
IF p.argc > 0 THEN |
|||
NEW(sq,p.argc); |
|||
FOR i := 0 TO p.argc - 1 DO |
|||
Strings.StringToInt(p.args[i],n,done); |
|||
sq[i] := n |
|||
END; |
|||
StdLog.String("max:> ");StdLog.Int(Max(sq));StdLog.Ln |
|||
END |
|||
END DoMax; |
|||
END Operations. |
|||
</syntaxhighlight> |
|||
Execute: ^Q Operations..DoMax 23 12 3 45 34 54 84 ~<br/> |
|||
{{Out}} |
|||
<pre> |
|||
max:> 84 |
|||
</pre> |
|||
=={{header|Crystal}}== |
|||
<syntaxhighlight lang="ruby">values.max</syntaxhighlight> |
|||
=={{header|D}}== |
=={{header|D}}== |
||
<lang d>import std.stdio, std.algorithm; |
|||
D already has a "Maximum Element" function. |
|||
void main() { |
|||
auto array = [9, 4, 3, 8, 5]; |
|||
<syntaxhighlight lang="d">void main() |
|||
auto m = reduce!max(array); |
|||
{ |
|||
writeln(m); |
|||
import std.algorithm.searching : maxElement; |
|||
}</lang> |
|||
import std.stdio : writeln; |
|||
[9, 4, 3, 8, 5].maxElement.writeln; |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>9</pre> |
|||
=={{header|Dart}}== |
|||
<syntaxhighlight lang="dart">/*This is a function which returns the greatest element in a list of numbers */ |
|||
num findGreatestElement(List<num> list){ |
|||
num greatestElement = list[0]; |
|||
for (num element in list){ |
|||
if (element>greatestElement) { |
|||
greatestElement = element; |
|||
} |
|||
} |
|||
return greatestElement; |
|||
} |
|||
/* and this is a shorter version */ |
|||
import 'dart:math'; |
|||
num findGreatestElement(List<num> list){ |
|||
return list.reduce(max); |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|dc}}== |
|||
<syntaxhighlight lang="dc">[sm llx] sg |
|||
[lm p q] sq |
|||
[d lm <u s_ z 0 =q llx] sl |
|||
[d sm] su |
|||
["Put list of numbers on the stack starting here, then execute g"] s_ |
|||
3.14159265358979 sp |
|||
_275.0 _111.19 0.0 _1234568.0 lp lp _1 * |
|||
lgx</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>3.14159265358979</pre> |
|||
=={{header|DCL}}== |
|||
<syntaxhighlight lang="dcl">$ list = "45,65,81,12,0,13,-56,123,-123,888,12,0" |
|||
$ max = f$integer( f$element( 0, ",", list )) |
|||
$ i = 1 |
|||
$ loop: |
|||
$ element = f$element( i, ",", list ) |
|||
$ if element .eqs. "," then $ goto done |
|||
$ element = f$integer( element ) |
|||
$ if element .gt. max then $ max = element |
|||
$ i = i + 1 |
|||
$ goto loop |
|||
$ done: |
|||
$ show symbol max</syntaxhighlight> |
|||
{{out}} |
|||
<pre>$ @greatest |
|||
MAX = 888 Hex = 00000378 Octal = 00000001570</pre> |
|||
=={{header|Delphi}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
program GElemLIst; |
|||
{$IFNDEF FPC} |
|||
{$Apptype Console} |
|||
{$ENDIF} |
|||
uses |
|||
math; |
|||
const |
|||
MaxCnt = 10000; |
|||
var |
|||
IntArr : array of integer; |
|||
fltArr : array of double; |
|||
i: integer; |
|||
begin |
|||
setlength(fltArr,MaxCnt); //filled with 0 |
|||
setlength(IntArr,MaxCnt); //filled with 0.0 |
|||
randomize; |
|||
i := random(MaxCnt); //choose a random place |
|||
IntArr[i] := 1; |
|||
fltArr[i] := 1.0; |
|||
writeln(Math.MaxIntValue(IntArr)); // Array of Integer |
|||
writeln(Math.MaxValue(fltArr)); |
|||
end. |
|||
</syntaxhighlight> |
|||
=={{header|Dyalect}}== |
|||
<syntaxhighlight lang="dyalect">func max(xs) { |
|||
var y |
|||
for x in xs { |
|||
if y == nil || x > y { |
|||
y = x |
|||
} |
|||
} |
|||
y |
|||
} |
|||
var xs = [1..10] |
|||
max(xs)</syntaxhighlight> |
|||
=={{header|Déjà Vu}}== |
|||
<syntaxhighlight lang="dejavu">max lst: |
|||
lst! 0 |
|||
for item in copy lst: |
|||
if > item dup: |
|||
item drop |
|||
!. max [ 10 300 999 9 ]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>999</pre> |
|||
=={{header|Draco}}== |
|||
<syntaxhighlight lang="draco">/* Find the greatest element in an array of ints */ |
|||
proc nonrec max([*] int a) int: |
|||
int INT_MIN = ~((~0) >> 1); |
|||
int nmax, i; |
|||
nmax := INT_MIN; |
|||
for i from 0 upto dim(a,1)-1 do |
|||
if a[i] > nmax then nmax := a[i] fi |
|||
od; |
|||
nmax |
|||
corp |
|||
/* Test on an array */ |
|||
proc nonrec main() void: |
|||
type arr = [8] int; |
|||
writeln("Maximum: ", max(arr(1,5,17,2,53,99,61,3))) |
|||
corp</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Maximum: 99</pre> |
|||
=={{header|E}}== |
=={{header|E}}== |
||
Line 275: | Line 1,606: | ||
This function works for any value which responds to <code>[http://wiki.erights.org/wiki/Category:Message_max/1 max/1]</code>: |
This function works for any value which responds to <code>[http://wiki.erights.org/wiki/Category:Message_max/1 max/1]</code>: |
||
< |
<syntaxhighlight lang="e">pragma.enable("accumulator") # non-finalized syntax feature |
||
def max([first] + rest) { |
def max([first] + rest) { |
||
return accum first for x in rest { _.max(x) } |
return accum first for x in rest { _.max(x) } |
||
}</ |
}</syntaxhighlight> |
||
< |
<syntaxhighlight lang="e">? max([1, 2, 3]) |
||
# value: 3</ |
# value: 3</syntaxhighlight> |
||
To require only the comparison protocol, one needs to write out the algorithm a little more explicitly: |
To require only the comparison protocol, one needs to write out the algorithm a little more explicitly: |
||
< |
<syntaxhighlight lang="e">def max([var bestSoFar] + rest) { |
||
for x ? (x > bestSoFar) in rest { |
for x ? (x > bestSoFar) in rest { |
||
bestSoFar := x |
bestSoFar := x |
||
} |
} |
||
return bestSoFar |
return bestSoFar |
||
}</ |
}</syntaxhighlight> |
||
< |
<syntaxhighlight lang="e">? max([1, 3, 2]) |
||
# value: 3 |
# value: 3 |
||
? max([[1].asSet(), [2].asSet(), [1, 2].asSet()]) |
? max([[1].asSet(), [2].asSet(), [1, 2].asSet()]) |
||
# value: [1, 2].asSet()</ |
# value: [1, 2].asSet()</syntaxhighlight> |
||
=={{header| |
=={{header|EasyLang}}== |
||
<lang lisp>(defun max (first-arg &rest more-args) |
|||
<syntaxhighlight lang="text">a[] = [ 2 9 4 3 8 5 ] |
|||
(if more-args |
|||
for e in a[] |
|||
(let ((max-rest (apply 'max more-args))) |
|||
max = higher e max |
|||
(if (> first-arg max-rest) |
|||
. |
|||
first-arg |
|||
print max</syntaxhighlight> |
|||
max-rest)) |
|||
first-arg))</lang> |
|||
=={{header|EchoLisp}}== |
|||
Example use: |
|||
<lang |
<syntaxhighlight lang="lisp"> |
||
;; a random length list of random values |
|||
7</lang> |
|||
(define L (map random (make-list (random 50) 100))) → L |
|||
L → (24 60 83 8 24 60 31 97 96 65 9 41 64 24 22 57 73 17 6 28 77 58 18 13 27 22 41 69 85) |
|||
;; find max |
|||
(apply max L) → 97 |
|||
</syntaxhighlight> |
|||
=={{header|ECL}}== |
|||
<syntaxhighlight lang="ecl"> |
|||
MaxVal(SET OF INTEGER s) := MAX(s); |
|||
//example usage |
|||
SetVals := [4,8,16,2,1]; |
|||
MaxVal(SetVals) //returns 16; |
|||
</syntaxhighlight> |
|||
=={{header|Efene}}== |
=={{header|Efene}}== |
||
< |
<syntaxhighlight lang="efene">list_max = fn ([Head:Rest]) { |
||
list_max(Rest, Head) |
list_max(Rest, Head) |
||
} |
} |
||
Line 336: | Line 1,683: | ||
io.format("~p~n", [list_max1([9, 4, 3, 8, 5])]) |
io.format("~p~n", [list_max1([9, 4, 3, 8, 5])]) |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Eiffel}}== |
|||
The GREATEST_ELEMENT class: |
|||
<syntaxhighlight lang="eiffel"> |
|||
class |
|||
GREATEST_ELEMENT [G -> COMPARABLE] |
|||
create |
|||
make |
|||
feature {NONE} --Implementation |
|||
is_max (element: G maximum: G): BOOLEAN |
|||
do |
|||
Result := maximum >= element |
|||
end |
|||
max (list: ARRAY [G]): G |
|||
require |
|||
not_empty: not list.is_empty |
|||
do |
|||
Result := list [list.lower] |
|||
across |
|||
list as i |
|||
loop |
|||
Result := i.item.max (Result) |
|||
end |
|||
ensure |
|||
is_part_of_array: list.has (Result) |
|||
is_maximum: list.for_all (agent is_max(?, Result)) |
|||
end |
|||
feature -- Initialization |
|||
make |
|||
do |
|||
end |
|||
greatest_element (a: ARRAY [G]): G |
|||
do |
|||
Result := max (a) |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
A test application: |
|||
<syntaxhighlight lang="eiffel"> |
|||
class |
|||
APPLICATION |
|||
create |
|||
make |
|||
feature {NONE} -- Initialization |
|||
make |
|||
-- Run application. |
|||
local |
|||
numbers: ARRAY [INTEGER] |
|||
greatest: GREATEST_ELEMENT [INTEGER] |
|||
do |
|||
create greatest.make |
|||
numbers := <<1, 2, 3, 4, 5, 6, 7, 8, 9>> |
|||
print (greatest.greatest_element (numbers)) |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Ela}}== |
|||
<syntaxhighlight lang="ela">open list |
|||
findBy p (x::xs) = foldl (\x y | p x y -> x | else -> y) x xs |
|||
maximum = findBy (>) |
|||
maximum [1..10]</syntaxhighlight> |
|||
=={{header|Elena}}== |
|||
ELENA 6.x : |
|||
<syntaxhighlight lang="elena">import extensions; |
|||
extension op |
|||
{ |
|||
get Maximal() |
|||
{ |
|||
auto en := cast Enumerator(self.enumerator()); |
|||
object maximal := nil; |
|||
while (en.next()) |
|||
{ |
|||
var item := *en; |
|||
if (nil == maximal) |
|||
{ |
|||
maximal := item |
|||
} |
|||
else if (maximal < item) |
|||
{ |
|||
maximal := item |
|||
} |
|||
}; |
|||
^ maximal |
|||
} |
|||
} |
|||
public program() |
|||
{ |
|||
console.printLine(new int[]{1,2,3,4,20,10,9,8}.Maximal) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
20 |
|||
</pre> |
|||
=={{header|Elixir}}== |
|||
<syntaxhighlight lang="elixir">iex(1)> Enum.max([3,1,4,1,5,9,2,6,5,3]) |
|||
9</syntaxhighlight> |
|||
=={{header|Emacs Lisp}}== |
|||
<syntaxhighlight lang="lisp">(defun find-maximum (items) |
|||
(let (max) |
|||
(dolist (item items) |
|||
(when (or (not max) (> item max)) |
|||
(setq max item))) |
|||
max)) |
|||
(find-maximum '(2 7 5)) ;=> 7</syntaxhighlight> |
|||
Built-in: |
|||
<syntaxhighlight lang="lisp">(max '(2 7 5)) ;=> 7</syntaxhighlight> |
|||
{{libheader|cl-lib}} |
|||
<syntaxhighlight lang="lisp">(cl-loop for el in '(2 7 5) maximize el) ;=> 7 |
|||
(cl-reduce #'max '(2 7 5)) ;=> 7</syntaxhighlight> |
|||
{{libheader|seq.el}} |
|||
<syntaxhighlight lang="lisp">(seq-max '(2 7 5)) ;=> 7</syntaxhighlight> |
|||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
Builtin. Using it from the Erlang shell: |
|||
From [http://www.erlang.org/doc/getting_started/seq_prog.html here] |
|||
<lang |
<syntaxhighlight lang="erlang">>lists:max([9,4,3,8,5]). |
||
9</syntaxhighlight> |
|||
list_max(Rest, Head). |
|||
=={{header|ERRE}}== |
|||
<syntaxhighlight lang="erre"> |
|||
PROGRAM MAXLIST |
|||
! |
|||
! for rosettacode.org |
|||
! |
|||
! VAR L$,EL$,CH$,I%,MAX |
|||
BEGIN |
|||
PRINT(CHR$(12);) ! CLS |
|||
INPUT("Lista",L$) |
|||
L$=L$+CHR$(32) |
|||
MAX=-1.7E+38 |
|||
FOR I%=1 TO LEN(L$) DO |
|||
CH$=MID$(L$,I%,1) |
|||
IF CH$<>CHR$(32) THEN ! blank is separator |
|||
EL$=EL$+CH$ |
|||
ELSE |
|||
IF VAL(EL$)>MAX THEN MAX=VAL(EL$) END IF |
|||
EL$="" |
|||
END IF |
|||
END FOR |
|||
PRINT("Max list element is";MAX) |
|||
END PROGRAM |
|||
</syntaxhighlight> |
|||
Note: The limit of this program is string variable lenght (255 chars). The advantage is no array use. |
|||
=={{header|Euler}}== |
|||
Euler allows hetrogenous lists, the <code>real</code> operator converts boolean and symbol (short character strings) to a number (leaving numeric values unchanged) and the <code>isu</code> operator tests whether its operand is <code>undefined</code> or not. |
|||
'''begin''' '''new''' greatest; |
|||
greatest <- ` '''formal''' ls; |
|||
'''begin''' '''new''' L; '''new''' i; '''new''' result; '''label''' iLoop; |
|||
L <- ls; |
|||
result <- '''undefined'''; |
|||
i <- 0; |
|||
iLoop: '''if''' [ i <- i + 1 ] <= '''length''' L '''then''' '''begin''' |
|||
'''if''' '''isu''' result '''or''' '''real''' L[ i ] > '''real''' result |
|||
'''then''' result <- L[ i ] '''else''' 0; |
|||
'''goto''' iLoop |
|||
'''end''' '''else''' 0; |
|||
result |
|||
'''end''' |
|||
'; |
|||
'''out''' greatest( ( '''false''', 99.0, -271, "b", 3, 4 ) ) |
|||
'''end''' $ |
|||
=={{header|Euler Math Toolbox}}== |
|||
<syntaxhighlight lang="text"> |
|||
list_max([], Res) -> Res; |
|||
>v=random(1,100); |
|||
list_max([Head|Rest], Max) when Head > Max -> |
|||
>max(v) |
|||
list_max(Rest, Head); |
|||
0.997492478596 |
|||
list_max([_Head|Rest], Max) -> list_max(Rest, Max).</lang> |
|||
</syntaxhighlight> |
|||
or an alternative [shorter] version using the standard function max/2 within a fold: |
|||
<lang erlang>list_max([H|T]) -> lists:foldl(fun erlang:max/2, H, T).</lang> |
|||
Using it. |
|||
<lang erlang>>list_max([9,4,3,8,5]). |
|||
9</lang> |
|||
=={{header|Euphoria}}== |
=={{header|Euphoria}}== |
||
===Applying a function to each element of an array=== |
===Applying a function to each element of an array=== |
||
< |
<syntaxhighlight lang="euphoria">function aeval( sequence sArr, integer id ) |
||
for i = 1 to length( sArr ) do |
for i = 1 to length( sArr ) do |
||
sArr[ i ] = call_func( id, { sArr[ i ] } ) |
sArr[ i ] = call_func( id, { sArr[ i ] } ) |
||
Line 376: | Line 1,910: | ||
sequence s |
sequence s |
||
s = { |
s = {"antelope", "dog", "cat", "cow", "wolf", "wolverine", "aardvark"} |
||
biggun = "ant" |
biggun = "ant" |
||
a = aeval( s, routine_id("biggest") ) |
a = aeval( s, routine_id("biggest") ) |
||
printf( 1, "%s\n", {biggun} )</ |
printf( 1, "%s\n", {biggun} )</syntaxhighlight> |
||
{{Out}} |
|||
Output: |
|||
<pre> |
<pre> |
||
1234 |
1234 |
||
Line 387: | Line 1,921: | ||
===More trivial example=== |
===More trivial example=== |
||
< |
<syntaxhighlight lang="euphoria">function get_biggest(sequence s) |
||
object biggun |
object biggun |
||
biggun = s[1] |
biggun = s[1] |
||
Line 401: | Line 1,935: | ||
printf(1,"%d\n",get_biggest(numbers)) |
printf(1,"%d\n",get_biggest(numbers)) |
||
constant animals = { "antelope", "dog", "cat", "cow", "wolf", "wolverine", "aardvark"} |
constant animals = {"ant", "antelope", "dog", "cat", "cow", "wolf", "wolverine", "aardvark"} |
||
printf(1,"%s\n",{get_biggest(animals)})</ |
printf(1,"%s\n",{get_biggest(animals)})</syntaxhighlight> |
||
{{Out}} |
|||
Output: |
|||
<pre> |
<pre> |
||
1234 |
1234 |
||
Line 410: | Line 1,944: | ||
</pre> |
</pre> |
||
=={{header| |
=={{header|Excel}}== |
||
Use the function MAX |
|||
<syntaxhighlight lang="excel"> |
|||
F# has a built in function for getting the max of a list: |
|||
=MAX(3;2;1;4;5;23;1;2) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
23 |
|||
</pre> |
|||
=={{header|F_Sharp|F#}}== |
|||
<lang fsharp>>[2;3;4;5;36;3;2;6;7] |> List.max;; |
|||
val it : int = 36</lang> |
|||
I generate a list of 10 random numbers at runtime then use F#'s built in function to find the maximum value of the list. |
|||
To use as a function |
|||
<lang fsharp>let ListMax n = n |> List.max</lang> |
|||
<syntaxhighlight lang="fsharp"> |
|||
let N = System.Random() |
|||
let G = List.init 10 (fun _->N.Next()) |
|||
List.iter (printf "%d ") G |
|||
printfn "\nMax value of list is %d" (List.max G) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
401566008 1378437959 1806806326 2010005455 1973773308 1216833747 268836584 1963610340 2120237482 1412806752 |
|||
Max value of list is 2120237482 |
|||
</pre> |
|||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
The following word is in factor's standard library. |
The following word is in factor's standard library. |
||
< |
<syntaxhighlight lang="factor">: supremum ( seq -- elt ) [ ] [ max ] map-reduce ;</syntaxhighlight> |
||
=={{header|Fancy}}== |
=={{header|Fancy}}== |
||
< |
<syntaxhighlight lang="fancy">[1,-2,2,4,6,-4,-1,5] max println # => 6</syntaxhighlight> |
||
=={{header|Fantom}}== |
=={{header|Fantom}}== |
||
Line 431: | Line 1,982: | ||
Has a built-in method to get maximum from a list. |
Has a built-in method to get maximum from a list. |
||
< |
<syntaxhighlight lang="fantom"> |
||
class Greatest |
class Greatest |
||
{ |
{ |
||
Line 441: | Line 1,992: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
< |
<syntaxhighlight lang="forth">: array-max ( addr len -- max ) |
||
dup 0= if nip exit then |
dup 0= if nip exit then |
||
over @ rot cell+ rot 1- |
over @ rot cell+ rot 1- |
||
cells bounds ?do i @ max cell +loop ; |
cells bounds ?do i @ max cell +loop ; |
||
: stack-max ( n ... m count -- max ) 1 ?do max loop ;</ |
: stack-max ( n ... m count -- max ) 1 ?do max loop ;</syntaxhighlight> |
||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
Line 456: | Line 2,007: | ||
The intrinsic function <tt>maxval</tt> returns the maximum value of the elements in an integer or real array: |
The intrinsic function <tt>maxval</tt> returns the maximum value of the elements in an integer or real array: |
||
< |
<syntaxhighlight lang="fortran">program test_maxval |
||
integer,dimension(5),parameter :: x = [10,100,7,1,2] |
integer,dimension(5),parameter :: x = [10,100,7,1,2] |
||
Line 464: | Line 2,015: | ||
write(*,'(F5.1)') maxval(y) |
write(*,'(F5.1)') maxval(y) |
||
end program test_maxval</ |
end program test_maxval</syntaxhighlight> |
||
{{Out}} |
|||
Output: |
|||
<pre> |
|||
100 |
100 |
||
678.0 |
678.0 |
||
</pre> |
|||
The intrinsic function <tt>max</tt> accepts any number of arguments. |
The intrinsic function <tt>max</tt> accepts any number of arguments. |
||
The type of these arguments can be integer, real, character, string of characters or arrays of these. |
|||
<lang fortran>program test_max |
|||
<syntaxhighlight lang="fortran">program test_max |
|||
implicit none |
implicit none |
||
Line 492: | Line 2,046: | ||
& max (['abc', 'hig', 'fde'], ['ghi', 'efd', 'cab'], ['def', 'bca', 'igh']) |
& max (['abc', 'hig', 'fde'], ['ghi', 'efd', 'cab'], ['def', 'bca', 'igh']) |
||
end program test_max</ |
end program test_max</syntaxhighlight> |
||
{{Out}} |
|||
Output: |
|||
<pre> |
|||
3 |
3 |
||
3.0 |
3.0 |
||
Line 502: | Line 2,057: | ||
g h i |
g h i |
||
ghi hig igh |
ghi hig igh |
||
</pre> |
|||
=={{header|FreeBASIC}}== |
|||
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
|||
Function MaxElement(a() As Double) As Double |
|||
Dim max As Double = a(LBound(a)) |
|||
For i As Integer = LBound(a) + 1 To UBound(a) |
|||
If a(i) > max Then max = a(i) |
|||
Next |
|||
Return max |
|||
End Function |
|||
Dim As Integer i, n |
|||
Input "How many values are to be input "; n |
|||
If n < 1 Then End |
|||
Dim a(1 To n) As Double |
|||
For i = 1 To n |
|||
Print " Value"; i; " : "; |
|||
Input "", a(i) |
|||
Next |
|||
Dim max As Double = MaxElement(a()) |
|||
Print |
|||
Print "The greatest value is"; max |
|||
Print |
|||
Print "Press any key to quit" |
|||
Sleep |
|||
</syntaxhighlight> |
|||
Example of use : |
|||
{{out}} |
|||
<pre> |
|||
How many values are to be input ? 4 |
|||
Value 1 : 70.5 |
|||
Value 2 : 23.67 |
|||
Value 3 : 150.2 |
|||
Value 4 : 145 |
|||
The greatest value is 150.2 |
|||
</pre> |
|||
=={{header|Frink}}== |
|||
<syntaxhighlight lang="frink"> |
|||
println[max[[1,2,3,5,10,20]]] |
|||
</syntaxhighlight> |
|||
=={{header|FunL}}== |
|||
Using the pre-defined function <code>max</code>: |
|||
<syntaxhighlight lang="funl">println( max([1,2,3,-1,0]) )</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
</pre> |
|||
It can be implemented as: |
|||
<syntaxhighlight lang="funl">def |
|||
maximum( xs ) = |
|||
def |
|||
max( a, b ) = if a <= b then b else a |
|||
foldl( f, z, [] ) = z |
|||
foldl( f, z, x:xs ) = foldl( f, f(z, x), xs ) |
|||
foldl1( f, x:xs ) = foldl( f, x, xs ) |
|||
foldl1( _, [] ) = error( "foldl1: empty list" ) |
|||
foldl1( max, xs )</syntaxhighlight> |
|||
=={{header|Futhark}}== |
|||
This parallel formulation exploits the fact that negative infinity constitutes a neutral element for the maximum operator. |
|||
<syntaxhighlight lang="futhark"> |
|||
let main (xs: []f64) = reduce f64.max (-f64.inf) xs |
|||
</syntaxhighlight> |
|||
=={{header|FutureBasic}}== |
|||
The function fn GreatestElementInList() will sort and return the greatest element of any list that supports the @"compare:" operator. |
|||
<syntaxhighlight lang="futurebasic"> |
|||
include "NSLog.incl" |
|||
local fn GreatestElementInList( list as CFArrayRef ) as CFTypeRef |
|||
CfArrayRef array = fn ArraySortedArrayUsingSelector( list, @"compare:" ) |
|||
CFTypeRef result = fn ArrayLastObject( array ) |
|||
end fn = result |
|||
CFArrayRef array |
|||
array = @[@1, @-2, @10, @5.0, @10.5] |
|||
NSLog( @"%@", fn GreatestElementInList( array ) ) |
|||
// Greatest element will be letter with highest ASCII value |
|||
array = @[@"A", @"b", @"C", @"d", @"E"] |
|||
NSLog( @"%@", fn GreatestElementInList( array ) ) |
|||
array = @[@"ant", @"antelope", @"dog", @"cat", @"cow", @"wolf", @"wolverine", @"aardvark"] |
|||
NSLog( @"%@", fn GreatestElementInList( array ) ) |
|||
array = @[@"abc", @"123", @"zyx", @"def"] |
|||
NSLog( @"%@", fn GreatestElementInList( array ) ) |
|||
HandleEvents |
|||
</syntaxhighlight> |
|||
{{output}} |
|||
<pre style="font-size: 13px"> |
|||
10.5 |
|||
d |
|||
wolverine |
|||
zyx |
|||
</pre> |
|||
=={{header|Fōrmulæ}}== |
|||
{{FormulaeEntry|page=https://formulae.org/?script=examples/Greatest_element_of_a_list}} |
|||
'''Solution''' |
|||
Fōrmulæ provides a built-in expression "Max" that reduces to the maximum element of a given list: |
|||
'''Case 1. With numbers''' |
|||
[[File:Fōrmulæ - Greatest element of a list 01.png]] |
|||
[[File:Fōrmulæ - Greatest element of a list 02.png]] |
|||
'''Case 2. With strings''' |
|||
[[File:Fōrmulæ - Greatest element of a list 03.png]] |
|||
[[File:Fōrmulæ - Greatest element of a list 04.png]] |
|||
'''Case 3. With time expressions''' |
|||
[[File:Fōrmulæ - Greatest element of a list 05.png]] |
|||
[[File:Fōrmulæ - Greatest element of a list 06.png]] |
|||
=={{header|GW-BASIC}}== |
|||
<syntaxhighlight lang="gwbasic">10 INPUT "How many items? ", N% |
|||
20 DIM ARR(N%) |
|||
30 FOR I% = 0 TO N%-1 |
|||
40 PRINT "Value of item #";I% |
|||
50 INPUT ARR(I%) |
|||
60 NEXT I% |
|||
70 CHAMP = ARR(0) : INDEX = 0 |
|||
80 FOR I% = 1 TO N%-1 |
|||
90 IF ARR(I%)>CHAMP THEN CHAMP=ARR(I%):INDEX=I% |
|||
100 NEXT I% |
|||
110 PRINT "The maximum value was ";CHAMP;" at index ";INDEX;"." |
|||
120 END</syntaxhighlight> |
|||
=={{header|GAP}}== |
|||
<syntaxhighlight lang="gap"># Built-in |
|||
L := List([1 .. 100], n -> Random(1, 10)); |
|||
MaximumList(L); |
|||
# 10</syntaxhighlight> |
|||
=={{header|Go}}== |
=={{header|Go}}== |
||
;Library |
|||
<lang go>package main |
|||
::<syntaxhighlight lang="go">package main |
|||
import ( |
import ( |
||
"fmt" |
"fmt" |
||
"rand" |
|||
"github.com/gonum/floats" |
|||
) |
|||
func main() { |
|||
fmt.Println(floats.Max([]float64{63, 70, 37, 34, 83, 27, 19, 97, 9, 17})) // prt 97 |
|||
fmt.Println(floats.Min([]float64{63, 70, 37, 34, 83, 27, 19, 97, 9, 17})) // prt 9 |
|||
}</syntaxhighlight> |
|||
::<syntaxhighlight lang="go">package main |
|||
import "fmt" |
|||
func main() { |
|||
x := []int{ |
|||
48, 96, 86, 68, |
|||
57, 82, 63, 70, |
|||
37, 34, 83, 27, |
|||
19, 97, 9, 17, |
|||
} |
|||
smallest, biggest := x[0], x[0] |
|||
for _, v := range x { |
|||
if v > biggest { |
|||
biggest = v |
|||
} |
|||
if v < smallest { |
|||
smallest = v |
|||
} |
|||
} |
|||
fmt.Println("The biggest number is ", biggest) // prt 97 |
|||
fmt.Println("The smallest number is ", smallest) // prt 9 |
|||
}</syntaxhighlight> |
|||
;List |
|||
The task title says list. This solution uses a Go slice as a list. |
|||
<syntaxhighlight lang="go">package main |
|||
import ( |
|||
"fmt" |
|||
"math/rand" |
|||
"time" |
"time" |
||
) |
) |
||
// function, per task description |
// function, per task description |
||
func largest(a []int) (lg int) { |
func largest(a []int) (lg int, ok bool) { |
||
if len(a) == 0 { |
|||
return |
|||
} |
|||
lg = a[0] |
|||
for _, e := range a[1:] { |
|||
if e > lg { |
if e > lg { |
||
lg = e |
lg = e |
||
} |
} |
||
} |
} |
||
return |
return lg, true |
||
} |
} |
||
func main() { |
func main() { |
||
// random size |
// random size slice |
||
rand.Seed(time. |
rand.Seed(time.Now().UnixNano()) |
||
a := make([]int, |
a := make([]int, rand.Intn(11)) |
||
for i := range a { |
for i := range a { |
||
a[i] = rand.Intn(101) // fill with random numbers |
a[i] = rand.Intn(101) - 100 // fill with random numbers |
||
} |
} |
||
fmt.Println |
fmt.Println(a) |
||
lg, ok := largest(a) |
|||
}</lang> |
|||
if ok { |
|||
fmt.Println(lg) |
|||
} else { |
|||
fmt.Println("empty list. no maximum.") |
|||
} |
|||
}</syntaxhighlight> |
|||
;Set |
|||
The task description says set. This solution uses a Go map as a set. |
|||
<syntaxhighlight lang="go">package main |
|||
import ( |
|||
"fmt" |
|||
"math" |
|||
"math/rand" |
|||
"time" |
|||
) |
|||
// Function, per task description. Interesting with the float64 type because |
|||
// of the NaN value. NaNs do not compare to other values, so the result of |
|||
// a "largest" function on a set containing a NaN might be open to |
|||
// interpretation. The solution provided here is to return the largest |
|||
// of the non-NaNs, and also return a bool indicating the presense of a NaN. |
|||
func largest(s map[float64]bool) (lg float64, ok, nan bool) { |
|||
if len(s) == 0 { |
|||
return |
|||
} |
|||
for e := range s { |
|||
switch { |
|||
case math.IsNaN(e): |
|||
nan = true |
|||
case !ok || e > lg: |
|||
lg = e |
|||
ok = true |
|||
} |
|||
} |
|||
return |
|||
} |
|||
func main() { |
|||
rand.Seed(time.Now().UnixNano()) |
|||
// taking "set" literally from task description |
|||
s := map[float64]bool{} |
|||
// pick number of elements to add to set |
|||
n := rand.Intn(11) |
|||
// add random numbers, also throw in an occasional NaN or Inf. |
|||
for i := 0; i < n; i++ { |
|||
switch rand.Intn(10) { |
|||
case 0: |
|||
s[math.NaN()] = true |
|||
case 1: |
|||
s[math.Inf(1)] = true |
|||
default: |
|||
s[rand.ExpFloat64()] = true |
|||
} |
|||
} |
|||
fmt.Print("s:") |
|||
for e := range s { |
|||
fmt.Print(" ", e) |
|||
} |
|||
fmt.Println() |
|||
switch lg, ok, nan := largest(s); { |
|||
case ok && !nan: |
|||
fmt.Println("largest:", lg) |
|||
case ok: |
|||
fmt.Println("largest:", lg, "(NaN present in data)") |
|||
case nan: |
|||
fmt.Println("no largest, all data NaN") |
|||
default: |
|||
fmt.Println("no largest, empty set") |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Golfscript}}== |
|||
<syntaxhighlight lang="golfscript">{$-1=}:max; |
|||
[1 4 8 42 6 3]max # Example usage</syntaxhighlight> |
|||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
< |
<syntaxhighlight lang="groovy">println ([2,4,0,3,1,2,-12].max())</syntaxhighlight> |
||
{{Out}} |
|||
Output: |
|||
<pre>4</pre> |
<pre>4</pre> |
||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
The built-in Haskell function <tt>maximum</tt> |
The built-in Haskell function <tt>maximum</tt> returns a maximum based on default comparison between members of an ordered type. |
||
< |
<syntaxhighlight lang="haskell">my_max = maximum</syntaxhighlight> |
||
It can alternately be defined as a "fold" on the built-in two-argument <tt>max</tt> function. |
It can alternately be defined as a "fold" on the built-in two-argument <tt>max</tt> function. |
||
< |
<syntaxhighlight lang="haskell">my_max = foldl1 max</syntaxhighlight> |
||
More generally, '''maximum''' is a special case of '''maximumBy''', which allows us to define or supply our own comparison function, and define the particular type of maximum that we need: |
|||
<syntaxhighlight lang="haskell">import Data.List (maximumBy) |
|||
import Data.Ord (comparing) |
|||
wds :: [String] |
|||
wds = ["alpha", "beta", "gamma", "delta", "epsilon", "zeta"] |
|||
main :: IO () |
|||
main = print $ maximumBy (comparing length) wds</syntaxhighlight> |
|||
As a fold, maximumBy could be defined along the lines of: |
|||
<syntaxhighlight lang="haskell">maximumBy |
|||
:: Foldable t |
|||
=> (a -> a -> Ordering) -> t a -> a |
|||
maximumBy cmp = |
|||
let max_ x y = |
|||
case cmp x y of |
|||
GT -> x |
|||
_ -> y |
|||
in foldr1 max_</syntaxhighlight> |
|||
=={{header|hexiscript}}== |
|||
<syntaxhighlight lang="hexiscript">fun greatest a |
|||
let l len a |
|||
let max a[0] |
|||
for let i 1; i < l; i++ |
|||
if max < a[i] |
|||
let max a[i] |
|||
endif |
|||
endfor |
|||
return max |
|||
endfun</syntaxhighlight> |
|||
=={{header|HicEst}}== |
=={{header|HicEst}}== |
||
< |
<syntaxhighlight lang="hicest"> |
||
max_value = MAX( -123, 234.56, 345.678, -456E3, -455) ! built-in function MAX(...) |
max_value = MAX( -123, 234.56, 345.678, -456E3, -455) ! built-in function MAX(...) |
||
Line 568: | Line 2,438: | ||
! max_value=345.678; values_found=30; values(1)=-123; values(2)=234.56; values(3)=345.678; values(4)=-456E3; values(5)=-455; values(6)=1; values(7)=2; values(8)=1; values(9)=0; values(10)=0; ...truncated |
! max_value=345.678; values_found=30; values(1)=-123; values(2)=234.56; values(3)=345.678; values(4)=-456E3; values(5)=-455; values(6)=1; values(7)=2; values(8)=1; values(9)=0; values(10)=0; ...truncated |
||
END |
END |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Hoon}}== |
|||
<syntaxhighlight lang="hoon">:- %say |
|||
|= [^ [a=(list ,@) ~] ~] |
|||
:- %noun |
|||
(snag 0 (sort a gte))</syntaxhighlight> |
|||
Usage: Add to a file gen/max.hoon |
|||
<pre> |
|||
> +max [1 2 3 ~] |
|||
3 |
|||
</pre> |
|||
=={{header|i}}== |
|||
<syntaxhighlight lang="i">concept largest(l) { |
|||
large = l[0] |
|||
for element in l |
|||
if element > large |
|||
large = element |
|||
end |
|||
end |
|||
return large |
|||
} |
|||
software { |
|||
print(largest([23, 1313, 21, 35757, 4, 434, 232, 2, 2342])) |
|||
}</syntaxhighlight> |
|||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
< |
<syntaxhighlight lang="icon">procedure main() |
||
local l |
local l |
||
l := [7,8,6,9,4,5,2,3,1] |
l := [7,8,6,9,4,5,2,3,1] |
||
Line 582: | Line 2,478: | ||
every max <:= !l |
every max <:= !l |
||
return max |
return max |
||
end</ |
end</syntaxhighlight> |
||
=={{Header|Insitux}}== |
|||
<code>max</code> is a built-in operation. |
|||
<syntaxhighlight lang="insitux"> |
|||
(max 1 2 3 4) |
|||
;or |
|||
(... max [1 2 3 4]) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
4 |
|||
</pre> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
'''Solution''':<lang |
'''Solution''':<syntaxhighlight lang="j"> >./</syntaxhighlight> |
||
'''Example''':< |
'''Example''':<syntaxhighlight lang="j"> >./ 1 2 3 2 1 |
||
3 |
3 |
||
>./'' NB. Maximum value of an empty list = identity element (or neutral) of max = -∞ |
>./'' NB. Maximum value of an empty list = identity element (or neutral) of max = -∞ |
||
__</ |
__</syntaxhighlight> |
||
(J's lists know how long they are.) |
|||
=={{header|Janet}}== |
|||
<syntaxhighlight lang="janet"> |
|||
(def elems @[3 1 3 2]) |
|||
# Use extreme function from stdlib with > function. |
|||
(extreme > elems) |
|||
# Unpack list as arguments to max function. |
|||
(max ;elems) |
|||
</syntaxhighlight> |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
<syntaxhighlight lang="java"> |
|||
int max(int[] values) { |
|||
int max = values[0]; |
|||
for (int value : values) |
|||
if (max < value) max = value; |
|||
return max; |
|||
} |
|||
</syntaxhighlight> |
|||
<br /> |
|||
The first function works with arrays of floats. Replace with arrays of double, int, or other primitive data type. |
The first function works with arrays of floats. Replace with arrays of double, int, or other primitive data type. |
||
< |
<syntaxhighlight lang="java">public static float max(float[] values) throws NoSuchElementException { |
||
if (values.length == 0) |
if (values.length == 0) |
||
throw new NoSuchElementException(); |
throw new NoSuchElementException(); |
||
float themax = values[0]; |
float themax = values[0]; |
||
for (int idx = 1; idx < values.length; ++idx) { |
for (int idx = 1; idx < values.length; ++idx) { |
||
if (values[idx] |
if (values[idx] > themax) |
||
themax = values[idx]; |
themax = values[idx]; |
||
} |
} |
||
return themax; |
return themax; |
||
}</ |
}</syntaxhighlight> |
||
Optionally, if it is OK to rearrange the contents of the original array: |
Optionally, if it is OK to rearrange the contents of the original array: |
||
< |
<syntaxhighlight lang="java">public static float max(float[] values) throws NoSuchElementException { |
||
if (values.length == 0) |
if (values.length == 0) |
||
throw new NoSuchElementException(); |
throw new NoSuchElementException(); |
||
Arrays.sort(values);//sorts the values in ascending order |
Arrays.sort(values);//sorts the values in ascending order |
||
return values[values.length-1]; |
return values[values.length-1]; |
||
}</ |
}</syntaxhighlight> |
||
The following functions work with Lists or arrays of reference types, respectively. Note that the type is required to implement Comparable, to ensure we can compare them. For Lists, there is a utility method <tt>Collections.max()</tt> that already does this. For arrays, we can just use the <tt>Arrays.asList()</tt> wrapper to wrap it into a list and then use the function for lists. |
The following functions work with Lists or arrays of reference types, respectively. Note that the type is required to implement Comparable, to ensure we can compare them. For Lists, there is a utility method <tt>Collections.max()</tt> that already does this. For arrays, we can just use the <tt>Arrays.asList()</tt> wrapper to wrap it into a list and then use the function for lists. |
||
< |
<syntaxhighlight lang="java">import java.util.List; |
||
import java.util.Collections; |
import java.util.Collections; |
||
import java.util.Arrays; |
import java.util.Arrays; |
||
Line 623: | Line 2,557: | ||
public static <T extends Comparable<? super T>> T max(T[] values) { |
public static <T extends Comparable<? super T>> T max(T[] values) { |
||
return Collections.max(Arrays.asList(values)); |
return Collections.max(Arrays.asList(values)); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
===ES3-5=== |
|||
Using the built-in Math.max method |
|||
<syntaxhighlight lang="javascript">Math.max.apply(null, [ 0, 1, 2, 5, 4 ]); // 5</syntaxhighlight> |
|||
===ES 5 maxima beyond simple numeric data types=== |
|||
<lang javascript>function max(arr) |
|||
{ |
|||
Math.max() serves well with simple numeric types, but for less restricted use we can write a generic '''maximumBy''' function which returns the maximum value from an array containing a series of any consistent data type, and which takes a type-specific comparison function as an argument. |
|||
return Math.max.apply(null, arr); |
|||
<syntaxhighlight lang="javascript">(function () { |
|||
// (a -> a -> Ordering) -> [a] -> a |
|||
function maximumBy(f, xs) { |
|||
return xs.reduce(function (a, x) { |
|||
return a === undefined ? x : ( |
|||
f(x, a) > 0 ? x : a |
|||
); |
|||
}, undefined); |
|||
} |
|||
// COMPARISON FUNCTIONS FOR SPECIFIC DATA TYPES |
|||
//Ordering: (LT|EQ|GT) |
|||
// GT: 1 (or other positive n) |
|||
// EQ: 0 |
|||
// LT: -1 (or other negative n) |
|||
function wordSortFirst(a, b) { |
|||
return a < b ? 1 : (a > b ? -1 : 0) |
|||
} |
|||
function wordSortLast(a, b) { |
|||
return a < b ? -1 : (a > b ? 1 : 0) |
|||
} |
|||
function wordLongest(a, b) { |
|||
return a.length - b.length; |
|||
} |
|||
function cityPopulationMost(a, b) { |
|||
return a.population - b.population; |
|||
} |
|||
function cityPopulationLeast(a, b) { |
|||
return b.population - a.population; |
|||
} |
|||
function cityNameSortFirst(a, b) { |
|||
var strA = a.name, |
|||
strB = b.name; |
|||
return strA < strB ? 1 : (strA > strB ? -1 : 0); |
|||
} |
|||
function cityNameSortLast(a, b) { |
|||
var strA = a.name, |
|||
strB = b.name; |
|||
return strA < strB ? -1 : (strA > strB ? 1 : 0); |
|||
} |
|||
var lstWords = [ |
|||
'alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta', 'eta', |
|||
'theta', 'iota', 'kappa', 'lambda' |
|||
]; |
|||
var lstCities = [ |
|||
{ |
|||
name: 'Shanghai', |
|||
population: 24.15 |
|||
}, { |
|||
name: 'Karachi', |
|||
population: 23.5 |
|||
}, { |
|||
name: 'Beijing', |
|||
population: 21.5 |
|||
}, { |
|||
name: 'Tianjin', |
|||
population: 14.7 |
|||
}, { |
|||
name: 'Istanbul', |
|||
population: 14.4 |
|||
}, , { |
|||
name: 'Lagos', |
|||
population: 13.4 |
|||
}, , { |
|||
name: 'Tokyo', |
|||
population: 13.3 |
|||
} |
|||
]; |
|||
return [ |
|||
maximumBy(wordSortFirst, lstWords), |
|||
maximumBy(wordSortLast, lstWords), |
|||
maximumBy(wordLongest, lstWords), |
|||
maximumBy(cityPopulationMost, lstCities), |
|||
maximumBy(cityPopulationLeast, lstCities), |
|||
maximumBy(cityNameSortFirst, lstCities), |
|||
maximumBy(cityNameSortLast, lstCities) |
|||
] |
|||
})();</syntaxhighlight> |
|||
{{Out}} |
|||
<syntaxhighlight lang="javascript">[ |
|||
"alpha", |
|||
"zeta", |
|||
"epsilon", |
|||
{ |
|||
"name": "Shanghai", |
|||
"population": 24.15 |
|||
}, |
|||
{ |
|||
"name": "Tokyo", |
|||
"population": 13.3 |
|||
}, |
|||
{ |
|||
"name": "Beijing", |
|||
"population": 21.5 |
|||
}, |
|||
{ |
|||
"name": "Tokyo", |
|||
"population": 13.3 |
|||
} |
|||
]</syntaxhighlight> |
|||
===ES6=== |
|||
For, numbers, a method of the standard Math object: |
|||
<syntaxhighlight lang="javascript">Math.max(...[ 0, 1, 2, 5, 4 ]); // 5</syntaxhighlight> |
|||
and for orderings defined over other datatypes: |
|||
<syntaxhighlight lang="javascript">(() => { |
|||
"use strict"; |
|||
// ----------- GREATEST ELEMENT OF A LIST ------------ |
|||
// maximumByMay :: (a -> a -> Ordering) -> |
|||
// [a] -> Maybe a |
|||
const maximumByMay = f => |
|||
// Nothing, if the list is empty, |
|||
// or just the maximum value when compared |
|||
// in terms of f. |
|||
xs => Boolean(xs.length) ? ( |
|||
Just(xs.slice(1).reduce( |
|||
(a, x) => 0 < f(a)(x) ? ( |
|||
a |
|||
) : x, |
|||
xs[0] |
|||
)) |
|||
) : Nothing(); |
|||
// ---------------------- TEST ----------------------- |
|||
const main = () => |
|||
JSON.stringify( |
|||
catMaybes([ |
|||
maximumByMay( |
|||
comparing(x => x.length) |
|||
)([ |
|||
"alpha", "beta", "gamma", "delta", |
|||
"epsilon", "zeta", "eta" |
|||
]), |
|||
maximumByMay(comparing(x => x.length))([]), |
|||
maximumByMay(comparing(x => x.n))([{ |
|||
k: "Bejing", |
|||
n: 21.5 |
|||
}, { |
|||
k: "Delhi", |
|||
n: 16.7 |
|||
}, { |
|||
k: "Karachi", |
|||
n: 23.5 |
|||
}, { |
|||
k: "Lagos", |
|||
n: 16.0 |
|||
}, { |
|||
k: "Shanghai", |
|||
n: 24.3 |
|||
}, { |
|||
k: "Tokyo", |
|||
n: 13.2 |
|||
}]) |
|||
]), |
|||
null, 2 |
|||
); |
|||
// --------------------- GENERIC --------------------- |
|||
// Just :: a -> Maybe a |
|||
const Just = x => ({ |
|||
type: "Maybe", |
|||
Nothing: false, |
|||
Just: x |
|||
}); |
|||
// Nothing :: Maybe a |
|||
const Nothing = () => ({ |
|||
type: "Maybe", |
|||
Nothing: true |
|||
}); |
|||
// catMaybes :: [Maybe a] -> [a] |
|||
const catMaybes = mbs => |
|||
mbs.flatMap( |
|||
m => m.Nothing ? ( |
|||
[] |
|||
) : [m.Just] |
|||
); |
|||
// comparing :: (a -> b) -> (a -> a -> Ordering) |
|||
const comparing = f => |
|||
x => y => { |
|||
const |
|||
a = f(x), |
|||
b = f(y); |
|||
return a < b ? -1 : (a > b ? 1 : 0); |
|||
}; |
|||
// MAIN --- |
|||
return main(); |
|||
})();</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>[ |
|||
"epsilon", |
|||
{ |
|||
"k": "Shanghai", |
|||
"n": 24.3 |
|||
} |
|||
]</pre> |
|||
=={{header|Joy}}== |
|||
<syntaxhighlight lang="joy">DEFINE maximum == unswons [max] fold.</syntaxhighlight> |
|||
=={{header|jq}}== |
|||
jq defines a total ordering of all JSON entities, and the <tt>max</tt> filter can accordingly be used on any JSON array: |
|||
<syntaxhighlight lang="jq">[1, 3, 1.0] | max # => 3 |
|||
[ {"a": 1}, {"a":3}, {"a":1.0}] | max # => {"a": 3}</syntaxhighlight> |
|||
Warning: both "[null]|max" and "[]|max" yield null. |
|||
Given a stream, s, of JSON values, the following filter will emit null if the stream is empty, or the maximum value otherwise: |
|||
<syntaxhighlight lang="jq">reduce s as $x (null; if $x > . then $x else . end)</syntaxhighlight> |
|||
=={{header|Julia}}== |
|||
Using the built-in <code>maximum</code> function: |
|||
<syntaxhighlight lang="julia">julia> maximum([1,3,3,7]) |
|||
7 |
|||
julia> maximum([pi,e+2/5,cos(6)/5,sqrt(91/10)]) |
|||
3.141592653589793 |
|||
julia> maximum([1,6,Inf]) |
|||
Inf |
|||
julia> maximum(Float64[]) |
|||
maximum: argument is empty |
|||
at In[138]:1 |
|||
in maximum at abstractarray.jl:1591 |
|||
</syntaxhighlight> |
|||
(Note that it throws an exception on an empty array.) |
|||
=={{header|K}}== |
|||
<syntaxhighlight lang="k"> |/ 6 1 7 4 |
|||
7</syntaxhighlight> |
|||
=={{header|Klingphix}}== |
|||
<syntaxhighlight lang="klingphix">include ..\Utilitys.tlhy |
|||
( "1" "1234" "62" "234" "12" "34" "6" ) |
|||
dup "Alphabetic order: " print lmax ? |
|||
:f tonum ; |
|||
@f map |
|||
"Numeric order: " print lmax ? |
|||
" " input</syntaxhighlight> |
|||
=={{header|Klong}}== |
|||
<syntaxhighlight lang="k">list::[ 1.0 2.3 1.1 5.0 3 2.8 2.01 3.14159 77 ] |
|||
|/list |
|||
|/ [ 1.0 2.3 1.1 5.0 3 2.8 2.01 3.14159 66 ] |
|||
|/ 1.0,2.3,1.1,5.0,3,2.8,2.01,3.14159,55</syntaxhighlight> |
|||
{{out}} |
|||
<pre>77 |
|||
66 |
|||
55 |
|||
</pre> |
|||
=={{header|Kotlin}}== |
|||
Kotlin has a max() function in its standard library that applies to collection of Iterable : |
|||
<syntaxhighlight lang="kotlin"> |
|||
fun main() { |
|||
listOf(1.0, 3.5, -1.1).max().also { println(it) } // 3.5 |
|||
listOf(1, 3, -1).max().also { println(it) } // 3 |
|||
setOf(1, 3, -1).max().also { println(it) } // 3 |
|||
} |
} |
||
</syntaxhighlight> |
|||
=={{header|Lambdatalk}}== |
|||
// Test it |
|||
<syntaxhighlight lang="scheme"> |
|||
a = [0,1,2,5,4]; |
|||
1) using the builtin primitive |
|||
alert(max(a));</lang> |
|||
{max 556 1 7344 4 7 52 22 55 88 122 55 99 1222 578} |
|||
-> 7344 |
|||
2) buidling a function |
|||
{def my-max |
|||
{def max-h |
|||
{lambda {:l :greatest} |
|||
{if {A.empty? :l} |
|||
then :greatest |
|||
else {max-h {A.rest :l} |
|||
{if {> {A.first :l} :greatest} |
|||
then {A.first :l} |
|||
else :greatest}}}}} |
|||
{lambda {:l} |
|||
{if {A.empty? :l} then empty else {max-h :l {A.first :l}}}}} |
|||
-> my-max |
|||
{my-max {A.new 556 1 7344 4 7 52 22 55 88 122 55 99 1222 578}} |
|||
-> 7344 |
|||
</syntaxhighlight> |
|||
=={{header|Lasso}}== |
|||
<syntaxhighlight lang="lasso">define greatest(a::array) => { |
|||
return (#a->sort&)->last |
|||
} |
|||
local(x = array(556,1,7344,4,7,52,22,55,88,122,55,99,1222,578)) |
|||
greatest(#x)</syntaxhighlight> |
|||
{{out}} |
|||
<pre>7344</pre> |
|||
=={{header|LDPL}}== |
|||
<syntaxhighlight lang="ldpl">data: |
|||
values is number list |
|||
n is number |
|||
procedure: |
|||
sub max |
|||
parameters: |
|||
x is number list |
|||
result is number |
|||
local data: |
|||
i is number |
|||
procedure: |
|||
store x:0 in result |
|||
for each i in values do |
|||
if i is greater than result then |
|||
store i in result |
|||
end if |
|||
repeat |
|||
end sub |
|||
create statement "get maximum of list $ in $" executing max |
|||
# Now let's use the sub-procedure. |
|||
push 1 to values |
|||
push 11 to values |
|||
push 5 to values |
|||
push 33 to values |
|||
push 99 to values |
|||
push 13 to values |
|||
push 37 to values |
|||
push 50 to values |
|||
get maximum of list values in n |
|||
display "The maximum is " n lf |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
The maximum is 99 |
|||
</pre> |
|||
=={{header|LFE}}== |
|||
Builtin. Using it from the LFE shell: |
|||
<syntaxhighlight lang="lisp">>(: lists max '[9 4 3 8 5]) |
|||
9</syntaxhighlight> |
|||
=={{header|Liberty BASIC}}== |
=={{header|Liberty BASIC}}== |
||
< |
<syntaxhighlight lang="lb">aList$= "1 15 -5 6 39 1.5 14" |
||
maxVal = val(word$(aList$, 1)) |
maxVal = val(word$(aList$, 1)) |
||
Line 649: | Line 2,960: | ||
wend |
wend |
||
print "maxVal = ";maxVal</ |
print "maxVal = ";maxVal</syntaxhighlight> |
||
=={{header|Lingo}}== |
|||
<syntaxhighlight lang="lingo">l = [1,7,5] |
|||
put max(l) |
|||
-- 7</syntaxhighlight> |
|||
=={{header|LiveCode}}== |
|||
Max is built-in<syntaxhighlight lang="livecode">put max(2,3,6,7,4,1)</syntaxhighlight> |
|||
Result: 7 |
|||
To be fair to the exercise, an alternative implementation could be<syntaxhighlight lang="livecode">function max2 lst |
|||
local maxNum |
|||
put item 1 of lst into maxNum |
|||
repeat with n = 1 to the number of items of lst |
|||
if item n of lst > maxNum then |
|||
put item n of lst into maxNum |
|||
end if |
|||
end repeat |
|||
return maxNum |
|||
end max2 |
|||
on mouseUp |
|||
answer max2("1,2,5,6,7,4,3,2") |
|||
end mouseUp</syntaxhighlight> |
|||
=={{header|Logo}}== |
=={{header|Logo}}== |
||
Line 657: | Line 2,992: | ||
to use APPLY instead of REDUCE. The latter is good for associative |
to use APPLY instead of REDUCE. The latter is good for associative |
||
procedures that have been written to accept exactly two inputs: |
procedures that have been written to accept exactly two inputs: |
||
< |
<syntaxhighlight lang="logo">to max :a :b |
||
output ifelse :a > :b [:a] [:b] |
output ifelse :a > :b [:a] [:b] |
||
end |
end |
||
print reduce "max [...]</ |
print reduce "max [...]</syntaxhighlight> |
||
Alternatively, REDUCE can be used to write MAX as a procedure |
Alternatively, REDUCE can be used to write MAX as a procedure |
||
that accepts any number of inputs, as SUM does: |
that accepts any number of inputs, as SUM does: |
||
< |
<syntaxhighlight lang="logo">to max [:inputs] 2 |
||
if emptyp :inputs ~ |
if emptyp :inputs ~ |
||
[(throw "error [not enough inputs to max])] |
[(throw "error [not enough inputs to max])] |
||
output reduce [ifelse ?1 > ?2 [?1] [?2]] :inputs |
output reduce [ifelse ?1 > ?2 [?1] [?2]] :inputs |
||
end</syntaxhighlight> =={{header|Logo}}== |
|||
end</lang> |
|||
{{works with|UCB Logo}} |
|||
<syntaxhighlight lang="logo">to bigger :a :b |
|||
output ifelse [greater? :a :b] [:a] [:b] |
|||
end |
|||
to max :lst |
|||
output reduce "bigger :lst |
|||
end</syntaxhighlight> |
|||
=={{header|Logtalk}}== |
=={{header|Logtalk}}== |
||
< |
<syntaxhighlight lang="logtalk"> |
||
max([X| Xs], Max) :- |
max([X| Xs], Max) :- |
||
max(Xs, X, Max). |
max(Xs, X, Max). |
||
Line 681: | Line 3,024: | ||
max(Xs, X, Max) |
max(Xs, X, Max) |
||
; max(Xs, Aux, Max) |
; max(Xs, Aux, Max) |
||
).</ |
).</syntaxhighlight> |
||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
<syntaxhighlight lang="lua">-- Table to store values |
|||
<lang lua> |
|||
local values = {} |
|||
vals = io.read() + 0 |
|||
-- Read in the first number from stdin |
|||
val_t = {} |
|||
local new_val = io.read"*n" |
|||
-- Append all numbers passed in |
|||
print(math.max(unpack(val_t))) |
|||
-- until there are no more numbers (io.read'*n' = nil) |
|||
</lang> |
|||
while new_val do |
|||
values[#values+1] = new_val |
|||
new_val = io.read"*n" |
|||
end |
|||
-- Print the max |
|||
=={{header|Mathematica}}== |
|||
print(math.max(unpack(values))) |
|||
</syntaxhighlight> |
|||
=={{header|M2000 Interpreter}}== |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module TestThis { |
|||
Print "Search a tuple type list (is an array also)" |
|||
A=(,) |
|||
For i=1 to Random(1,10) |
|||
Append A, (Random(1,100),) |
|||
Next |
|||
Print Len(A) |
|||
Print A |
|||
Print A#max() |
|||
Print "Search an array" |
|||
B=lambda->Random(1,100) |
|||
Rem Dim A(1 to Random(1,10))<<B() |
|||
Dim A(1 to Random(1,10))<<lambda->{=Random(1,100)}() |
|||
Print Len(A()) |
|||
Print A() |
|||
Print A()#max() |
|||
\\ #max() skip non numeric values |
|||
Rem Print (1,"100",3)#max()=3 |
|||
Print "Search an inventory list" |
|||
Inventory C |
|||
for i=1 to Random(1,10) |
|||
do |
|||
key=random(10000) |
|||
until not exist(c, key) |
|||
\\ we can put a number as string |
|||
if random(1,2)=1 then Append c, key:=B() else Append c, key:=str$(B()) |
|||
Next |
|||
\\ if inventory item is string with a number work fine |
|||
Function MaxItem(a) { |
|||
k=each(a,2) |
|||
val=a(0!) |
|||
while k |
|||
\\ using stack of values |
|||
\\ over -equal to over 1 - copy value from 1 to top, means double the top value |
|||
\\ number - pop top value |
|||
\\ drop -equal to drop 1 : drop top value |
|||
Push a(k^!): Over : If Number>val then Read Val else drop |
|||
Rem If a(k^!)>Val Then Val=a(k^!) |
|||
end while |
|||
=val |
|||
} |
|||
Print Len(C) |
|||
Print C |
|||
Print MaxItem(C) |
|||
Print "Search a stack object" |
|||
\\ a stack object is the same as the stack of values |
|||
\\ which always is present |
|||
D=stack |
|||
I=0 |
|||
J=Random(1,10) |
|||
\\ Stack stackobjext {} |
|||
\\ hide current stack and attach the D stack |
|||
Stack D { |
|||
Push B() : I++ : IF I>J Else Loop |
|||
} |
|||
\\ if stack item isn't numeric we get a run time error |
|||
Function MaxItemStack(a) { |
|||
Stack a {env$=envelope$()} |
|||
if replace$("N","", env$)<>"" then error "only numbers allowed" |
|||
k=each(a,2) |
|||
val=Stackitem(a,1) |
|||
while k |
|||
If Stackitem(k)>val then Val=stackitem(k) |
|||
end while |
|||
=val |
|||
} |
|||
Print Len(D) |
|||
Print D |
|||
Print MaxItemStack(D) |
|||
} |
|||
TestThis |
|||
</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
This is a built-in, polymorphic procedure in Maple. |
|||
<syntaxhighlight lang="maple">> max( { 1, 2, Pi, exp(1) } ); # set |
|||
Pi |
|||
> max( [ 1, 2, Pi, exp(1) ] ); # list |
|||
Pi |
|||
> max( 1, 2, Pi, exp(1) ); # sequence |
|||
Pi |
|||
> max( Array( [ 1, 2, Pi, exp(1) ] ) ); # Array |
|||
Pi</syntaxhighlight> |
|||
For numeric data in (multi-dimensional) rtables, a particularly flexible and powerful method for finding the maximum (and many other things) is the use of "rtable_scanblock". The maximum of an Array is a built-in rtable_scanblock operation and can be found as follows. |
|||
<syntaxhighlight lang="maple">> A := Array([1,2,4/5,3,11]): rtable_scanblock( A, [rtable_dims(A)], Maximum ); |
|||
11</syntaxhighlight> |
|||
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
|||
Input: |
Input: |
||
< |
<syntaxhighlight lang="mathematica">Max[1, 3, 3, 7] |
||
Max[Pi,E+2/5,17 Cos[6]/5,Sqrt[91/10]] |
Max[Pi,E+2/5,17 Cos[6]/5,Sqrt[91/10]] |
||
Max[1,6,Infinity] |
Max[1,6,Infinity] |
||
Max[]</ |
Max[]</syntaxhighlight> |
||
{{Out}} |
|||
Output |
|||
<pre> 7 |
|||
<lang Mathematica> 7 |
|||
17 Cos[6]/5 |
17 Cos[6]/5 |
||
Infinity |
Infinity |
||
-Infinity</ |
-Infinity</pre> |
||
Note that Max returns minus infinity if supplied with no arguments; as it should: |
Note that Max returns minus infinity if supplied with no arguments; as it should: |
||
< |
<syntaxhighlight lang="mathematica">Max[Max[],Max[a,b,c]] |
||
Max[Max[a],Max[b,c]] |
Max[Max[a],Max[b,c]] |
||
Max[Max[a,b],Max[c]] |
Max[Max[a,b],Max[c]] |
||
Max[Max[a,b,c],Max[]]</ |
Max[Max[a,b,c],Max[]]</syntaxhighlight> |
||
should all give the same results, therefore max[] should give -Infinity. If it WOULD give 0 strange |
should all give the same results, therefore max[] should give -Infinity. If it WOULD give 0 strange things can happen: |
||
< |
<syntaxhighlight lang="mathematica">Max[Max[], Max[-4, -3]]</syntaxhighlight> |
||
WOULD give 0 instead of -3 |
WOULD give 0 instead of -3 |
||
=={{header|MATLAB}}== |
=={{header|MATLAB}}== |
||
< |
<syntaxhighlight lang="matlab">function [maxValue] = findmax(setOfValues) |
||
maxValue = max(setOfValues);</ |
maxValue = max(setOfValues);</syntaxhighlight> |
||
=={{header|Maxima}}== |
|||
<syntaxhighlight lang="maxima">u : makelist(random(1000), 50)$ |
|||
/* Three solutions */ |
|||
lreduce(max, u); |
|||
apply(max, u); |
|||
lmax(u);</syntaxhighlight> |
|||
=={{header|MAXScript}}== |
|||
MAXScript has a built-in function called amax(), which will return the maximum of an array or the values supplied to it. |
|||
The following custom function will return the maximum of the array supplied to it, or 'undefined' if an empty array is supplied. |
|||
<syntaxhighlight lang="maxscript">fn MaxValue AnArray = |
|||
( |
|||
if AnArray.count != 0 then |
|||
( |
|||
local maxVal = 0 |
|||
for i in AnArray do if i > maxVal then maxVal = i |
|||
maxVal |
|||
) |
|||
else undefined |
|||
)</syntaxhighlight> |
|||
=={{header|Metafont}}== |
|||
The <code>max</code> macro (in the base set of macro for Metafont) accepts any number of arguments, and accepts both numerics (numbers), pairs (bidimensional vectors), and strings (not mixed). |
|||
<syntaxhighlight lang="metafont">show max(4,5,20,1); |
|||
show max((12,3), (10,10), (25,5)); |
|||
show max("hello", "world", "Hello World");</syntaxhighlight> |
|||
=={{header|min}}== |
|||
{{works with|min|0.37.0}} |
|||
<syntaxhighlight lang="min">(() ('> 'pop 'nip if) map-reduce) ^max |
|||
(5 3 2 7 4) max puts!</syntaxhighlight> |
|||
=={{header|MiniScript}}== |
|||
There is a list.max function in the listUtil module, but if you're working in an environment without this module or just want to write it yourself, you might do it as follows. |
|||
<syntaxhighlight lang="miniscript">list.max = function() |
|||
if not self then return null |
|||
result = self[0] |
|||
for item in self |
|||
if item > result then result = item |
|||
end for |
|||
return result |
|||
end function |
|||
print [47, 11, 42, 102, 13].max</syntaxhighlight> |
|||
=={{header|МК-61/52}}== |
|||
<syntaxhighlight lang="text">П0 С/П x=0 07 ИП0 x<0 00 max БП 00</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="text">П0 ИП0 С/П - x<0 01 Вx П0 БП 01</syntaxhighlight> |
|||
=={{header|Modula-3}}== |
=={{header|Modula-3}}== |
||
Line 719: | Line 3,225: | ||
We provide a generic Maximum implementation: |
We provide a generic Maximum implementation: |
||
< |
<syntaxhighlight lang="modula3">GENERIC INTERFACE Maximum(Elem); |
||
EXCEPTION Empty; |
EXCEPTION Empty; |
||
Line 725: | Line 3,231: | ||
PROCEDURE Max(READONLY a: ARRAY OF Elem.T): Elem.T RAISES {Empty}; |
PROCEDURE Max(READONLY a: ARRAY OF Elem.T): Elem.T RAISES {Empty}; |
||
END Maximum.</ |
END Maximum.</syntaxhighlight> |
||
< |
<syntaxhighlight lang="modula3">GENERIC MODULE Maximum(Elem); |
||
PROCEDURE Max(READONLY arr: ARRAY OF Elem.T): Elem.T RAISES {Empty} = |
PROCEDURE Max(READONLY arr: ARRAY OF Elem.T): Elem.T RAISES {Empty} = |
||
Line 744: | Line 3,250: | ||
BEGIN |
BEGIN |
||
END Maximum.</ |
END Maximum.</syntaxhighlight> |
||
<code>Elem</code> can be instantiated to any type (any type that can be compared with the '>' function). For convenience Modula-3 provides interfaces/modules for the built in types, like Integer, Real, LongReal, etc, which contain type definitions as well as properties specific to the type. |
<code>Elem</code> can be instantiated to any type (any type that can be compared with the '>' function). For convenience Modula-3 provides interfaces/modules for the built in types, like Integer, Real, LongReal, etc, which contain type definitions as well as properties specific to the type. |
||
To make a generic interface/module for a specific type, you must instantiate it: |
To make a generic interface/module for a specific type, you must instantiate it: |
||
< |
<syntaxhighlight lang="modula3">INTERFACE RealMax = Maximum(Real) END RealMax.</syntaxhighlight> |
||
< |
<syntaxhighlight lang="modula3">MODULE RealMax = Maximum(Real) END RealMax.</syntaxhighlight> |
||
Now we can import <code>RealMax</code> into our source and use the <code>Max</code> function: |
Now we can import <code>RealMax</code> into our source and use the <code>Max</code> function: |
||
< |
<syntaxhighlight lang="modula3">MODULE Main; |
||
IMPORT RealMax, IO, Fmt; |
IMPORT RealMax, IO, Fmt; |
||
Line 761: | Line 3,267: | ||
BEGIN |
BEGIN |
||
IO.Put(Fmt.Real(RealMax.Max(realarr)) & "\n"); |
IO.Put(Fmt.Real(RealMax.Max(realarr)) & "\n"); |
||
END Main.</ |
END Main.</syntaxhighlight> |
||
=={{header| |
=={{header|MontiLang}}== |
||
MontiLang has a builtin statement <code>MAX</code> which finds the maximum of the top two items on the stack. By looping through an array and pushing to the stack, the largest item in an array can be found. |
|||
<syntaxhighlight lang="montilang">2 5 3 12 9 9 56 2 ARR |
|||
The following custom function will return the maximum of the array supplied to it, or 'undefined' if an empty array is supplied. |
|||
<lang MAXScript>fn MaxValue AnArray = |
|||
( |
|||
if AnArray.count != 0 then |
|||
( |
|||
local maxVal = 0 |
|||
for i in AnArray do if i > maxVal then maxVal = i |
|||
maxVal |
|||
) |
|||
else undefined |
|||
)</lang> |
|||
LEN VAR l . |
|||
=={{header|Metafont}}== |
|||
0 VAR i . |
|||
FOR l |
|||
GET i SWAP |
|||
i 1 + VAR i . |
|||
ENDFOR . |
|||
STKLEN 1 - VAR st . |
|||
FOR st |
|||
MAX |
|||
ENDFOR PRINT</syntaxhighlight> |
|||
Another way to do it. |
|||
The <code>max</code> macro (in the base set of macro for Metafont) accepts any number of arguments, and accepts both numerics (numbers), pairs (bidimensional vectors), and strings (not mixed). |
|||
<syntaxhighlight lang="montilang">2 5 3 12 9 9 56 2 ARR |
|||
<lang metafont>show max(4,5,20,1); |
|||
print |
|||
show max((12,3), (10,10), (25,5)); |
|||
LEN VAR l . |
|||
show max("hello", "world", "Hello World");</lang> |
|||
0 VAR i . |
|||
0 |
|||
FOR l |
|||
swap |
|||
GET i rot max |
|||
i 1 + VAR i . |
|||
ENDFOR |
|||
|Greatest number in the list: | out . print |
|||
|Press ENTER to exit | input |
|||
clear</syntaxhighlight> |
|||
=={{header|MUMPS}}== |
=={{header|MUMPS}}== |
||
<syntaxhighlight lang="mumps"> |
|||
<lang MUMPS> |
|||
MV(A,U) |
MV(A,U) |
||
;A is a list of values separated by the string U |
;A is a list of values separated by the string U |
||
Line 792: | Line 3,307: | ||
FOR I=1:1 SET T=$PIECE(A,U,I) QUIT:T="" S MAX=$SELECT(($DATA(MAX)=0):T,(MAX<T):T,(MAX>=T):MAX) |
FOR I=1:1 SET T=$PIECE(A,U,I) QUIT:T="" S MAX=$SELECT(($DATA(MAX)=0):T,(MAX<T):T,(MAX>=T):MAX) |
||
QUIT MAX |
QUIT MAX |
||
</syntaxhighlight> |
|||
</lang> |
|||
Usage: |
Usage: |
||
<pre> |
<pre> |
||
Line 802: | Line 3,317: | ||
2.3E5 |
2.3E5 |
||
</pre> |
</pre> |
||
=={{header|Nanoquery}}== |
|||
<syntaxhighlight lang="nanoquery">def max(list) |
|||
if len(list) = 0 |
|||
return null |
|||
end |
|||
largest = list[0] |
|||
for val in list |
|||
if val > largest |
|||
largest = val |
|||
end |
|||
end |
|||
return largest |
|||
end</syntaxhighlight> |
|||
=={{header|Neko}}== |
|||
<syntaxhighlight lang="actionscript">/** |
|||
greatest element from a list (Neko Array) |
|||
Tectonics: |
|||
nekoc greatest-element.neko |
|||
neko greatest-element |
|||
*/ |
|||
var greatest = function(list) { |
|||
var max, element; |
|||
var pos = 1; |
|||
if $asize(list) > 0 max = list[0]; |
|||
while pos < $asize(list) { |
|||
element = list[pos]; |
|||
if max < element max = element; |
|||
pos += 1; |
|||
} |
|||
return max; |
|||
} |
|||
$print(greatest($array(5, 1, 3, 5)), "\n"); |
|||
$print(greatest($array("abc", "123", "zyx", "def")), "\n");</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ nekoc greatest-element.neko |
|||
prompt$ neko ./greatest-element.n |
|||
5 |
|||
zyx</pre> |
|||
=={{header|Nemerle}}== |
|||
<syntaxhighlight lang="nemerle">using System; |
|||
using Nemerle.Collections; |
|||
using System.Linq; |
|||
using System.Console; |
|||
module SeqMax |
|||
{ |
|||
SeqMax[T, U] (this seq : T) : U |
|||
where T : Seq[U] |
|||
where U : IComparable |
|||
{ |
|||
$[s | s in seq].Fold(seq.First(), (x, y) => {if (x.CompareTo(y) > 0) x else y}) |
|||
} |
|||
Main() : void |
|||
{ |
|||
def numbers = [1, 12, 3, -5, 6, 23]; |
|||
def letters = ['s', 'p', 'a', 'm']; |
|||
// using SeqMax() method (as task says to "create a function") |
|||
WriteLine($"numbers.SeqMax() = $(numbers.SeqMax())"); |
|||
WriteLine($"letters.SeqMax() = $(letters.SeqMax())"); |
|||
// using the already available Max() method |
|||
WriteLine($"numbers.Max() = $(numbers.Max())"); |
|||
WriteLine($"letters.Max() = $(letters.Max())") |
|||
} |
|||
}</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>numbers.SeqMax() = 23 |
|||
letters.SeqMax() = s |
|||
numbers.Max() = 23 |
|||
letters.Max() = s</pre> |
|||
=={{header|NetRexx}}== |
|||
<syntaxhighlight lang="netrexx">/* NetRexx */ |
|||
options replace format comments java crossref savelog symbols binary |
|||
rn = Random() |
|||
maxElmts = 100 |
|||
dlist = double[maxElmts] |
|||
rlist = Rexx[maxElmts] |
|||
loop r_ = 0 to maxElmts - 1 |
|||
nr = rn.nextGaussian * 100.0 |
|||
dlist[r_] = nr |
|||
rlist[r_] = Rexx(nr) |
|||
end r_ |
|||
say 'Max double:' Rexx(getMax(dlist)).format(4, 9) |
|||
say 'Max Rexx:' getMax(rlist).format(4, 9) |
|||
return |
|||
method getMax(dlist = double[]) public static binary returns double |
|||
dmax = Double.MIN_VALUE |
|||
loop n_ = 0 to dlist.length - 1 |
|||
if dlist[n_] > dmax then dmax = dlist[n_] |
|||
end n_ |
|||
return dmax |
|||
method getMax(dlist = Rexx[]) public static binary returns Rexx |
|||
dmax = Rexx(Double.MIN_VALUE) |
|||
loop n_ = 0 to dlist.length - 1 |
|||
dmax = dlist[n_].max(dmax) |
|||
end n_ |
|||
return dmax |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
Max double: 274.457568703 |
|||
Max Rexx: 274.457568703 |
|||
</pre> |
|||
=={{header|NewLISP}}== |
|||
<syntaxhighlight lang="newlisp">(max 1 2 3 5 2 3 4)</syntaxhighlight> |
|||
<syntaxhighlight lang="newlisp">(apply max '(1 2 3 5 2 3 4)) ; apply to list |
|||
; Added by Nehal-Singhal 2018-05-29</syntaxhighlight> |
|||
=={{header|Nial}}== |
=={{header|Nial}}== |
||
The behavior of multi-dimensional arrays is like J |
The behavior of multi-dimensional arrays is like J |
||
< |
<syntaxhighlight lang="nial">max 1 2 3 4 |
||
=4</ |
=4</syntaxhighlight> |
||
=={{header|Nim}}== |
|||
<syntaxhighlight lang="nim">echo max([2,3,4,5,6,1])</syntaxhighlight> |
|||
{{out}} |
|||
<pre>6</pre> |
|||
=={{header|Nu}}== |
|||
By using <code>math max</code>: |
|||
<syntaxhighlight lang="nu">[1 5 3 11 7] | math max</syntaxhighlight> |
|||
{{out}} |
|||
<pre>11</pre> |
|||
=={{header|Oberon-2}}== |
|||
{{Works with|oo2c Version 2}} |
|||
<syntaxhighlight lang="oberon2"> |
|||
MODULE GreatestElement1; |
|||
IMPORT |
|||
ADT:ArrayList, |
|||
Object:Boxed, |
|||
Out; |
|||
VAR |
|||
a: ArrayList.ArrayList(Boxed.LongInt); |
|||
max: Boxed.LongInt; |
|||
PROCEDURE Max(al: ArrayList.ArrayList(Boxed.LongInt)): Boxed.LongInt; |
|||
VAR |
|||
i: LONGINT; |
|||
item, max: Boxed.LongInt; |
|||
BEGIN |
|||
max := NEW(Boxed.LongInt,MIN(LONGINT)); |
|||
i := 0; |
|||
WHILE (i < al.size) DO |
|||
item := al.Get(i); |
|||
IF item.value > max.value THEN max := item END; |
|||
INC(i) |
|||
END; |
|||
RETURN max |
|||
END Max; |
|||
BEGIN |
|||
a := NEW(ArrayList.ArrayList(Boxed.LongInt),5); |
|||
a.Append(NEW(Boxed.LongInt,10)); |
|||
a.Append(NEW(Boxed.LongInt,32)); |
|||
a.Append(NEW(Boxed.LongInt,4)); |
|||
a.Append(NEW(Boxed.LongInt,43)); |
|||
a.Append(NEW(Boxed.LongInt,9)); |
|||
max := Max(a); |
|||
Out.String("Max: ");Out.LongInt(max.value,4);Out.Ln |
|||
END GreatestElement1. |
|||
</syntaxhighlight> |
|||
Simple version |
|||
<syntaxhighlight lang="oberon2"> |
|||
MODULE GreatestElement2; |
|||
IMPORT |
|||
Out; |
|||
VAR |
|||
a: ARRAY 10 OF LONGINT; |
|||
PROCEDURE Max(a: ARRAY OF LONGINT): LONGINT; |
|||
VAR |
|||
i, max: LONGINT; |
|||
BEGIN |
|||
max := MIN(LONGINT); |
|||
FOR i := 0 TO LEN(a) - 1 DO |
|||
IF a[i] > max THEN max := a[i] END; |
|||
END; |
|||
RETURN max |
|||
END Max; |
|||
BEGIN |
|||
a[0] := 10; |
|||
a[1] := 32; |
|||
a[2] := 4; |
|||
a[3] := 43; |
|||
a[4] := 9; |
|||
Out.String("Max: ");Out.LongInt(Max(a),4);Out.Ln |
|||
END GreatestElement2. |
|||
</syntaxhighlight> |
|||
{{out}}(in both programs): |
|||
<pre> |
|||
Max: 43 |
|||
</pre> |
|||
=={{header|Objeck}}== |
|||
The language has a "Max" method for vectors. |
|||
<syntaxhighlight lang="objeck"> |
|||
values := IntVector->New([4, 1, 42, 5]); |
|||
values->Max()->PrintLine(); |
|||
</syntaxhighlight> |
|||
=={{header|Objective-C}}== |
=={{header|Objective-C}}== |
||
Line 827: | Line 3,566: | ||
< |
<syntaxhighlight lang="objc">#import <Foundation/Foundation.h> |
||
@interface NSArray (WithMaximum) |
@interface NSArray (WithMaximum) |
||
Line 837: | Line 3,576: | ||
{ |
{ |
||
if ( [self count] == 0 ) return nil; |
if ( [self count] == 0 ) return nil; |
||
id maybeMax = |
id maybeMax = self[0]; |
||
for ( id el in self ) { |
|||
NSEnumerator *en = [self objectEnumerator]; |
|||
id el; |
|||
while ( (el=[en nextObject]) != nil ) { |
|||
if ( [maybeMax respondsToSelector: @selector(compare:)] && |
if ( [maybeMax respondsToSelector: @selector(compare:)] && |
||
[el respondsToSelector: @selector(compare:)] && |
[el respondsToSelector: @selector(compare:)] && |
||
Line 851: | Line 3,588: | ||
return maybeMax; |
return maybeMax; |
||
} |
} |
||
@end</ |
@end</syntaxhighlight> |
||
This example mixes integers with a double value, just to show that |
This example mixes integers with a double value, just to show that |
||
everything is fine until they are NSNumber. |
everything is fine until they are NSNumber. |
||
< |
<syntaxhighlight lang="objc">int main() |
||
{ |
{ |
||
@autoreleasepool { |
|||
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
|||
NSArray *collection = [ |
NSArray *collection = @[@1, @2, @10, @5, @10.5]; |
||
[NSNumber numberWithInt: 1], |
|||
[NSNumber numberWithInt: 2], |
|||
[NSNumber numberWithInt: 10], |
|||
[NSNumber numberWithInt: 5], |
|||
[NSNumber numberWithDouble: 10.5], nil]; |
|||
NSLog(@"%@", [collection maximumValue]); |
NSLog(@"%@", [collection maximumValue]); |
||
} |
|||
[pool release]; |
|||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Objeck}}== |
|||
The language has a "Max" method for vectors. |
|||
<lang objeck> |
|||
values := IntVector->New([4, 1, 42, 5]); |
|||
values->Max()->PrintLine(); |
|||
</lang> |
|||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
< |
<syntaxhighlight lang="ocaml">let my_max = function |
||
[] -> invalid_arg "empty list" |
[] -> invalid_arg "empty list" |
||
| x::xs -> List.fold_left max x xs</ |
| x::xs -> List.fold_left max x xs</syntaxhighlight> |
||
# my_max [4;3;5;9;2;3] ;; |
# my_max [4;3;5;9;2;3] ;; |
||
Line 890: | Line 3,615: | ||
Octave's <code>max</code> accepts a vector (and can return also the index of the maximum value in the vector) |
Octave's <code>max</code> accepts a vector (and can return also the index of the maximum value in the vector) |
||
< |
<syntaxhighlight lang="octave">m = max( [1,2,3,20,10,9,8] ); % m = 20 |
||
[m, im] = max( [1,2,3,20,10,9,8] ); % im = 4</ |
[m, im] = max( [1,2,3,20,10,9,8] ); % im = 4</syntaxhighlight> |
||
=={{header|Oforth}}== |
|||
<syntaxhighlight lang="oforth">[1, 2.3, 5.6, 1, 3, 4 ] reduce(#max)</syntaxhighlight> |
|||
=={{header|Ol}}== |
|||
Basics: |
|||
<syntaxhighlight lang="scheme"> |
|||
; builtin function |
|||
(max 1 2 3 4 5) ; 5 |
|||
(define x '(1 2 3 4 5)) |
|||
; using to numbers list |
|||
(apply max x) ; 5 |
|||
; using list reducing |
|||
(fold max (car x) x) ; 5 |
|||
; manual lambda-comparator |
|||
(print (fold (lambda (a b) |
|||
(if (less? a b) b a)) |
|||
(car x) x)) ; 5 |
|||
</syntaxhighlight> |
|||
=={{header|ooRexx}}== |
|||
===version=== |
|||
<syntaxhighlight lang="oorexx"> |
|||
-- routine that will work with any ordered collection or sets and bags containing numbers. |
|||
::routine listMax |
|||
use arg list |
|||
items list~makearray -- since we're dealing with different collection types, reduce to an array |
|||
if items~isEmpty then return .nil -- return a failure indicator. could also raise an error, if desired |
|||
largest = items[1] |
|||
-- note, this method does call max one extra time. This could also use the |
|||
-- do i = 2 to items~size to avoid this |
|||
do item over items |
|||
largest = max(item, largest) |
|||
end |
|||
return largest |
|||
</syntaxhighlight> |
|||
===version 2 works with any strings=== |
|||
<syntaxhighlight lang="text">/* REXX *************************************************************** |
|||
* 30.07.2013 Walter Pachl as for REXX |
|||
**********************************************************************/ |
|||
s=.list~of('Walter','lives','in','Vienna') |
|||
say listMax(s) |
|||
-- routine that will work with any ordered collection or sets and bags. |
|||
::routine listMax |
|||
use arg list |
|||
items=list~makearray -- since we're dealing with different collection types, reduce to an array |
|||
if items~isEmpty then return .nil -- return a failure indicator. could also raise an error, if desired |
|||
largest = items[1] |
|||
-- note, this method uses one extra comparison. It could use |
|||
-- do i = 2 to items~size to avoid this |
|||
do item over items |
|||
If item>>largest Then |
|||
largest = item |
|||
end |
|||
return largest</syntaxhighlight> |
|||
=={{header|OxygenBasic}}== |
|||
<syntaxhighlight lang="text"> |
|||
'Works on any list with element types which support '>' comparisons |
|||
macro max any(R, A, N, i) |
|||
============================ |
|||
scope |
|||
indexbase 1 |
|||
int i |
|||
R=A(1) |
|||
for i=2 to N |
|||
if A(i)>R |
|||
R=A(i) |
|||
endif |
|||
next |
|||
end scope |
|||
end macro |
|||
'DEMO |
|||
===== |
|||
redim double d(100) |
|||
d={ 1.1, 1.2, 5.5, -0.1, -12.0 } |
|||
double m=max(d,5) |
|||
print "greatest element of d(): " m '5.5 |
|||
</syntaxhighlight> |
|||
=={{header|Oz}}== |
=={{header|Oz}}== |
||
< |
<syntaxhighlight lang="oz">declare |
||
fun {Maximum X|Xr} %% pattern-match on argument to make sure the list is not empty |
fun {Maximum X|Xr} %% pattern-match on argument to make sure the list is not empty |
||
{FoldL Xr Value.max X} %% fold the binary function Value.max over the list |
{FoldL Xr Value.max X} %% fold the binary function Value.max over the list |
||
end |
end |
||
in |
in |
||
{Show {Maximum [1 2 3 4 3]}}</ |
{Show {Maximum [1 2 3 4 3]}}</syntaxhighlight> |
||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
<lang>vecmax(v)</ |
<syntaxhighlight lang="parigp">vecmax(v)</syntaxhighlight> |
||
=={{header|Pascal}}== |
|||
See [[Greatest_element_of_a_list#Delphi | Delphi]] |
|||
{{works with | Free Pascal}} |
|||
or try this, for it shows the according position |
|||
<syntaxhighlight lang="pascal">program GElemLIst; |
|||
{$IFNDEF FPC} |
|||
{$Apptype Console} |
|||
{$else} |
|||
{$Mode Delphi} |
|||
{$ENDIF} |
|||
uses |
|||
sysutils; |
|||
const |
|||
MaxCnt = 1000000; |
|||
type |
|||
tMaxIntPos= record |
|||
mpMax, |
|||
mpPos : integer; |
|||
end; |
|||
tMaxfltPos= record |
|||
mpMax : double; |
|||
mpPos : integer; |
|||
end; |
|||
function FindMaxInt(const ia: array of integer):tMaxIntPos; |
|||
//delivers the highest Element and position of integer array |
|||
var |
|||
i : NativeInt; |
|||
tmp,max,ps: integer; |
|||
Begin |
|||
max := -MaxInt-1; |
|||
ps := -1; |
|||
//i = index of last Element |
|||
i := length(ia)-1; |
|||
IF i>=0 then Begin |
|||
max := ia[i]; |
|||
ps := i; |
|||
dec(i); |
|||
while i> 0 do begin |
|||
tmp := ia[i]; |
|||
IF max< tmp then begin |
|||
max := tmp; |
|||
ps := i; |
|||
end; |
|||
dec(i); |
|||
end; |
|||
end; |
|||
result.mpMax := Max; |
|||
result.mpPos := ps; |
|||
end; |
|||
function FindMaxflt(const ia: array of double):tMaxfltPos; |
|||
//delivers the highest Element and position of double array |
|||
var |
|||
i, |
|||
ps: NativeInt; |
|||
max : double; |
|||
tmp : ^double;//for 32-bit version runs faster |
|||
Begin |
|||
max := -MaxInt-1; |
|||
ps := -1; |
|||
//i = index of last Element |
|||
i := length(ia)-1; |
|||
IF i>=0 then Begin |
|||
max := ia[i]; |
|||
ps := i; |
|||
dec(i); |
|||
tmp := @ia[i]; |
|||
while i> 0 do begin |
|||
IF tmp^>max then begin |
|||
max := tmp^; |
|||
ps := i; |
|||
end; |
|||
dec(i); |
|||
dec(tmp); |
|||
end; |
|||
end; |
|||
result.mpMax := Max; |
|||
result.mpPos := ps; |
|||
end; |
|||
var |
|||
IntArr : array of integer; |
|||
fltArr : array of double; |
|||
ErgInt : tMaxINtPos; |
|||
ErgFlt : tMaxfltPos; |
|||
i: NativeInt; |
|||
begin |
|||
randomize; |
|||
setlength(fltArr,MaxCnt); //filled with 0 |
|||
setlength(IntArr,MaxCnt); //filled with 0.0 |
|||
For i := High(fltArr) downto 0 do |
|||
fltArr[i] := MaxCnt*random(); |
|||
For i := High(IntArr) downto 0 do |
|||
IntArr[i] := round(fltArr[i]); |
|||
ErgInt := FindMaxInt(IntArr); |
|||
writeln('FindMaxInt ',ErgInt.mpMax,' @ ',ErgInt.mpPos); |
|||
Ergflt := FindMaxflt(fltArr); |
|||
writeln('FindMaxFlt ',Ergflt.mpMax:0:4,' @ ',Ergflt.mpPos); |
|||
end.</syntaxhighlight> |
|||
Out, because of the searchdirection Position of FindMaxFlt is below FindMaxInt |
|||
<pre> |
|||
FindMaxInt 999999 @ 691620 |
|||
FindMaxFlt 999999.0265 @ 14824</pre> |
|||
=={{header|PascalABC.NET}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
## |
|||
var values := Lst(1,7,4,6,3,5,2,6); |
|||
values.Max.Print; |
|||
</syntaxhighlight> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">sub max { |
||
my $max = shift; |
|||
for (@_) { $max = $_ if $_ > $max } |
|||
return $max; |
|||
foreach ( @list ) { |
|||
}</syntaxhighlight> |
|||
$themax = $_ > $themax ? $_ : $themax; |
|||
} |
|||
return $themax; |
|||
}</lang> |
|||
It is already implemented in the module <tt>List::Util</tt>'s <tt>max()</tt> function: |
It is already implemented in the module <tt>List::Util</tt>'s <tt>max()</tt> function: |
||
< |
<syntaxhighlight lang="perl">use List::Util qw(max); |
||
max(@values);</ |
max(@values);</syntaxhighlight> |
||
=={{header| |
=={{header|Phix}}== |
||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
{{works with|Rakudo Star|2010-07}} |
|||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
|||
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">max</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1234</span><span style="color: #0000FF;">,</span><span style="color: #000000;">62</span><span style="color: #0000FF;">,</span><span style="color: #000000;">234</span><span style="color: #0000FF;">,</span><span style="color: #000000;">12</span><span style="color: #0000FF;">,</span><span style="color: #000000;">34</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: #7060A8;">max</span><span style="color: #0000FF;">({</span><span style="color: #008000;">"ant"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"antelope"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"dog"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"cat"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"cow"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"wolf"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"wolverine"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"aardvark"</span><span style="color: #0000FF;">})</span> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
<pre> |
|||
1234 |
|||
"wolverine" |
|||
</pre> |
|||
=={{header|Phixmonti}}== |
|||
<syntaxhighlight lang="phixmonti">"1" "1234" "62" "234" "12" "34" "6" stklen tolist |
|||
dup "Alphabetic order: " print max print nl |
|||
len for |
|||
var i |
|||
i get tonum i set |
|||
endfor |
|||
"Numeric order: " print max print</syntaxhighlight> |
|||
With syntactic sugar |
|||
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt |
|||
( "1" "1234" "62" "234" "12" "34" "6" ) |
|||
dup "Alphabetic order: " print max print nl |
|||
There's a built-in infix operator <code>max</code>; combining this with the reduction metaoperator (square brackets) yields the list operator we want: |
|||
def f |
|||
<lang perl6>say [max] 17, 13, 50, 56, 28, 63, 62, 66, 74, 54;</lang> |
|||
tonum |
|||
Note that this works over any type for which comparison is defined: |
|||
enddef |
|||
<lang perl6>say [max] 'my', 'dog', 'has', 'fleas';</lang> |
|||
getid f map |
|||
We could implement a list operator without using <code>max</code> by calling the generic reduce function with a lambda: |
|||
dup "Numeric order: " print max print |
|||
<lang perl6>sub max2 (*@a) { reduce -> $x, $y { $y after $x ?? $y !! $x }, @a } |
|||
</syntaxhighlight> |
|||
say max2 17, 13, 50, 56, 28, 63, 62, 66, 74, 54;</lang> |
|||
Since we've used the generic 'after' function, this can also be used on any type that defines cmp. |
|||
<!-- We could call the function "max", but then GeSHi would misleadingly highlight it as a keyword. perl6.php isn't going to distinguish between grammatical categories any time soon. --> |
|||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
The built-in PHP function <tt>max()</tt> already does this. |
The built-in PHP function <tt>max()</tt> already does this. |
||
<lang |
<syntaxhighlight lang="php">max($values)</syntaxhighlight> |
||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">: (max 2 4 1 3) # Return the maximal argument |
||
-> 4 |
-> 4 |
||
: (apply max (2 4 1 3)) # Apply to a list |
: (apply max (2 4 1 3)) # Apply to a list |
||
-> 4 |
-> 4 |
||
: (maxi abs (2 -4 -1 3)) # Maximum according to given function |
: (maxi abs (2 -4 -1 3)) # Maximum according to given function |
||
-> -4</ |
-> -4</syntaxhighlight> |
||
=={{header|PL/I}}== |
=={{header|PL/I}}== |
||
<syntaxhighlight lang="pli"> |
|||
<lang PL/I> |
|||
maximum = A(lbound(A,1)); |
maximum = A(lbound(A,1)); |
||
do i = lbound(A,1) to hbound(A,1); |
do i = lbound(A,1)+1 to hbound(A,1); |
||
if maximum < A(i) then maximum = A(i); |
if maximum < A(i) then maximum = A(i); |
||
end; |
end; |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|PostScript}}== |
=={{header|PostScript}}== |
||
Line 960: | Line 3,913: | ||
{{works with|Ghostscript}} |
{{works with|Ghostscript}} |
||
< |
<syntaxhighlight lang="postscript">/findmax { |
||
dup 0 get exch % put the first element underneath the array |
dup 0 get exch % put the first element underneath the array |
||
{max} forall % replace it by the respective larger value if necessary |
{max} forall % replace it by the respective larger value if necessary |
||
} def</ |
} def</syntaxhighlight> |
||
If not using Ghostscript this gets a bit longer: |
If not using Ghostscript this gets a bit longer: |
||
< |
<syntaxhighlight lang="postscript">/findmax { |
||
dup 0 get exch % put the first element underneath the array |
dup 0 get exch % put the first element underneath the array |
||
{ |
{ |
||
Line 976: | Line 3,929: | ||
pop % remove it |
pop % remove it |
||
} forall |
} forall |
||
} def</ |
} def</syntaxhighlight> |
||
{{libheader|initlib}} |
|||
<syntaxhighlight lang="postscript"> |
|||
[1 2 3 4 5 4 3 2 1] uncons exch {max} fold |
|||
</syntaxhighlight> |
|||
=={{header|PowerBASIC}}== |
=={{header|PowerBASIC}}== |
||
< |
<syntaxhighlight lang="powerbasic">FUNCTION PBMAIN() |
||
DIM x AS LONG, y AS LONG, z AS LONG |
DIM x AS LONG, y AS LONG, z AS LONG |
||
RANDOMIZE TIMER |
RANDOMIZE TIMER |
||
Line 990: | Line 3,948: | ||
? STR$(z) & " was the highest value" |
? STR$(z) & " was the highest value" |
||
END FUNCTION</ |
END FUNCTION</syntaxhighlight> |
||
{{Out}} |
|||
Sample output: |
|||
<pre> |
|||
8104 was the highest value |
8104 was the highest value |
||
</pre> |
|||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
The <code>Measure-Object</code> cmdlet in PowerShell already has this capability: |
The <code>Measure-Object</code> cmdlet in PowerShell already has this capability: |
||
< |
<syntaxhighlight lang="powershell">function Get-Maximum ($a) { |
||
return ($a | Measure-Object -Maximum).Maximum |
return ($a | Measure-Object -Maximum).Maximum |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Prolog}}== |
=={{header|Prolog}}== |
||
SWI-Prolog already knows max_list. |
SWI-Prolog already knows max_list. |
||
< |
<syntaxhighlight lang="prolog"> ?- max_list([1, 2, 10, 3, 0, 7, 9, 5], M). |
||
M = 10.</ |
M = 10.</syntaxhighlight> |
||
can be implemented like this: |
can be implemented like this: |
||
<syntaxhighlight lang="prolog">max_list(L, V) :- |
|||
<lang Prolog> |
|||
select(V, L, R), \+((member(X, R), X > V)). |
|||
max_list([H|T], Max) :- |
|||
</syntaxhighlight> |
|||
max_list(T, H, Max). |
|||
max_list([], Max, Max). |
|||
max_list([H|T], Max0, Max) :- |
|||
H > Max0, !, |
|||
max_list(T, H, Max). |
|||
max_list([_|T], Max0, Max) :- |
|||
max_list(T, Max0, Max). |
|||
</lang> |
|||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
< |
<syntaxhighlight lang="purebasic">Procedure.f Max (Array a.f(1)) |
||
Protected last, i, ret.f |
Protected last, i, ret.f |
||
Line 1,036: | Line 3,985: | ||
ProcedureReturn ret |
ProcedureReturn ret |
||
EndProcedure</ |
EndProcedure</syntaxhighlight> |
||
===PureBasic: another solution=== |
|||
<syntaxhighlight lang="purebasic">Procedure.f maxelement(List tl.f()) |
|||
ForEach tl() : mx.f=mx*Bool(mx>=tl())+tl()*Bool(mx<tl()) : Next |
|||
ProcedureReturn mx |
|||
EndProcedure |
|||
NewList testlist.f() : OpenConsole() |
|||
For i=0 To 99 : AddElement(testlist()) : testlist()=Sqr(Random(1000)) : Next |
|||
Print("Greatest element = "+StrF(maxelement(testlist()),8)) : Input()</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Greatest element = 31.59113884</pre> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
===Numeric values=== |
|||
The built-in Python function <tt>max()</tt> already does this. |
The built-in Python function <tt>max()</tt> already does this. |
||
<lang |
<syntaxhighlight lang="python">max(values)</syntaxhighlight> |
||
Of course this assumes we have a list or tuple (or other sequence like object). (One can even find the ''max()'' or ''min()'' character of a string since that's treated as a sequence of characters and there are "less than" and "greater than" operations (object methods) associate with those characters). |
Of course this assumes we have a list or tuple (or other sequence like object). (One can even find the ''max()'' or ''min()'' character of a string since that's treated as a sequence of characters and there are "less than" and "greater than" operations (object methods) associate with those characters). |
||
Line 1,047: | Line 4,008: | ||
max(), (and min()), can take iterables and a key argument which takes a function that can transform each item into a type that we can compare, for example, if the stream were returning string representations of integers, one to a line, you could do |
max(), (and min()), can take iterables and a key argument which takes a function that can transform each item into a type that we can compare, for example, if the stream were returning string representations of integers, one to a line, you could do |
||
< |
<syntaxhighlight lang="python">>>> floatstrings = ['1\n', ' 2.3\n', '4.5e-1\n', '0.01e4\n', '-1.2'] |
||
>>> max(floatstrings, key = float) |
>>> max(floatstrings, key = float) |
||
'0.01e4\n' |
'0.01e4\n' |
||
>>></ |
>>></syntaxhighlight> |
||
Normally we would want the converted form as the maximum and we could just as easily write: |
Normally we would want the converted form as the maximum and we could just as easily write: |
||
< |
<syntaxhighlight lang="python">>>> max(float(x) for x in floatstrings) |
||
100.0 |
100.0 |
||
>>></ |
>>></syntaxhighlight> |
||
Or you can write your own functional version, of the maximum function, using reduce and lambda |
|||
<syntaxhighlight lang="python">>>> mylist = [47, 11, 42, 102, 13] |
|||
>>> reduce(lambda a,b: a if (a > b) else b, mylist) |
|||
102</syntaxhighlight> |
|||
And if you are being lazy but still want to meet this task's requirements : |
|||
<syntaxhighlight lang="python"> |
|||
max(list(map(int,input("").split(",")))) |
|||
</syntaxhighlight> |
|||
===Non-numeric values=== |
|||
<syntaxhighlight lang="python">'''Non-numeric maxima''' |
|||
print( |
|||
f'max a-z: "{max(["epsilon", "zeta", "eta", "theta"])}"' |
|||
) |
|||
print( |
|||
f'max length: "{max(["epsilon", "zeta", "eta", "theta"], key=len)}"' |
|||
) |
|||
print( |
|||
'max property k by a-z: ' + str(max([ |
|||
{"k": "epsilon", "v": 2}, |
|||
{"k": "zeta", "v": 4}, |
|||
{"k": "eta", "v": 32}, |
|||
{"k": "theta", "v": 16}], key=lambda x: x["k"])) |
|||
) |
|||
print( |
|||
'max property k by length: ' + str(max([ |
|||
{"k": "epsilon", "v": 2}, |
|||
{"k": "zeta", "v": 4}, |
|||
{"k": "eta", "v": 32}, |
|||
{"k": "theta", "v": 16}], key=lambda x: len(x["k"]))) |
|||
) |
|||
print( |
|||
'max property v: ' + str(max([ |
|||
{"k": "epsilon", "v": 2}, |
|||
{"k": "zeta", "v": 4}, |
|||
{"k": "eta", "v": 32}, |
|||
{"k": "theta", "v": 16}], key=lambda x: x["v"])) |
|||
)</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>max a-z: "zeta" |
|||
max length: "epsilon" |
|||
max property k by a-z: {'k': 'zeta', 'v': 4} |
|||
max property k by length: {'k': 'epsilon', 'v': 2} |
|||
max property v: {'k': 'eta', 'v': 32}</pre> |
|||
=={{header|Q}}== |
|||
<syntaxhighlight lang="q">q)l:2 9 3 8 4 7 |
|||
q)max l |
|||
9</syntaxhighlight> |
|||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery">[ behead swap witheach max ] is [max] ( [ --> n )</syntaxhighlight> |
|||
=={{header|R}}== |
=={{header|R}}== |
||
< |
<syntaxhighlight lang="r">v <- c(1, 2, 100, 50, 0) |
||
print(max(v)) # 100</ |
print(max(v)) # 100</syntaxhighlight> |
||
=={{header|Racket}}== |
|||
The "max" function it built in and takes an arbitrary amount of arguments. |
|||
<syntaxhighlight lang="racket">(max 12 9 8 17 1)</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>17</pre> |
|||
To use with a list, there is <tt>apply</tt>: |
|||
<syntaxhighlight lang="racket">(apply max '(12 9 8 17 1))</syntaxhighlight> |
|||
However, if you want to write the function yourself: |
|||
<syntaxhighlight lang="racket"> |
|||
(define (my-max l) |
|||
(define (max-h l greatest) |
|||
(cond [(empty? l) greatest] |
|||
[(> (first l) greatest) (max-h (rest l) (first l))] |
|||
[else (max-h (rest l) greatest)])) |
|||
(if (empty? l) empty (max-h l (first l)))) |
|||
</syntaxhighlight> |
|||
or with a "for" loop: |
|||
<syntaxhighlight lang="racket"> |
|||
(define (my-max l) |
|||
(for/fold ([max #f]) ([x l]) |
|||
(if (and max (> max x)) max x))) |
|||
</syntaxhighlight> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
The built-in function works with any type that defines ordering. |
|||
<syntaxhighlight lang="raku" line>say max 10, 4, 5, -2, 11; |
|||
say max <zero one two three four five six seven eight nine>; |
|||
# Even when the values and number of values aren't known until runtime |
|||
my @list = flat(0..9,'A'..'H').roll((^60).pick).rotor(4,:partial)».join.words; |
|||
say @list, ': ', max @list; |
|||
</syntaxhighlight> |
|||
{{out|Sample output}} |
|||
<pre>11 |
|||
zero |
|||
[6808 013C 6D5B 4219 29G9 DC13 CA4F 55F3 AA06 0AGF DAB0 2]: DC13</pre> |
|||
=={{header|RapidQ}}== |
|||
<syntaxhighlight lang="vb">functioni FindMax(...) as double |
|||
dim x as integer |
|||
for x = 1 to ParamValCount |
|||
IF ParamVal(x) > Result THEN Result = ParamVal(x) |
|||
next |
|||
End functioni |
|||
Print FindMax(50, 20, 65, 20, 105) |
|||
</syntaxhighlight> |
|||
=={{header|Rascal}}== |
|||
Rascal has a built-in function that gives the greatest element of a list |
|||
<syntaxhighlight lang="rascal"> |
|||
rascal>import List; |
|||
ok |
|||
rascal>max([1,2,3,4]); |
|||
int: 4 |
|||
</syntaxhighlight> |
|||
=={{header|Raven}}== |
|||
<syntaxhighlight lang="raven">[ 1 2 3 4 ] max "%d\n" print</syntaxhighlight> |
|||
{{out}} <pre>4</pre> |
|||
'''Randomly generated list size and elements''' |
|||
<syntaxhighlight lang="raven">100 choose as $cnt |
|||
[ ] as $lst |
|||
0 $cnt 1 range each drop 100 choose $lst push |
|||
$lst print |
|||
$lst max "max value: %d\n" print</syntaxhighlight> |
|||
=={{header|REBOL}}== |
=={{header|REBOL}}== |
||
< |
<syntaxhighlight lang="rebol">REBOL [ |
||
Title: "Maximum Value" |
Title: "Maximum Value" |
||
Date: 2009-12-15 |
|||
Author: oofoe |
|||
URL: http://rosettacode.org/wiki/Maximum_Value |
URL: http://rosettacode.org/wiki/Maximum_Value |
||
] |
] |
||
Line 1,076: | Line 4,165: | ||
print ["Max of" mold d: [5 4 3 2 1] "is" max d] |
print ["Max of" mold d: [5 4 3 2 1] "is" max d] |
||
print ["Max of" mold d: [-5 -4 -3 -2 -1] "is" max d]</ |
print ["Max of" mold d: [-5 -4 -3 -2 -1] "is" max d]</syntaxhighlight> |
||
Output: |
|||
{{Out}} |
|||
<pre>Max of [5 4 3 2 1] is 5 |
<pre>Max of [5 4 3 2 1] is 5 |
||
Max of [-5 -4 -3 -2 -1] is -1</pre> |
Max of [-5 -4 -3 -2 -1] is -1</pre> |
||
=={{header|REXX}}== |
|||
=={{header|Red}}== |
|||
If the list is a string that contains a list of numbers: |
|||
<syntaxhighlight lang="red">Red [] |
|||
list: [1 2 3 5 4] |
|||
print last sort list |
|||
</syntaxhighlight> |
|||
=={{header|REXX}}== |
|||
<lang rexx> |
|||
The numbers in the list may be any valid REXX number (integer, negative, floating point, etc.) |
|||
/*list of first twenty reversed primes.*/ |
|||
===using a list=== |
|||
<syntaxhighlight lang="rexx">/*REXX program finds the greatest element in a list (of the first 25 reversed primes).*/ |
|||
$ = reverse(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97) |
|||
say 'list of numbers = ' $ /*show the original list of numbers. */ |
|||
big=word($, 1) /*choose an initial biggest number. */ |
|||
# = words($); do j=2 to # /*traipse through the list, find max. */ |
|||
big=max(big, word($, j) ) /*use the MAX BIF to find the biggie.*/ |
|||
end /*j*/ |
|||
say /*stick a fork in it, we're all done. */ |
|||
say 'the biggest value in a list of ' # " numbers is: " big</syntaxhighlight> |
|||
{{out|output|text= when using the default (internal) input:}} |
|||
<pre> |
|||
list of numbers = 79 98 38 97 37 17 76 16 95 35 74 34 14 73 13 92 32 91 71 31 11 7 5 3 2 |
|||
the biggest value in a list of 25 numbers is: 98 |
|||
y='2 3 5 7 11 31 71 91 32 92 13 73 14 34 74 35 95 16 76 17' |
|||
</pre> |
|||
big=word(y,1) |
|||
===using an array=== |
|||
do j=2 to words(y) |
|||
<syntaxhighlight lang="rexx">/*REXX program finds the greatest element in a list (of the first 25 reversed primes).*/ |
|||
big=max(big,word(y,j)) |
|||
@.=; @.1 = 2; @.2 = 3; @.3 = 5; @.4 = 7; @.5 =11; @.6 =31; @.7 =71 |
|||
end |
|||
@.8 =91; @.9 =32; @.10=92; @.11=13; @.12=73; @.13=14; @.14=34 |
|||
@.15=74; @.16=35; @.17=95; @.18=16; @.19=76; @.20=17; @.21=37 |
|||
say 'biggest value in list of' words(y) "numbers is" big |
|||
@.22=97; @.23=38; @.24=98; @.25=79 |
|||
</lang> |
|||
big=@.1 /*choose an initial biggest number. */ |
|||
Output: |
|||
do #=2 while @.#\=='' /*traipse through whole array of nums. */ |
|||
<pre style="height:30ex;overflow:scroll"> |
|||
big = max(big, @.#) /*use a BIF to find the biggest number.*/ |
|||
biggest value in list of 20 numbers is 95 |
|||
end /*#*/ |
|||
/*stick a fork in it, we're all done. */ |
|||
say 'the biggest value in an array of ' #-1 " elements is: " big</syntaxhighlight> |
|||
{{out|output|text= when using the default (internal) input:}} |
|||
<pre> |
|||
the biggest value in an array of 25 elements is: 98 |
|||
</pre> |
</pre> |
||
===using a list from the terminal=== |
|||
If the list is an array of numbers: |
|||
<syntaxhighlight lang="rexx">/*REXX program finds the greatest element in a list of numbers entered at the terminal*/ |
|||
say '────────────────── Please enter a list of numbers (separated by blanks or commas):' |
|||
parse pull $; #=words($) /*get a list of numbers from terminal. */ |
|||
$=translate($, , ',') /*change all commas (,) to blanks. */ |
|||
big=word($,1); do j=2 to # /*traipse through the list of numbers. */ |
|||
big=max(big, word($,j)) /*use a BIF for finding the max number.*/ |
|||
end /*j*/ |
|||
say /*stick a fork in it, we're all done. */ |
|||
say '────────────────── The biggest value in the list of ' # " elements is: " big</syntaxhighlight> |
|||
Programming note: the '''max''' BIF normalizes the number returned (eliding the leading superfluous zeroes). |
|||
If this is undesirable, then the '''do''' loop (shown above) can be replaced with: |
|||
<lang rexx> |
|||
<syntaxhighlight lang="rexx">···; do j=2 to #; _=word($,j) |
|||
y.1 = 2; y.2 = 3; y.3 = 5; y.4 = 7; y.5 =11 |
|||
if _>big then big=_ |
|||
y.6 =31; y.7 =71; y.8 =91; y.9 =32; y.10=92 |
|||
end /*j*/</syntaxhighlight> |
|||
y.11=13; y.12=73; y.13=14; y.14=34; y.15=74 |
|||
{{out|output|text= when using the input from the terminal via a user prompt:}} |
|||
y.16=35; y.17=95; y.18=16; y.19=76; y.20=17 |
|||
<pre> |
|||
────────────────── Please enter a list of numbers (separated by blanks or commas): |
|||
-12 -3 0 1.1 1e2 99.2 00245 ◄■■■■■■■■■■ user input |
|||
────────────────── The biggest value in the list of 7 elements is: 245 |
|||
big=y.1 |
|||
</pre> |
|||
items=20 |
|||
===list of any strings=== |
|||
do j=2 to items |
|||
<syntaxhighlight lang="rexx">/* REXX *************************************************************** |
|||
big=max(big,y.j) |
|||
* If the list contains any character strings, the following will work |
|||
end |
|||
* Note the use of >> (instead of >) to avoid numeric comparison |
|||
* Note that max() overrides the builtin function MAX |
|||
* 30.07.2013 Walter Pachl |
|||
**********************************************************************/ |
|||
list='Walter Pachl living in Vienna' |
|||
Say max(list) |
|||
list='8 33 -12' |
|||
Say max(list) |
|||
Exit |
|||
max: Procedure |
|||
Parse Arg l |
|||
max=word(l,1) |
|||
Do i=2 To words(l) |
|||
If word(l,i)>>max Then |
|||
max=word(l,i) |
|||
End |
|||
Return max</syntaxhighlight> |
|||
{{out|output|text= when using an '''ASCII''' system:}} |
|||
<pre> |
|||
living |
|||
8 |
|||
</pre> |
|||
{{out|output|text= when using an '''EBCDIC''' system:}} |
|||
<pre> |
|||
Walter |
|||
8 |
|||
</pre> |
|||
'''output''' when using a ''list'' which is: <tt> 12 111111 1 </tt> |
|||
(lexigraphically 12 is greater than 111111) |
|||
<pre> |
|||
12 |
|||
</pre> |
|||
=={{header|Ring}}== |
|||
say 'biggest value in an arrow of' items "elements is" big |
|||
<syntaxhighlight lang="ring">aList = [1,2,4,5,10,6,7,8,9] |
|||
</lang> |
|||
see max(aList)</syntaxhighlight> |
|||
Output: |
|||
{{out}} |
|||
<pre style="height:30ex;overflow:scroll"> |
|||
<pre> |
|||
biggest value in an arrow of 20 elements is 95 |
|||
10 |
|||
</pre> |
</pre> |
||
=={{header|RPL}}== |
|||
{{works with|HP|48}} |
|||
{ 2 718 28 18 28 46 } ≪ MAX ≫ STREAM |
|||
{{out}} |
|||
<pre> |
|||
1: 718 |
|||
</pre> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
<tt>max</tt> is a method of all Enumerables |
<tt>max</tt> is a method of all Enumerables |
||
<lang |
<syntaxhighlight lang="ruby">values.max</syntaxhighlight> |
||
=={{header|Run BASIC}}== |
|||
<syntaxhighlight lang="runbasic">list$= "1 12 -55 46 41 3.66 19" |
|||
while word$(list$,i+1," ") <> "" |
|||
mx = max(mx,val(word$(list$,i+1," "))) |
|||
i = i + 1 |
|||
wend |
|||
print mx</syntaxhighlight> |
|||
=={{header|Rust}}== |
|||
This is built in functionality for everything that can be iterated over. It returns an Option<T>, meaning Some(e) if there are elements in the iterator and None if it is empty. |
|||
<syntaxhighlight lang="rust">fn main() { |
|||
let nums = [1,2,39,34,20]; |
|||
println!("{:?}", nums.iter().max()); |
|||
println!("{}", nums.iter().max().unwrap()); |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Some(39) |
|||
39</pre> |
|||
=={{header|S-lang}}== |
|||
Starting w/an array, this is trivial: |
|||
<syntaxhighlight lang="s-lang">variable a = [5, -2, 0, 4, 666, 7]; |
|||
print(max(a));</syntaxhighlight> |
|||
output: |
|||
666 |
|||
If a is a list instead of an array, then: |
|||
<syntaxhighlight lang="s-lang">a = {5, -2, 0, 4, 666, 7}; |
|||
print(max(list_to_array(a)));</syntaxhighlight> |
|||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
{{libheader|Scala}} |
|||
max is a method in Int (e.g. 3 max 5 == 5) |
|||
<lang |
<syntaxhighlight lang="scala">def noSweat(list: Int*) = list.max |
||
// Test |
|||
With Scala2.8 a build-in function could also be used. |
|||
assert(noSweat(1, 3, 12, 7) == 12)</syntaxhighlight> |
|||
<lang scala>List(1,2,3,4).max</lang> |
|||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
The built-in Scheme function <tt>max</tt> takes the max of all its arguments. |
The built-in Scheme function <tt>max</tt> takes the max of all its arguments. |
||
< |
<syntaxhighlight lang="scheme">(max 1 2 3 4) |
||
(apply max values) ; find max of a list</ |
(apply max values) ; find max of a list</syntaxhighlight> |
||
=={{header|Seed7}}== |
|||
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
|||
const func integer: max (in array integer: values) is func |
|||
result |
|||
var integer: max is 0; |
|||
local |
|||
var integer: index is 0; |
|||
begin |
|||
max := values[1]; |
|||
for index range 2 to length(values) do |
|||
if values[index] > max then |
|||
max := values[index]; |
|||
end if; |
|||
end for; |
|||
end func; |
|||
const proc: main is func |
|||
begin |
|||
writeln(max([] (1, 2, 6, 4, 3))); |
|||
end func;</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
6 |
|||
</pre> |
|||
=={{header|Self}}== |
|||
Using ''reduceWith:'' it is very simple to find the maximum value among a collection. |
|||
<syntaxhighlight lang="self">(1 & 2 & 3 & 4 & 20 & 10 & 9 & 8) asVector reduceWith: [:a :b | a max: b] "returns 20"</syntaxhighlight> |
|||
Or, since it's "built-in", you can simply do: |
|||
<syntaxhighlight lang="self">(1 & 2 & 3 & 4 & 20 & 10 & 9 & 8) asVector max. "returns 20"</syntaxhighlight> |
|||
=={{header|SenseTalk}}== |
|||
<syntaxhighlight lang="sensetalk">put the max of (1, 5, 666, -1000, 3) |
|||
put the highest value of [88,-2,6,55,103,0]</syntaxhighlight> |
|||
Output: |
|||
<syntaxhighlight lang="sensetalk">666 |
|||
103</syntaxhighlight> |
|||
=={{header|Sidef}}== |
|||
''max'' method returns the greatest element in a list. It works only if the array's elements have the same type (e.g.: strings, numbers). |
|||
<syntaxhighlight lang="ruby">values.max;</syntaxhighlight> |
|||
=={{header|Slate}}== |
=={{header|Slate}}== |
||
< |
<syntaxhighlight lang="slate">#(1 2 3 4 20 10 9 8) reduce: [| :a :b | a max: b]</syntaxhighlight> |
||
=={{header|Smalltalk}}== |
=={{header|Smalltalk}}== |
||
Using ''fold'' it is very simple to find the maximum value among a collection. |
Using ''fold'' it is very simple to find the maximum value among a collection. |
||
<syntaxhighlight lang="smalltalk">#(1 2 3 4 20 10 9 8) fold: [:a :b | a max: b] "returns 20"</syntaxhighlight> |
|||
<lang smalltalk>Smalltalk at: #maximum put: nil. |
|||
maximum := [ :c | c fold: [:a :b | a max: b] ]. |
|||
Or, since it's "built-in", you can simply do: |
|||
maximum value: #(1 2 3 4 20 10 9 8). "returns 20"</lang> |
|||
{{works with|Pharo|1.4}} |
|||
{{works with|Smalltalk/X}} |
|||
<syntaxhighlight lang="smalltalk">#(1 2 3 4 20 10 9 8) max. "returns 20"</syntaxhighlight> |
|||
using #inject:into: |
|||
<syntaxhighlight lang="smalltalk"> |
|||
| list | |
|||
list := #(1 2 3 4 20 10 9 8). |
|||
list inject: (list at: 1) into: [ :number :each | |
|||
number max: each ] |
|||
</syntaxhighlight> |
|||
=={{header|SNOBOL4}}== |
=={{header|SNOBOL4}}== |
||
< |
<syntaxhighlight lang="snobol4">while a = trim(input) :f(stop) |
||
max = gt(a,max) a :(while) |
max = gt(a,max) a :(while) |
||
stop output = max |
stop output = max |
||
end</ |
end</syntaxhighlight> |
||
=={{header|Standard ML}}== |
=={{header|Standard ML}}== |
||
Comparisons are specific for each type. Here is a max function for a list of ints: |
Comparisons are specific for each type. Here is a max function for a list of ints: |
||
< |
<syntaxhighlight lang="sml">fun max_of_ints [] = raise Empty |
||
| max_of_ints (x::xs) = foldl Int.max x xs</ |
| max_of_ints (x::xs) = foldl Int.max x xs</syntaxhighlight> |
||
- max_of_ints [4,3,5,9,2,3]; |
- max_of_ints [4,3,5,9,2,3]; |
||
val it = 9 : int |
val it = 9 : int |
||
=={{header|Stata}}== |
|||
Use the '''[https://www.stata.com/help.cgi?summarize summarize]''' command to compute the maximum value of a variable: |
|||
<syntaxhighlight lang="stata">qui sum x |
|||
di r(max)</syntaxhighlight> |
|||
Mata has also several [https://www.stata.com/help.cgi?mf_minmax functions] to compute minimum or maximum of a vactor or matrix: |
|||
<syntaxhighlight lang="stata">a = 1,5,3,4,2,7,9,8 |
|||
max(a)</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
{{works with|Swift|2.x}} |
|||
<syntaxhighlight lang="swift">if let x = [4,3,5,9,2,3].maxElement() { |
|||
print(x) // prints 9 |
|||
}</syntaxhighlight> |
|||
{{works with|Swift|1.x}} |
|||
<syntaxhighlight lang="swift">let x = maxElement([4,3,5,9,2,3]) |
|||
println(x) // prints 9</syntaxhighlight> |
|||
=={{header|Symstatic}}== |
|||
<syntaxhighlight lang="symstatic">let max([first|tail]) := max(first, tail) |
|||
let max(curMax, []) := curMax |
|||
let max(curMax, [first|tail]) := max( |
|||
if curMax > first then curMax else first, |
|||
tail, |
|||
) |
|||
assert(max([3, 5, 7, 2, 4, 8, -1]) = 8) |
|||
</syntaxhighlight> |
|||
=={{header|Tailspin}}== |
|||
Simplest is to use the built-in collector |
|||
<syntaxhighlight lang="tailspin"> |
|||
[1, 5, 20, 3, 9, 7] ... -> ..=Max&{by: :(), select: :()} -> !OUT::write |
|||
// outputs 20 |
|||
// This is how the Max-collector is implemented in the standard library: |
|||
processor Max&{by:, select:} |
|||
@:[]; |
|||
sink accumulate |
|||
<?($@Max <=[]>) |
|||
| ?($(by) <$@Max(1)..>)> @Max: [$(by), $(select)]; |
|||
end accumulate |
|||
source result |
|||
$@Max(2) ! |
|||
end result |
|||
end Max |
|||
</syntaxhighlight> |
|||
But here is how to find the max more manually/programmatically, it is pretty easy as well |
|||
<syntaxhighlight lang="tailspin"> |
|||
templates max |
|||
@: $(1); |
|||
$(2..last)... -> # |
|||
$@! |
|||
when <$@..> do @: $; |
|||
end max |
|||
[1, 5, 20, 3, 9, 7] -> max -> !OUT::write |
|||
// outputs 20 |
|||
</syntaxhighlight> |
|||
Can also be written as an inline templates |
|||
<syntaxhighlight lang="tailspin"> |
|||
[1, 5, 20, 3, 9, 7] -> \(@: $(1); $(2..last)... -> # $@ ! when <$@..> do @: $;\) -> !OUT::write |
|||
// outputs 20 |
|||
</syntaxhighlight> |
|||
Or we can do just the matching in an inline templates referencing the outer state |
|||
<syntaxhighlight lang="tailspin"> |
|||
templates max |
|||
@: $(1); |
|||
$(2..last)... -> \(<$@max..> @max: $;\) -> !VOID |
|||
$@! |
|||
end max |
|||
[1, 5, 20, 3, 9, 7] -> max -> !OUT::write |
|||
// outputs 20 |
|||
</syntaxhighlight> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
{{works with|Tcl|8.5}} |
{{works with|Tcl|8.5}} |
||
Use the <code>{*}</code> expansion operator to substitute the list value with its constituent elements |
Use the <code>{*}</code> expansion operator to substitute the list value with its constituent elements |
||
< |
<syntaxhighlight lang="tcl">package require Tcl 8.5 |
||
set values {4 3 2 7 8 9} |
set values {4 3 2 7 8 9} |
||
::tcl::mathfunc::max {*}$values ;# ==> 9</ |
::tcl::mathfunc::max {*}$values ;# ==> 9</syntaxhighlight> |
||
=={{header|TI-83 BASIC}}== |
|||
The builtin <code>max</code> function can be applied to lists. <code style="font-family:'TI Uni'">max({1, 3, 2</code>. |
|||
=={{header|TI-89 BASIC}}== |
=={{header|TI-89 BASIC}}== |
||
The builtin <code>max</code> function can be applied to lists. <code style="font-family:'TI Uni'">max({1, 3, 2})</code> = 3. |
The builtin <code>max</code> function can be applied to lists. <code style="font-family:'TI Uni'">max({1, 3, 2})</code> = 3. |
||
=={{header|Transd}}== |
|||
<syntaxhighlight lang="scheme">#lang transd |
|||
MainModule: { |
|||
_start: (λ |
|||
(textout (max 9 6 2 11 3 4) " ") |
|||
(with v [1, 45, 7, 274, -2, 34] |
|||
(textout (max-element v) " ") |
|||
(textout (max-element-idx v)) |
|||
)) |
|||
}</syntaxhighlight>{{out}} |
|||
<pre> |
|||
11 274 3 |
|||
</pre> |
|||
=={{header|Trith}}== |
=={{header|Trith}}== |
||
< |
<syntaxhighlight lang="trith">[1 -2 3.1415 0 42 7] [max] foldl1</syntaxhighlight> |
||
=={{header| |
=={{header|TUSCRIPT}}== |
||
<syntaxhighlight lang="tuscript"> |
|||
$$ MODE TUSCRIPT |
|||
LOOP n,list="2'4'0'3'1'2'-12" |
|||
IF (n==1) greatest=VALUE(list) |
|||
IF (list>greatest) greatest=VALUE(list) |
|||
ENDLOOP |
|||
PRINT greatest |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
4 |
|||
</pre> |
|||
=={{header|uBasic/4tH}}== |
|||
Since uBasic/4tH has a stack, it's only logical to use it. |
|||
<syntaxhighlight lang="text">Push 13, 0, -6, 2, 37, -10, 12 ' Push values on the stack |
|||
Print "Maximum value = " ; FUNC(_FNmax(7)) |
|||
End ' We pushed seven values |
|||
_FNmax Param(1) |
|||
Local(3) |
|||
d@ = -(2^31) ' Set maximum to a tiny value |
|||
For b@ = 1 To a@ ' Get all values from the stack |
|||
c@ = Pop() |
|||
If c@ > d@ THEN d@ = c@ ' Change maximum if required |
|||
Next |
|||
Return (d@) ' Return the maximum</syntaxhighlight> |
|||
=={{header|UNIX Shell}}== |
|||
{{works with|bash|3}} |
{{works with|bash|3}} |
||
{{works with|pdksh}} |
|||
<lang |
<syntaxhighlight lang="bash">max() { |
||
local m= |
local m=$1 |
||
shift |
|||
while [ -n "$1" ] |
|||
while [ $# -gt 0 ] |
|||
do |
do |
||
[ - |
[ "$m" -lt "$1" ] && m=$1 |
||
[ $m -lt $1 ] && m=$1 |
|||
shift |
shift |
||
done |
done |
||
echo $m |
echo "$m" |
||
} |
} |
||
max 10 9 11 57 1 12</ |
max 10 9 11 57 1 12</syntaxhighlight> |
||
{{works with|Bourne Shell}} |
|||
<syntaxhighlight lang="bash">max() { |
|||
m=$1 # Bourne Shell has no local command. |
|||
shift |
|||
while [ $# -gt 0 ] |
|||
do |
|||
[ "$m" -lt "$1" ] && m=$1 |
|||
shift |
|||
done |
|||
echo "$m" |
|||
}</syntaxhighlight> |
|||
=={{header|Ursa}}== |
|||
The <code>max</code> function: |
|||
<syntaxhighlight lang="ursa">def max (int<> list) |
|||
decl int max i |
|||
set max list<0> |
|||
for (set i 1) (< i (- (size list) 1)) (inc i) |
|||
if (> list<i> max) |
|||
set max list<i> |
|||
end if |
|||
end for |
|||
return max |
|||
end max</syntaxhighlight> |
|||
In use: (assuming the function is in the file <code>max.u</code>) |
|||
<pre>cygnus/x ursa v0.75 (default, release 0) |
|||
[Oracle Corporation JVM 1.8.0_51 on Mac OS X 10.10.5 x86_64] |
|||
> import "max.u" |
|||
> decl int<> list |
|||
> append 5 1 7 3 9 2 list |
|||
> out (max list) endl console |
|||
9 |
|||
> _</pre> |
|||
=={{header|Ursala}}== |
=={{header|Ursala}}== |
||
Line 1,203: | Line 4,623: | ||
case it is used with <code>fleq</code>, the partial order relation on floating point |
case it is used with <code>fleq</code>, the partial order relation on floating point |
||
numbers. |
numbers. |
||
< |
<syntaxhighlight lang="ursala">#import flo |
||
#cast %e |
#cast %e |
||
example = fleq$^ <-1.,-2.,0.,5.,4.,6.,1.,-5.></ |
example = fleq$^ <-1.,-2.,0.,5.,4.,6.,1.,-5.></syntaxhighlight> |
||
{{Out}} |
|||
output: |
|||
<pre>6.000000e+00</pre> |
<pre>6.000000e+00</pre> |
||
=={{header|V}}== |
=={{header|V}}== |
||
Assuming it is a list of positive numbers |
Assuming it is a list of positive numbers |
||
< |
<syntaxhighlight lang="v">[4 3 2 7 8 9] 0 [max] fold |
||
=9</ |
=9</syntaxhighlight> |
||
If it is not |
If it is not |
||
< |
<syntaxhighlight lang="v">[4 3 2 7 8 9] dup first [max] fold</syntaxhighlight> |
||
=9 |
=9 |
||
=={{header|VBA}}== |
|||
<syntaxhighlight lang="vb">Option Explicit |
|||
Sub Main() |
|||
Dim a |
|||
a = Array(1, 15, 19, 25, 13, 0, -125, 9) |
|||
Debug.Print Max_VBA(a) |
|||
End Sub |
|||
Function Max_VBA(Arr As Variant) As Long |
|||
Dim i As Long, temp As Long |
|||
temp = Arr(LBound(Arr)) |
|||
For i = LBound(Arr) + 1 To UBound(Arr) |
|||
If Arr(i) > temp Then temp = Arr(i) |
|||
Next i |
|||
Max_VBA = temp |
|||
End Function</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>25</pre> |
|||
=={{header|VBScript}}== |
|||
<syntaxhighlight lang="vb"> |
|||
Function greatest_element(arr) |
|||
tmp_num = 0 |
|||
For i = 0 To UBound(arr) |
|||
If i = 0 Then |
|||
tmp_num = arr(i) |
|||
ElseIf arr(i) > tmp_num Then |
|||
tmp_num = arr(i) |
|||
End If |
|||
Next |
|||
greatest_element = tmp_num |
|||
End Function |
|||
WScript.Echo greatest_element(Array(1,2,3,44,5,6,8)) |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>44</pre> |
|||
=={{header|Vim Script}}== |
|||
for numbers (not floats): |
|||
<syntaxhighlight lang="vim">max([1, 3, 2])</syntaxhighlight> |
|||
result: 3 |
|||
for strings (with configurable ignore-case): |
|||
<syntaxhighlight lang="vim">function! Max(list, ...) |
|||
" {list} list of strings |
|||
" {a:1} 'i': ignore case, 'I': match case, otherwise use 'ignorecase' option |
|||
if empty(a:list) |
|||
return 0 |
|||
endif |
|||
let gt_op = a:0>=1 ? get({'i': '>?', 'I': '>#'}, a:1, '>') : '>' |
|||
let cmp_expr = printf('a:list[idx] %s maxval', gt_op) |
|||
let maxval = a:list[0] |
|||
let len = len(a:list) |
|||
let idx = 1 |
|||
while idx < len |
|||
if eval(cmp_expr) |
|||
let maxval = a:list[idx] |
|||
endif |
|||
let idx += 1 |
|||
endwhile |
|||
return maxval |
|||
endfunction</syntaxhighlight> |
|||
=={{header|Visual Basic}}== |
|||
<syntaxhighlight lang="vb">Public Function ListMax(anArray()) |
|||
'return the greatest element in array anArray |
|||
'use LBound and UBound to find its length |
|||
n0 = LBound(anArray) |
|||
n = UBound(anArray) |
|||
theMax = anArray(n0) |
|||
For i = (n0 + 1) To n |
|||
If anArray(i) > theMax Then theMax = anArray(i) |
|||
Next |
|||
ListMax = theMax |
|||
End Function |
|||
Public Sub ListMaxTest() |
|||
Dim b() |
|||
'test function ListMax |
|||
'fill array b with some numbers: |
|||
b = Array(5992424433449#, 4534344439984#, 551344678, 99800000#) |
|||
'print the greatest element |
|||
Debug.Print "Greatest element is"; ListMax(b()) |
|||
End Sub</syntaxhighlight> |
|||
Result: |
|||
<pre>ListMaxTest |
|||
Greatest element is 5992424433449</pre> |
|||
=={{header|V (Vlang)}}== |
|||
<syntaxhighlight lang="v (vlang)">fn max<T>(list []T) T { |
|||
mut max := list[0] |
|||
for i in 1..list.len { |
|||
if list[i] > max { |
|||
max = list[i] |
|||
} |
|||
} |
|||
return max |
|||
} |
|||
fn main() { |
|||
println('int max: ${max<int>([5,6,4,2,8,3,0,2])}') |
|||
println('float max: ${max<f64>([1e4, 1e5, 1e2, 1e9])}') |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>int max: 8 |
|||
float max: 1e9</pre> |
|||
=={{header|Wart}}== |
|||
Wart defines <code>max</code> in terms of the more general <code>best</code>. |
|||
<syntaxhighlight lang="python">def (best f seq) |
|||
if seq |
|||
ret winner car.seq |
|||
each elem cdr.seq |
|||
if (f elem winner) |
|||
winner <- elem |
|||
def (max ... args) |
|||
(best (>) args)</syntaxhighlight> |
|||
<code>(>)</code> is <code>></code> while suppressing infix expansion. |
|||
=={{header|WDTE}}== |
|||
<syntaxhighlight lang="wdte">let s => import 'stream'; |
|||
let a => import 'arrays'; |
|||
let max list => |
|||
a.stream list |
|||
-> s.extent 1 > |
|||
-> at 0 |
|||
;</syntaxhighlight> |
|||
<code>extent</code> is a standard library function that returns a sorted list of the elements of a stream that fit the given function best, so <code>></code> results in the maximum element. |
|||
=={{header|Wortel}}== |
|||
The <code>@maxl</code> returns the maximum value of a list: |
|||
<syntaxhighlight lang="wortel">@maxl [1 6 4 6 4 8 6 3] ; returns 8</syntaxhighlight> |
|||
=={{header|Wren}}== |
|||
<syntaxhighlight lang="wren">var max = Fn.new { |a| a.reduce { |m, x| (x > m) ? x : m } } |
|||
var a = [42, 7, -5, 11.7, 58, 22.31, 59, -18] |
|||
System.print(max.call(a))</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
59 |
|||
</pre> |
|||
=={{header|XPL0}}== |
|||
The set of values is the lengths of the lines of text in the input file. |
|||
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; \include 'code' declarations |
|||
def Tab=$09, LF=$0A, CR=$0D, EOF=$1A; |
|||
int CpuReg, Hand; |
|||
char CmdTail($80); |
|||
int I, Max, C; |
|||
[\Copy file name on command line, which is in the Program Segment Prefix (PSP) |
|||
\ ES=CpuReg(11), to the CmdTail array, which is in our Data Segment = CpuReg(12) |
|||
CpuReg:= GetReg; \point to copy of CPU registers |
|||
Blit(CpuReg(11), $81, CpuReg(12), CmdTail, $7F); |
|||
Hand:= FOpen(CmdTail, 0); \open file for input and get its handle |
|||
FSet(Hand, ^I); \assign handle to device 3 |
|||
OpenI(3); \initialize file for input |
|||
Max:= 0; \scan file for longest line |
|||
repeat I:= 0; |
|||
repeat C:= ChIn(3); |
|||
case C of |
|||
CR, LF, EOF: []; \don't count these characters |
|||
Tab: [I:= I+8 & ~7] \(every 8th column) |
|||
other I:= I+1; \count all other characters |
|||
until C=LF or C=EOF; |
|||
if I > Max then Max:= I; |
|||
until C = EOF; |
|||
Text(0, "Longest line = "); IntOut(0, Max); CrLf(0); |
|||
]</syntaxhighlight> |
|||
Example of running the program on its source code: |
|||
<pre> |
|||
maxline maxline.xpl |
|||
Longest line = 80 |
|||
</pre> |
|||
=={{header|XSLT}}== |
|||
The desired value is the first in a sequence that has been sorted numerically in descending order. |
|||
<syntaxhighlight lang="xml"><xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> |
|||
<xsl:output method="text"/> |
|||
<xsl:template match="/"> |
|||
<xsl:for-each select="/*/*"> |
|||
<!-- without data-type="number", items are sorted alphabetically --> |
|||
<xsl:sort data-type="number" order="descending"/> |
|||
<xsl:if test="position() = 1"> |
|||
<xsl:value-of select="."/> |
|||
</xsl:if> |
|||
</xsl:for-each> |
|||
</xsl:template> |
|||
</xsl:stylesheet></syntaxhighlight> |
|||
Sample input: |
|||
<syntaxhighlight lang="xml"><numbers> |
|||
<number>3</number> |
|||
<number>1</number> |
|||
<number>12</number> |
|||
<number>7</number> |
|||
</numbers></syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
12 |
|||
</pre> |
|||
=={{header|Yabasic}}== |
|||
<syntaxhighlight lang="yabasic">l$ = "1,1234,62,234,12,34,6" |
|||
dim n$(1) |
|||
n = token(l$, n$(), ", ") |
|||
for i = 1 to n |
|||
t$ = n$(i) |
|||
if t$ > m$ then m$ = t$ end if // or: if t$ > m$ m$ = t$ |
|||
if val(t$) > m then m = val(t$) end if // or: if val(t$) > m m = val(t$) |
|||
next |
|||
print "Alphabetic order: ", m$, ", numeric order: ", m</syntaxhighlight> |
|||
=={{header|Yacas}}== |
|||
Input: |
|||
<syntaxhighlight lang="yacas">Max({1, 3, 3, 7}) |
|||
Max({Pi,Exp(1)+2/5,17*Cos(6)/5,Sqrt(91/10)}) |
|||
Max({1,6,Infinity}) |
|||
Max({})</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> 7 |
|||
(17*Cos(2*Pi-6))/5 |
|||
Infinity |
|||
Undefined</pre> |
|||
=={{header|Yorick}}== |
=={{header|Yorick}}== |
||
The built-in function ''max'' does this. |
The built-in function ''max'' does this. |
||
Interactive example: |
|||
<pre>> foo = [4, 3, 2, 7, 8, 9] |
<pre>> foo = [4, 3, 2, 7, 8, 9] |
||
> max(foo) |
> max(foo) |
||
9</pre> |
9</pre> |
||
=={{header|Zig}}== |
|||
'''Works with:''' 0.10.x, 0.11.x, 0.12.0-dev.1389+42d4d07ef |
|||
<syntaxhighlight lang="zig">/// Asserts that `input` is not empty (len >= 1). |
|||
pub fn max(comptime T: type, input: []const T) T { |
|||
var max_elem: T = input[0]; |
|||
for (input[1..]) |elem| { |
|||
max_elem = @max(max_elem, elem); |
|||
} |
|||
return max_elem; |
|||
}</syntaxhighlight> |
|||
=={{header|zkl}}== |
|||
<syntaxhighlight lang="zkl">(1).max(1,2,3) //-->3 |
|||
(66).max(1,2,3.14) //-->66</syntaxhighlight> |
|||
If given a list, the max of the list is returned. The number/object just selects the method to call. Notice the difference between Int.max and Float.max. |
|||
<syntaxhighlight lang="zkl">(66).max(T(1,2,3)) //-->3 |
|||
(66).max(T(1,2,3.14)) //-->3 |
|||
(6.6).max(T(1,2,3.14)) //-->3.14</syntaxhighlight> |
|||
For other object types, you could use: |
|||
<syntaxhighlight lang="zkl">fcn max{ vm.arglist.reduce(fcn(p,n){ if(p < n) n else p }) }</syntaxhighlight> |
|||
<pre>max(2,1,-40,50,2,4,2) //-->50 |
|||
max(2) //-->2 |
|||
max("foo","bar") //-->"foo" |
|||
max("3",4,"5") //-->"5" only if strings contain only digits |
|||
</pre> |
|||
=={{header|Zoea}}== |
|||
<syntaxhighlight lang="zoea"> |
|||
program: max |
|||
case: 1 |
|||
input: [7,3,5,9,2,6] |
|||
output: 9 |
|||
case: 2 |
|||
input: [1,5,3,2,7] |
|||
output: 7 |
|||
</syntaxhighlight> |
|||
=={{header|ZX Spectrum Basic}}== |
|||
<syntaxhighlight lang="zxbasic">10 PRINT "Values"'' |
|||
20 LET z=0 |
|||
30 FOR x=1 TO INT (RND*10)+1 |
|||
40 LET y=RND*10-5 |
|||
50 PRINT y |
|||
60 LET z=(y AND y>z)+(z AND y<z) |
|||
70 NEXT x |
|||
80 PRINT '"Max. value = ";z</syntaxhighlight> |
Latest revision as of 08:30, 9 August 2024
![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
Create a function that returns the maximum value in a provided set of values,
where the number of values may not be known until run-time.
11l
11l already has a "Maximum Value" function.
max(values)
8th
[ 1.0, 2.3, 1.1, 5.0, 3, 2.8, 2.01, 3.14159 ] ' n:max 0 a:reduce . cr
Output: 5
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program rechMax64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessResult: .ascii "Max number is = @ rank = @ address (hexa) = @ \n" // message result
tTableNumbers: .quad 50
.quad 12
.quad -1000
.quad 40
.quad 255
.quad 60
.quad 254
.equ NBRANKTABLE, (. - tTableNumbers) / 8 // number table posts
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
ldr x1,qAdrtTableNumbers
mov x2,0
ldr x4,[x1,x2,lsl #3] // load first number
mov x3,x2 // save first indice
add x2,x2,1 // increment indice
1:
cmp x2,#NBRANKTABLE // indice ? maxi
bge 2f // yes -> end search
ldr x0,[x1,x2,lsl #3] // load other number
cmp x0,x4 // > old number max
csel x4,x0,x4,gt // if > x4 = x0 else x4=x4
csel x3,x2,x3,gt // if > x3 = x2 else x3=x3
add x2,x2,1 // increment indice
b 1b // and loop
2:
mov x0,x4
ldr x1,qAdrsZoneConv
bl conversion10S // decimal conversion
ldr x0,qAdrszMessResult
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at first @ character
mov x5,x0 // save address message
mov x0,x3
ldr x1,qAdrsZoneConv // conversion rank maxi
bl conversion10S // decimal conversion
mov x0,x5 // message address
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at Second @ character
mov x5,x0 // save message address
ldr x0,qAdrtTableNumbers
lsl x3,x3,3
add x0,x0,x3
ldr x1,qAdrsZoneConv // conversion address maxi
bl conversion16 // hexa conversion
mov x0,x5
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at third @ character
bl affichageMess // display message final
100: // standard end of the program
mov x0,0 // return code
mov x8,EXIT // request to exit program
svc 0 // perform the system call
qAdrtTableNumbers: .quad tTableNumbers
qAdrszMessResult: .quad szMessResult
qAdrsZoneConv: .quad sZoneConv
/******************************************************************/
/* conversion hexadecimal register */
/******************************************************************/
/* x0 contains value and x1 address zone receptrice */
conversion16:
stp x0,lr,[sp,-48]! // save registres
stp x1,x2,[sp,32] // save registres
stp x3,x4,[sp,16] // save registres
mov x2,#60 // start bit position
mov x4,#0xF000000000000000 // mask
mov x3,x0 // save entry value
1: // start loop
and x0,x3,x4 // value register and mask
lsr x0,x0,x2 // right shift
cmp x0,#10 // >= 10 ?
bge 2f // yes
add x0,x0,#48 // no is digit
b 3f
2:
add x0,x0,#55 // else is a letter A-F
3:
strb w0,[x1],#1 // load result and + 1 in address
lsr x4,x4,#4 // shift mask 4 bits left
subs x2,x2,#4 // decrement counter 4 bits <= zero ?
bge 1b // no -> loop
100: // fin standard de la fonction
ldp x3,x4,[sp,16] // restaur des 2 registres
ldp x1,x2,[sp,32] // restaur des 2 registres
ldp x0,lr,[sp],48 // restaur des 2 registres
ret
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
- Output:
Max number is = +255 rank = +4 address (hexa) = 000000000041051C
ACL2
(defun maximum (xs)
(if (endp (rest xs))
(first xs)
(max (first xs)
(maximum (rest xs)))))
Action!
BYTE FUNC Max(BYTE ARRAY tab BYTE size)
BYTE i,res
res=tab(0)
FOR i=1 TO size-1
DO
IF res<tab(i) THEN
res=tab(i)
FI
OD
RETURN (res)
PROC Main()
BYTE i,m,size=[20]
BYTE ARRAY tab(size)
FOR i=0 TO size-1
DO
tab(i)=Rand(0)
OD
Print("Array:")
FOR i=0 TO size-1
DO
PrintF(" %I",tab(i))
OD
PutE()
m=Max(tab,size)
PrintF("Greatest: %I%E",m)
RETURN
- Output:
Screenshot from Atari 8-bit computer
Array: 106 182 121 251 21 244 46 157 228 251 173 50 106 126 193 230 88 117 114 120 Greatest: 251
ActionScript
function max(... args):Number
{
var curMax:Number = -Infinity;
for(var i:uint = 0; i < args.length; i++)
curMax = Math.max(curMax, args[i]);
return curMax;
}
Ada
The keys for this task are initializing the compared value to the 'First value of the element type, and use of an unconstrained array type.
with Ada.Text_Io;
procedure Max_Test isco
-- substitute any array type with a scalar element
type Flt_Array is array (Natural range <>) of Float;
-- Create an exception for the case of an empty array
Empty_Array : Exception;
function Max(Item : Flt_Array) return Float is
Max_Element : Float := Float'First;
begin
if Item'Length = 0 then
raise Empty_Array;
end if;
for I in Item'range loop
if Item(I) > Max_Element then
Max_Element := Item(I);
end if;
end loop;
return Max_Element;
end Max;
Buf : Flt_Array := (-275.0, -111.19, 0.0, -1234568.0, 3.14159, -3.14159);
begin
Ada.Text_IO.Put_Line(Float'Image(Max(Buf)));
end Max_Test;
A generic function Max to deal with any floating-point type.
generic
type Item is digits <>;
type Items_Array is array (Positive range <>) of Item;
function Generic_Max (List : Items_Array) return Item;
Implementation of:
function Generic_Max (List : Items_Array) return Item is
Result : Item := List (List'First);
begin
for Index in List'First + 1..List'Last loop
Result := Item'Max (Result, List (Index));
end loop;
return Result;
end Generic_Max;
When the argument array is empty, Constraint_Error exception is propagated, because array indexing is checked in Ada. Note also use of the floating-type attribute Max.
Aime
integer
lmax(list l)
{
integer max, x;
max = l[0];
for (, x in l) {
if (max < x) {
max = x;
}
}
max;
}
or
integer
lmax(list l)
{
integer max;
max = l[0];
l.ucall(max_i, 1, max);
max;
}
ALGOL 68
# substitute any array type with a scalar element #
MODE FLT = REAL;
# create an exception for the case of an empty array #
PROC raise empty array = VOID:(
GO TO except empty array
);
PROC max = ([]FLT item)FLT:
BEGIN
IF LWB item > UPB item THEN
raise empty array; SKIP
ELSE
FLT max element := item[LWB item];
FOR i FROM LWB item + 1 TO UPB item DO
IF item[i] > max element THEN
max element := item[i]
FI
OD;
max element
FI
END # max #;
test:(
[]FLT buf = (-275.0, -111.19, 0.0, -1234568.0, pi, -pi);
print((max(buf),new line)) EXIT
except empty array:
SKIP
)
- Output:
+3.14159265358979e +0
ALGOL W
begin
% simple list type %
record IntList( integer val; reference(IntList) next );
% find the maximum element of an IntList, returns 0 for an empty list %
integer procedure maxElement( reference(IntList) value list ) ;
begin
integer maxValue;
reference(IntList) listPos;
maxValue := 0;
listPos := list;
if listPos not = null then begin
% non-empty list %
maxValue := val(listPos);
listPos := next(listPos);
while listPos not = null do begin
if val(listPos) > maxValue then maxValue := val(listPos);
listPos := next(listPos)
end while_listPos_ne_null ;
end if_listPos_ne_null ;
maxValue
end maxElement ;
% test the maxElement procedure %
write( maxElement( IntList( -767, IntList( 2397, IntList( 204, null ) ) ) ) )
end.
- Output:
2397
Amazing Hopper
Version 1:
#include <hopper.h>
main:
lst=0
max=0
file="datos.txt"
{","} toksep
{file} statsfile
{file} load
mov (lst)
{0} reshape (lst)
{lst} array (SORT)
[end] get (lst)
mov (max)
{"Maximo = "}
{max}
{"\n"} print
exit(0)
Version 2:
#include <hopper.h>
#define SIZE_LIST 100000
main:
lst=-1
max=0
{SIZE_LIST} rand array (lst)
mul by (SIZE_LIST)
mov (lst)
{lst} array (SORT)
[end] get (lst)
mov (max)
{"Maximo = "}
{max}
{"\n"} print
exit(0)
- Output:
Maximo = 99999.8
AntLang
max|range[10]
APL
LIST←2 4 6 3 8
⌈/LIST
- Output:
8
AppleScript
max({1, 2, 3, 4, 20, 6, 11, 3, 9, 7})
on max(aList)
set _curMax to first item of aList
repeat with i in (rest of aList)
if i > _curMax then set _curMax to contents of i
end repeat
return _curMax
end max
To find the greatest elements of lists which may contain data types other than numbers, we can write a more generic maximumBy function, which returns the maximum value from an array containing a series of any consistent data type, and which takes a type-specific comparison function as an argument.
-- maximumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a
on maximumByMay(f, xs)
set cmp to mReturn(f)
script max
on |λ|(a, b)
if cmp's |λ|(a, b) < 0 then
b
else
a
end if
end |λ|
end script
foldl1May(max, xs)
end maximumByMay
-- TEST -----------------------------------------------------------------------
on run
set lstWords to ["alpha", "beta", "gamma", "delta", "epsilon", ¬
"zeta", "eta", "theta", "iota", "kappa", "|λ|", "mu"]
set lstCities to [{name:"Shanghai", population:24.15}, ¬
{name:"Karachi", population:23.5}, ¬
{name:"Beijing", population:21.5}, ¬
{name:"Tianjin", population:14.7}, ¬
{name:"Istanbul", population:14.4}, ¬
{name:"Lagos", population:13.4}, ¬
{name:"Tokyo", population:13.3}]
script population
on |λ|(x)
population of x
end |λ|
end script
return catMaybes({¬
maximumByMay(comparing(|length|), lstWords), ¬
maximumByMay(comparing(|length|), {}), ¬
maximumByMay(comparing(population), lstCities)})
--> {"epsilon", {name:"Shanghai", population:24.15}}
end run
-- GENERIC FUNCTIONS ----------------------------------------------------------
-- catMaybes :: [Maybe a] -> [a]
on catMaybes(mbs)
script emptyOrListed
on |λ|(m)
if nothing of m then
{}
else
{just of m}
end if
end |λ|
end script
concatMap(emptyOrListed, mbs)
end catMaybes
-- comparing :: (a -> b) -> (a -> a -> Ordering)
on comparing(f)
set mf to mReturn(f)
script
on |λ|(a, b)
set x to mf's |λ|(a)
set y to mf's |λ|(b)
if x < y then
-1
else
if x > y then
1
else
0
end if
end if
end |λ|
end script
end comparing
-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
set acc to {}
tell mReturn(f)
repeat with x in xs
set acc to acc & |λ|(contents of x)
end repeat
end tell
return acc
end concatMap
-- foldl1May :: (a -> a -> a) -> [a] -> Maybe a
on foldl1May(f, xs)
set lng to length of xs
if lng > 0 then
if lng > 1 then
tell mReturn(f)
set v to item 1 of xs
set lng to length of xs
repeat with i from 2 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return just(v)
end tell
else
just(item 1 of xs)
end if
else
nothing("Empty list")
end if
end foldl1May
-- just :: a -> Just a
on just(x)
{nothing:false, just:x}
end just
-- length :: [a] -> Int
on |length|(xs)
length of xs
end |length|
-- max :: Ord a => a -> a -> a
on max(x, y)
if x > y then
x
else
y
end if
end max
-- nothing :: () -> Nothing
on nothing(msg)
{nothing:true, msg:msg}
end nothing
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn
- Output:
{"epsilon", {name:"Shanghai", population:24.15}}
Applesoft BASIC
100 REMMAX
110 R$ = "":E$ = ""
120 L = LEN (L$)
130 IF L = 0 THEN RETURN
140 FOR I = 1 TO L
150 C$ = MID$ (L$,I,1)
160 SP = C$ = " "
170 IF SP THEN GOSUB 200
180 E$ = E$ + C$
190 NEXT I
200 C$ = ""
210 IF E$ = "" THEN RETURN
220 V = VAL (E$):V$ = R$
230 E$ = "":E = V$ = ""
240 IF E AND V = 0 THEN RETURN
250 R$ = STR$ (V)
260 IF E THEN RETURN
270 R = VAL (V$)
280 IF R < V THEN RETURN
290 R$ = V$: RETURN
L$ = "1 2 3 4 20 6 11 3 9 7"
GOSUB 100MAX
PRINT R$
- Output:
20
ARM Assembly
/* ARM assembly Raspberry PI */
/* program rechMax.s */
/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessResult: .ascii "Max number is = " @ message result
sMessValeur: .fill 12, 1, ' '
.ascii " rank = "
sMessRank: .fill 12, 1, ' '
.ascii " address (hexa) = "
sMessAddress: .fill 12, 1, ' '
.asciz "\n"
tTableNumbers: .int 50
.int 12
.int -1000
.int 40
.int 255
.int 60
.int 254
.equ NBRANKTABLE, (. - tTableNumbers) / 4 @ number table posts
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
push {fp,lr} @ saves 2 registers
ldr r1,iAdrtTableNumbers
mov r2,#0
ldr r4,[r1,r2,lsl #2]
mov r3,r2
add r2,#1
1:
cmp r2,#NBRANKTABLE
bge 2f
ldr r0,[r1,r2,lsl #2]
cmp r0,r4
movgt r4,r0
movgt r3,r2
add r2,#1
b 1b
2:
mov r0,r4
ldr r1,iAdrsMessValeur
bl conversion10S @ call conversion
mov r0,r3
ldr r1,iAdrsMessRank
bl conversion10 @ call conversion
ldr r0,iAdrtTableNumbers
add r0,r3,lsl #2
ldr r1,iAdrsMessAddress
bl conversion16 @ call conversion
ldr r0,iAdrszMessResult
bl affichageMess @ display message
100: @ standard end of the program
mov r0, #0 @ return code
pop {fp,lr} @restaur 2 registers
mov r7, #EXIT @ request to exit program
swi 0 @ perform the system call
iAdrtTableNumbers: .int tTableNumbers
iAdrsMessValeur: .int sMessValeur
iAdrsMessRank: .int sMessRank
iAdrsMessAddress: .int sMessAddress
iAdrszMessResult: .int szMessResult
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {fp,lr} /* save registres */
push {r0,r1,r2,r7} /* save others registers */
mov r2,#0 /* counter length */
1: /* loop length calculation */
ldrb r1,[r0,r2] /* read octet start position + index */
cmp r1,#0 /* if 0 its over */
addne r2,r2,#1 /* else add 1 in the length */
bne 1b /* and loop */
/* so here r2 contains the length of the message */
mov r1,r0 /* address message in r1 */
mov r0,#STDOUT /* code to write to the standard output Linux */
mov r7, #WRITE /* code call system "write" */
swi #0 /* call systeme */
pop {r0,r1,r2,r7} /* restaur others registers */
pop {fp,lr} /* restaur des 2 registres */
bx lr /* return */
/******************************************************************/
/* Converting a register to hexadecimal */
/******************************************************************/
/* r0 contains value and r1 address area */
conversion16:
push {r1-r4,lr} /* save registers */
mov r2,#28 @ start bit position
mov r4,#0xF0000000 @ mask
mov r3,r0 @ save entry value
1: @ start loop
and r0,r3,r4 @value register and mask
lsr r0,r2 @ move right
cmp r0,#10 @ compare value
addlt r0,#48 @ <10 ->digit
addge r0,#55 @ >10 ->letter A-F
strb r0,[r1],#1 @ store digit on area and + 1 in area address
lsr r4,#4 @ shift mask 4 positions
subs r2,#4 @ counter bits - 4 <= zero ?
bge 1b @ no -> loop
@end
pop {r1-r4,lr} @ restaur registres
bx lr @return
/******************************************************************/
/* Converting a register to a decimal */
/******************************************************************/
/* r0 contains value and r1 address area */
conversion10:
push {r1-r4,lr} /* save registers */
mov r3,r1
mov r2,#10
1: @ start loop
bl divisionpar10 @ r0 <- dividende. quotient ->r0 reste -> r1
add r1,#48 @ digit
strb r1,[r3,r2] @ store digit on area
sub r2,#1 @ previous position
cmp r0,#0 @ stop if quotient = 0 */
bne 1b @ else loop
@ and move spaves in first on area
mov r1,#' ' @ space
2:
strb r1,[r3,r2] @ store space in area
subs r2,#1 @ @ previous position
bge 2b @ loop if r2 >= zéro
100:
pop {r1-r4,lr} @ restaur registres
bx lr @return
/***************************************************/
/* Converting a register to a signed decimal */
/***************************************************/
/* r0 contains value and r1 area address */
conversion10S:
push {r0-r4,lr} @ save registers
mov r2,r1 /* debut zone stockage */
mov r3,#'+' /* par defaut le signe est + */
cmp r0,#0 @ negative number ?
movlt r3,#'-' @ yes
mvnlt r0,r0 @ number inversion
addlt r0,#1
mov r4,#10 @ length area
1: @ start loop
bl divisionpar10
add r1,#48 @ digit
strb r1,[r2,r4] @ store digit on area
sub r4,r4,#1 @ previous position
cmp r0,#0 @ stop if quotient = 0
bne 1b
strb r3,[r2,r4] @ store signe
subs r4,r4,#1 @ previous position
blt 100f @ if r4 < 0 -> end
mov r1,#' ' @ space
2:
strb r1,[r2,r4] @store byte space
subs r4,r4,#1 @ previous position
bge 2b @ loop if r4 > 0
100:
pop {r0-r4,lr} @ restaur registers
bx lr
/***************************************************/
/* division par 10 signé */
/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*
/* and http://www.hackersdelight.org/ */
/***************************************************/
/* r0 dividende */
/* r0 quotient */
/* r1 remainder */
divisionpar10:
/* r0 contains the argument to be divided by 10 */
push {r2-r4} /* save registers */
mov r4,r0
ldr r3, .Ls_magic_number_10 /* r1 <- magic_number */
smull r1, r2, r3, r0 /* r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0) */
mov r2, r2, ASR #2 /* r2 <- r2 >> 2 */
mov r1, r0, LSR #31 /* r1 <- r0 >> 31 */
add r0, r2, r1 /* r0 <- r2 + r1 */
add r2,r0,r0, lsl #2 /* r2 <- r0 * 5 */
sub r1,r4,r2, lsl #1 /* r1 <- r4 - (r2 * 2) = r4 - (r0 * 10) */
pop {r2-r4}
bx lr /* leave function */
.align 4
.Ls_magic_number_10: .word 0x66666667
Arturo
arr: [5 4 2 9 7 3]
print max arr
- Output:
9
AutoHotkey
CSV Data
list = 1,5,17,-2
Loop Parse, list, `,
x := x < A_LoopField ? A_LoopField : x
MsgBox Max = %x%
Pseudo-arrays
list = 1,5,17,-2
StringSplit, list, list,`, ; creates a pseudo-array
Loop % List0
x := x < List%A_Index% ? List%A_Index% : x
MsgBox Max = %x%
True arrays
List := [1,5,17,-2]
For each, value in List
x := x < value ? value : x
MsgBox Max = %x%
AWK
One-liner:
$ awk 'func max(a){for(i in a)if(a[i]>r)r=a[i];return r}BEGIN{a[0]=42;a[1]=33;a[2]=21;print max(a)}'
42
More readable version:
# Usage: awk -f greatest_list_element.awk
#
function max(a) {
for(i in a) if(a[i]>r) r=a[i];
return r
}
#
BEGIN { a[0]=42;
a[1]=33;
a[2]=21;
print max(a)
}
Axe
This example assumes the array is null-terminated so that the program can stop at the end of the data.
Lbl MAX
0→M
While {r₁}
{r₁}>M?{r₁}→M
End
M
Return
BASIC
DECLARE SUB addVal (value AS INTEGER)
DECLARE FUNCTION findMax% ()
REDIM SHARED vals(0) AS INTEGER
DIM SHARED valCount AS INTEGER
DIM x AS INTEGER, y AS INTEGER
valCount = -1
'''''begin test run
RANDOMIZE TIMER
FOR x = 1 TO 10
y = INT(RND * 100)
addVal y
PRINT y; " ";
NEXT
PRINT ": "; findMax
'''''end test run
SUB addVal (value AS INTEGER)
DIM tmp AS INTEGER
IF valCount > -1 THEN
'this is needed for BASICs that don't support REDIM PRESERVE
REDIM v2(valCount) AS INTEGER
FOR tmp = 0 TO valCount
v2(tmp) = vals(tmp)
NEXT
END IF
valCount = valCount + 1
REDIM vals(valCount)
IF valCount > 0 THEN
'also needed for BASICs that don't support REDIM PRESERVE
FOR tmp = 0 TO valCount - 1
vals(tmp) = v2(tmp)
NEXT
END IF
vals(valCount) = value
END SUB
FUNCTION findMax%
DIM tmp1 AS INTEGER, tmp2 AS INTEGER
FOR tmp1 = 0 TO valCount
IF vals(tmp1) > tmp2 THEN tmp2 = vals(tmp1)
NEXT
findMax = tmp2
END FUNCTION
- Output:
8162 5139 7004 7393 5151 4476 577 4419 3333 4649 : 8162
BaCon
' Greatest element from list
' Populate sample array of numbers
READ elements
DECLARE numbers TYPE NUMBER ARRAY elements
FOR i = 0 TO elements - 1
READ numbers[i]
NEXT
DATA 6
DATA 100,-2,300,4,500,6
' Demonstrate the function
PRINT greatest(elements, numbers)
END
' Return greatest element given count and list of numbers
FUNCTION greatest(n, NUMBER a[])
LOCAL mx = a[0]
FOR i = 1 TO n - 1
mx = MAX(mx, a[i])
NEXT
RETURN mx
END FUNCTION
- Output:
prompt$ ./greatest-element 500
See also: BBC BASIC, Liberty BASIC, PowerBASIC, PureBasic, Run BASIC, TI-89 BASIC, Visual Basic
BASIC256
l$ = "1,1234,62,234,12,34,6"
dim n$(1)
n$ = explode(l$, ",")
m$ = "" : m = 0
for i = 1 to n$[?]-1
t$ = n$[i]
if t$ > m$ then m$ = t$
if int(t$) > m then m = int(t$)
next i
print "Alphabetic order: "; m$; ", numeric order: "; m
Chipmunk Basic
The GW-BASIC solution works without any changes.
Minimal BASIC
10 PRINT "HOW MANY ITEMS? "
20 INPUT N
30 FOR J = 0 TO N-1
40 PRINT "VALUE OF ITEM #";J
50 INPUT T
60 LET A(J) = T
70 NEXT J
80 LET C = A(0)
90 LET I = 0
100 FOR J = 1 TO N-1
110 IF A(J) > C THEN 130
120 GOTO 150
130 LET C = A(J)
140 LET I = J
150 NEXT J
160 PRINT "THE MAXIMUM VALUE WAS ";C;" AT INDEX ";I;"."
170 END
IS-BASIC
1000 DEF FINDMAX(REF ARR)
1010 LET MX=ARR(LBOUND(ARR))
1020 FOR I=LBOUND(ARR)+1 TO UBOUND(ARR)
1030 LET MX=MAX(MX,ARR(I))
1040 NEXT
1050 LET FINDMAX=MX
1060 END DEF
MSX Basic
10 INPUT "How many items"; N%
20 DIM ARR(N%)
30 FOR I% = 0 TO N% - 1
40 PRINT "Value of item #"; I%
50 INPUT ARR(I%)
60 NEXT I%
70 CHAMP = ARR(0) : INDEX = 0
80 FOR I% = 1 TO N% - 1
90 IF ARR(I%) > CHAMP THEN CHAMP = ARR(I%): INDEX = I%
100 NEXT I%
110 PRINT "The maximum value was "; CHAMP; " at index "; INDEX; "."
120 END
Quite BASIC
10 INPUT "How many items? "; n
20 ARRAY a
30 FOR j = 0 TO n-1
40 PRINT "Value of item #"; j
50 INPUT ""; t
60 LET a(j) = t
70 NEXT j
80 LET c = a(0)
90 LET i = 0
100 FOR j = 1 TO n-1
110 IF a(j) > c THEN LET c = a(j) : LET i = j
120 NEXT j
130 PRINT "The maximum value was "; c; " at index "; i; "."
140 END
SmallBASIC
list = [1,1234,62,234,12,34,6]
print max(list)
Batch File
::max.cmd
@echo off
setlocal enabledelayedexpansion
set a=.%~1
if "%a%" equ "." set /p a="Input stream: "
call :max res %a%
echo %res%
endlocal
goto :eof
:max
set %1=%2
:loop
shift /2
if "%2" equ "" goto :eof
if %2 gtr !%1! set res=%2
goto loop
Invocation from command line or from internal prompt
>max "123 456 3 234243 12"
234243
>max
Input stream: 5 4 3 2 67 1
67
BBC BASIC
ListOfValues$ = "13, 0, -6, 2, 37, -10, 12"
PRINT "Maximum value = " ; FNmax(ListOfValues$)
END
DEF FNmax(list$)
LOCAL index%, number, max
max = VAL(list$)
REPEAT
index% = INSTR(list$, ",", index%+1)
number = VAL(MID$(list$, index%+1))
IF number > max THEN max = number
UNTIL index% = 0
= max
bc
define m(a[], n) {
auto m, i
m = a[0]
for (i = 1; i < n; i++) {
if (a[i] > m) m = a[i]
}
return(m)
}
Befunge
001pv <
>&:01g`#v_1+#^_01g.@
^p10 <
Only works with positive integers. List must be terminated with -1.
BQN
Max ← ⌈´
- Output:
Max ¯275‿¯111‿0‿¯1234568‿π‿¯π 3.141592653589793
Bracmat
When comparing two rational numbers, Bracmat compares numerically. In all other cases Bracmat compares lexically.
( biggest
= max
. !arg:
| !arg:%?max ?arg
& !arg:? (%@:>!max:?max) (?&~)
| !max
)
& out$("1:" biggest$(5 100000 -5 aap 3446 NOOT mies 0))
& out$("2:" biggest$)
& out
$ ( "3:"
biggest
$ (5 100000 -5 43756243978569758/13 3365864921428443 87512487957139516/27 3446)
)
- Output:
1: mies 2: 3: 3365864921428443
Brat
Arrays have a max function, but here's a manual implementation.
max = { list |
list.reduce { n, max |
true? n > max
{ max = n }
{ max }
}
}
p max [3 4 1 2]
Burlesque
blsq ) {88 99 77 66 55}>]
99
C
This works well with floats. Replace with double, int or what-have-you before passing a different data type.
#include <assert.h>
float max(unsigned int count, float values[]) {
assert(count > 0);
size_t idx;
float themax = values[0];
for(idx = 1; idx < count; ++idx) {
themax = values[idx] > themax ? values[idx] : themax;
}
return themax;
}
The following macro can be used with any number and type of arguments, provided that the arguments are simple, i.e. must not contain subexpressions where commas appear (this is because of the way the arguments are counted; the macro can be modified so that it is up to the caller to count the number of arguments passed).
#include <stdarg.h>
#define MAX(A,...) ({ inline __typeof__ (A) _max_(__typeof__ (A) a, ...) {\
va_list l; int i,c; const char *s = #__VA_ARGS__; __typeof__ (A) max = a;\
__typeof__ (A) t;\
for(c=1;*s!=0;s++) if (*s==',') c++;\
va_start(l, a);\
for(i=0;i<=c;i++) {\
if ((t=va_arg(l,__typeof__ (A))) > max) max = t;\
}\
va_end(l); return max;\
}\
_max_((A),__VA_ARGS__);\
})
C#
C# already has a "Maximum Value" function.
int[] values = new int[] {1,2,3,4,5,6,7,8,9,10};
int max = values.Max();
C++
A simple wrapper around the standard library function max_element(). Requires C++17.
#include <algorithm> //std::max_element
#include <iterator> //std::begin and std::end
#include <functional> //std::less
template<class It, class Comp = std::less<>>
//requires ForwardIterator<It> && Compare<Comp>
constexpr auto max_value(It first, It last, Comp compare = std::less{})
{
//Precondition: first != last
return *std::max_element(first, last, compare);
}
template<class C, class Comp = std::less<>>
//requires Container<C> && Compare<Comp>
constexpr auto max_value(const C& container, Comp compare = std::less{})
{
//Precondition: !container.empty()
using std::begin; using std::end;
return max_value(begin(container), end(container), compare);
}
CFEngine
Note: CFEngine bundles are NOT functions, however they can behave in some ways that are similar to functions.
bundle agent __main__
{
vars:
"number_of_list_elements"
int => randomint( "0", 100 ),
unless => isvariable( "$(this.promiser)" );
"idx"
slist => expandrange( "[0-$(number_of_list_elements)]", 1 ),
unless => isvariable( "$(this.promiser)" );
"number[$(idx)]"
int => randomint( "0", "100" ),
unless => isvariable( "$(this.promiser)" );
"numbers" slist => sort( getvalues( number ), int );
methods:
"Get the greatest value"
usebundle => greatest_value( @(numbers) ),
useresult => "returned";
reports:
"'$(returned[max])' is the largest number in $(with)"
with => join( ",", numbers );
}
bundle agent greatest_value(list_of_values)
{
reports:
"$(with)"
with => max( list_of_values, int ),
bundle_return_value_index => "max";
}
- Output:
R: '97' is the largest number in 3,5,6,13,15,30,34,37,47,49,49,53,54,59,59,59,60,62,64,67,78,83,95,97
Clojure
The Clojure.core function max returns the max of its arguments.
(max 1 2 3 4) ; evaluates to 4
;; If the values are already in a collection, use apply:
(apply max [1 2 3 4]) ; evaluates to 4
CLU
% This "maximum" procedure is fully general, as long as
% the container type has an elements iterator and the
% data type is comparable.
% It raises an exception ("empty") if there are no elements.
maximum = proc [T,U: type] (a: T) returns (U)
signals (empty)
where T has elements: itertype (T) yields (U),
U has gt: proctype (U,U) returns (bool)
max: U
seen: bool := false
for item: U in T$elements(a) do
if ~seen cor item > max then
max := item
seen := true
end
end
if (~seen) then
signal empty
else
return(max)
end
end maximum
start_up = proc ()
po: stream := stream$primary_output()
% try it on an array of ints
ints: array[int] := array[int]$[1,5,17,2,53,99,61,3]
imax: int := maximum[array[int], int](ints)
stream$putl(po, "maximum int: " || int$unparse(imax))
% try it on a sequence of reals
reals: sequence[real] := sequence[real]$[-0.5, 2.6, 3.14, 2.72]
rmax: real := maximum[sequence[real], real](reals)
stream$putl(po, "maximum real: " || real$unparse(rmax))
end start_up
- Output:
maximum int: 99 maximum real: 3.140000e+00
CMake
Only for lists of integers.
# max(var [value1 value2...]) sets var to the maximum of a list of
# integers. If list is empty, sets var to NO.
function(max var)
set(first YES)
set(choice NO)
foreach(item ${ARGN})
if(first)
set(choice ${item})
set(first NO)
elseif(choice LESS ${item})
set(choice ${item})
endif()
endforeach(item)
set(${var} ${choice} PARENT_SCOPE)
endfunction(max)
set(list 33 11 44 22 66 55)
max(maximum ${list})
message(STATUS "maximum of ${list} => ${maximum}")
-- maximum of 33;11;44;22;66;55 => 66
COBOL
This is already built into the language for tables of numbers.
DISPLAY FUNCTION MAX(nums (ALL))
A sample implementation:
IDENTIFICATION DIVISION.
FUNCTION-ID. greatest-elt.
DATA DIVISION.
LOCAL-STORAGE SECTION.
01 idx USAGE INDEX.
01 Table-Len CONSTANT 50.
LINKAGE SECTION.
01 num-table-area.
03 num-table PIC 9(8) OCCURS Table-Len TIMES.
01 max-elt PIC 9(8).
PROCEDURE DIVISION USING VALUE num-table-area RETURNING max-elt.
PERFORM VARYING idx FROM 1 BY 1 UNTIL idx > Table-Len
IF num-table (idx) > max-elt
MOVE num-table (idx) TO max-elt
END-IF
END-PERFORM
GOBACK
.
END FUNCTION greatest-elt.
CoffeeScript
# using Math library
max1 = (list) ->
Math.max.apply null, list
# using no libraries
max2 = (list) ->
maxVal = list[0]
for value in list
maxVal = value if value > maxVal
maxVal
# Test it
a = [0,1,2,5,4];
alert(max1(a)+". The answer is "+max2(a));
ColdFusion
<Cfset theList = '1, 1000, 250, 13'>
<Cfparam name="maxNum" default=0>
<Cfloop list="#theList#" index="i">
<Cfif i gt maxNum><Cfset maxNum = i></Cfif>
</Cfloop>
<Cfoutput>#maxNum#</Cfoutput>
<Cfset theList = '1, 1000, 250, 13'>
<Cfset maxNum = ListFirst(ListSort(thelist, "numeric", "desc"))>
<Cfoutput>#maxNum#</Cfoutput>
Common Lisp
The built-in Common Lisp function max takes the max of all its arguments.
(max 1 2 3 4)
(reduce #'max values) ; find max of a list
(loop for x in values
maximize x) ; alternative way to find max of a list
Component Pascal
BalckBox Component Builder
MODULE Operations;
IMPORT StdLog,Args,Strings;
PROCEDURE Max(s: ARRAY OF INTEGER): INTEGER;
VAR
i: INTEGER;
max: INTEGER;
BEGIN
max := MIN(INTEGER);
FOR i := 0 TO LEN(s) - 1 DO
max := MAX(max,s[i]);
END;
RETURN max
END Max;
PROCEDURE DoMax*;
VAR
sq: POINTER TO ARRAY OF INTEGER;
p: Args.Params;
i,n,done: INTEGER;
BEGIN
Args.Get(p);
IF p.argc > 0 THEN
NEW(sq,p.argc);
FOR i := 0 TO p.argc - 1 DO
Strings.StringToInt(p.args[i],n,done);
sq[i] := n
END;
StdLog.String("max:> ");StdLog.Int(Max(sq));StdLog.Ln
END
END DoMax;
END Operations.
Execute: ^Q Operations..DoMax 23 12 3 45 34 54 84 ~
- Output:
max:> 84
Crystal
values.max
D
D already has a "Maximum Element" function.
void main()
{
import std.algorithm.searching : maxElement;
import std.stdio : writeln;
[9, 4, 3, 8, 5].maxElement.writeln;
}
- Output:
9
Dart
/*This is a function which returns the greatest element in a list of numbers */
num findGreatestElement(List<num> list){
num greatestElement = list[0];
for (num element in list){
if (element>greatestElement) {
greatestElement = element;
}
}
return greatestElement;
}
/* and this is a shorter version */
import 'dart:math';
num findGreatestElement(List<num> list){
return list.reduce(max);
}
dc
[sm llx] sg
[lm p q] sq
[d lm <u s_ z 0 =q llx] sl
[d sm] su
["Put list of numbers on the stack starting here, then execute g"] s_
3.14159265358979 sp
_275.0 _111.19 0.0 _1234568.0 lp lp _1 *
lgx
- Output:
3.14159265358979
DCL
$ list = "45,65,81,12,0,13,-56,123,-123,888,12,0"
$ max = f$integer( f$element( 0, ",", list ))
$ i = 1
$ loop:
$ element = f$element( i, ",", list )
$ if element .eqs. "," then $ goto done
$ element = f$integer( element )
$ if element .gt. max then $ max = element
$ i = i + 1
$ goto loop
$ done:
$ show symbol max
- Output:
$ @greatest MAX = 888 Hex = 00000378 Octal = 00000001570
Delphi
program GElemLIst;
{$IFNDEF FPC}
{$Apptype Console}
{$ENDIF}
uses
math;
const
MaxCnt = 10000;
var
IntArr : array of integer;
fltArr : array of double;
i: integer;
begin
setlength(fltArr,MaxCnt); //filled with 0
setlength(IntArr,MaxCnt); //filled with 0.0
randomize;
i := random(MaxCnt); //choose a random place
IntArr[i] := 1;
fltArr[i] := 1.0;
writeln(Math.MaxIntValue(IntArr)); // Array of Integer
writeln(Math.MaxValue(fltArr));
end.
Dyalect
func max(xs) {
var y
for x in xs {
if y == nil || x > y {
y = x
}
}
y
}
var xs = [1..10]
max(xs)
Déjà Vu
max lst:
lst! 0
for item in copy lst:
if > item dup:
item drop
!. max [ 10 300 999 9 ]
- Output:
999
Draco
/* Find the greatest element in an array of ints */
proc nonrec max([*] int a) int:
int INT_MIN = ~((~0) >> 1);
int nmax, i;
nmax := INT_MIN;
for i from 0 upto dim(a,1)-1 do
if a[i] > nmax then nmax := a[i] fi
od;
nmax
corp
/* Test on an array */
proc nonrec main() void:
type arr = [8] int;
writeln("Maximum: ", max(arr(1,5,17,2,53,99,61,3)))
corp
- Output:
Maximum: 99
E
This function works for any value which responds to max/1
:
pragma.enable("accumulator") # non-finalized syntax feature
def max([first] + rest) {
return accum first for x in rest { _.max(x) }
}
? max([1, 2, 3])
# value: 3
To require only the comparison protocol, one needs to write out the algorithm a little more explicitly:
def max([var bestSoFar] + rest) {
for x ? (x > bestSoFar) in rest {
bestSoFar := x
}
return bestSoFar
}
? max([1, 3, 2])
# value: 3
? max([[1].asSet(), [2].asSet(), [1, 2].asSet()])
# value: [1, 2].asSet()
EasyLang
a[] = [ 2 9 4 3 8 5 ]
for e in a[]
max = higher e max
.
print max
EchoLisp
;; a random length list of random values
(define L (map random (make-list (random 50) 100))) → L
L → (24 60 83 8 24 60 31 97 96 65 9 41 64 24 22 57 73 17 6 28 77 58 18 13 27 22 41 69 85)
;; find max
(apply max L) → 97
ECL
MaxVal(SET OF INTEGER s) := MAX(s);
//example usage
SetVals := [4,8,16,2,1];
MaxVal(SetVals) //returns 16;
Efene
list_max = fn ([Head:Rest]) {
list_max(Rest, Head)
}
list_max = fn ([], Res) {
Res
}
fn ([Head:Rest], Max) when Head > Max {
list_max(Rest, Head)
}
fn ([_Head:Rest], Max) {
list_max(Rest, Max)
}
list_max1 = fn ([H:T]) {
lists.foldl(fn erlang.max:2, H, T)
}
@public
run = fn () {
io.format("~p~n", [list_max([9, 4, 3, 8, 5])])
io.format("~p~n", [list_max1([9, 4, 3, 8, 5])])
}
Eiffel
The GREATEST_ELEMENT class:
class
GREATEST_ELEMENT [G -> COMPARABLE]
create
make
feature {NONE} --Implementation
is_max (element: G maximum: G): BOOLEAN
do
Result := maximum >= element
end
max (list: ARRAY [G]): G
require
not_empty: not list.is_empty
do
Result := list [list.lower]
across
list as i
loop
Result := i.item.max (Result)
end
ensure
is_part_of_array: list.has (Result)
is_maximum: list.for_all (agent is_max(?, Result))
end
feature -- Initialization
make
do
end
greatest_element (a: ARRAY [G]): G
do
Result := max (a)
end
end
A test application:
class
APPLICATION
create
make
feature {NONE} -- Initialization
make
-- Run application.
local
numbers: ARRAY [INTEGER]
greatest: GREATEST_ELEMENT [INTEGER]
do
create greatest.make
numbers := <<1, 2, 3, 4, 5, 6, 7, 8, 9>>
print (greatest.greatest_element (numbers))
end
end
Ela
open list
findBy p (x::xs) = foldl (\x y | p x y -> x | else -> y) x xs
maximum = findBy (>)
maximum [1..10]
Elena
ELENA 6.x :
import extensions;
extension op
{
get Maximal()
{
auto en := cast Enumerator(self.enumerator());
object maximal := nil;
while (en.next())
{
var item := *en;
if (nil == maximal)
{
maximal := item
}
else if (maximal < item)
{
maximal := item
}
};
^ maximal
}
}
public program()
{
console.printLine(new int[]{1,2,3,4,20,10,9,8}.Maximal)
}
- Output:
20
Elixir
iex(1)> Enum.max([3,1,4,1,5,9,2,6,5,3])
9
Emacs Lisp
(defun find-maximum (items)
(let (max)
(dolist (item items)
(when (or (not max) (> item max))
(setq max item)))
max))
(find-maximum '(2 7 5)) ;=> 7
Built-in:
(max '(2 7 5)) ;=> 7
(cl-loop for el in '(2 7 5) maximize el) ;=> 7
(cl-reduce #'max '(2 7 5)) ;=> 7
(seq-max '(2 7 5)) ;=> 7
Erlang
Builtin. Using it from the Erlang shell:
>lists:max([9,4,3,8,5]).
9
ERRE
PROGRAM MAXLIST
!
! for rosettacode.org
!
! VAR L$,EL$,CH$,I%,MAX
BEGIN
PRINT(CHR$(12);) ! CLS
INPUT("Lista",L$)
L$=L$+CHR$(32)
MAX=-1.7E+38
FOR I%=1 TO LEN(L$) DO
CH$=MID$(L$,I%,1)
IF CH$<>CHR$(32) THEN ! blank is separator
EL$=EL$+CH$
ELSE
IF VAL(EL$)>MAX THEN MAX=VAL(EL$) END IF
EL$=""
END IF
END FOR
PRINT("Max list element is";MAX)
END PROGRAM
Note: The limit of this program is string variable lenght (255 chars). The advantage is no array use.
Euler
Euler allows hetrogenous lists, the real
operator converts boolean and symbol (short character strings) to a number (leaving numeric values unchanged) and the isu
operator tests whether its operand is undefined
or not.
begin new greatest; greatest <- ` formal ls; begin new L; new i; new result; label iLoop; L <- ls; result <- undefined; i <- 0; iLoop: if [ i <- i + 1 ] <= length L then begin if isu result or real L[ i ] > real result then result <- L[ i ] else 0; goto iLoop end else 0; result end '; out greatest( ( false, 99.0, -271, "b", 3, 4 ) ) end $
Euler Math Toolbox
>v=random(1,100);
>max(v)
0.997492478596
Euphoria
Applying a function to each element of an array
function aeval( sequence sArr, integer id )
for i = 1 to length( sArr ) do
sArr[ i ] = call_func( id, { sArr[ i ] } )
end for
return sArr
end function
object biggun
function biggest( object elem )
if compare(elem, biggun) > 0 then
biggun = elem
end if
return elem
end function
biggun = 0
object a
a = aeval( {1,1234,62,234,12,34,6}, routine_id("biggest") )
printf( 1, "%d\n", biggun )
sequence s
s = {"antelope", "dog", "cat", "cow", "wolf", "wolverine", "aardvark"}
biggun = "ant"
a = aeval( s, routine_id("biggest") )
printf( 1, "%s\n", {biggun} )
- Output:
1234 wolverine
More trivial example
function get_biggest(sequence s)
object biggun
biggun = s[1]
for i = 2 to length(s) do
if compare(s[i], biggun) > 0 then
biggun = s[i]
end if
end for
return biggun
end function
constant numbers = {1,1234,62,234,12,34,6}
printf(1,"%d\n",get_biggest(numbers))
constant animals = {"ant", "antelope", "dog", "cat", "cow", "wolf", "wolverine", "aardvark"}
printf(1,"%s\n",{get_biggest(animals)})
- Output:
1234 wolverine
Excel
Use the function MAX
=MAX(3;2;1;4;5;23;1;2)
- Output:
23
F#
I generate a list of 10 random numbers at runtime then use F#'s built in function to find the maximum value of the list.
let N = System.Random()
let G = List.init 10 (fun _->N.Next())
List.iter (printf "%d ") G
printfn "\nMax value of list is %d" (List.max G)
- Output:
401566008 1378437959 1806806326 2010005455 1973773308 1216833747 268836584 1963610340 2120237482 1412806752 Max value of list is 2120237482
Factor
The following word is in factor's standard library.
: supremum ( seq -- elt ) [ ] [ max ] map-reduce ;
Fancy
[1,-2,2,4,6,-4,-1,5] max println # => 6
Fantom
Has a built-in method to get maximum from a list.
class Greatest
{
public static Void main ()
{
Int[] values := [1,2,3,4,5,6,7,8,9]
Int greatest := values.max
echo (greatest)
}
}
Forth
: array-max ( addr len -- max )
dup 0= if nip exit then
over @ rot cell+ rot 1-
cells bounds ?do i @ max cell +loop ;
: stack-max ( n ... m count -- max ) 1 ?do max loop ;
Fortran
The intrinsic function maxval returns the maximum value of the elements in an integer or real array:
program test_maxval
integer,dimension(5),parameter :: x = [10,100,7,1,2]
real,dimension(5),parameter :: y = [5.0,60.0,1.0,678.0,0.0]
write(*,'(I5)') maxval(x)
write(*,'(F5.1)') maxval(y)
end program test_maxval
- Output:
100 678.0
The intrinsic function max accepts any number of arguments. The type of these arguments can be integer, real, character, string of characters or arrays of these.
program test_max
implicit none
write (*, '(i0)') &
& max (1, 2, 3)
write (*, '(f3.1)') &
& max (1.0, 2.0, 3.0)
write (*, '(a)') &
& max ('a', 'b', 'c')
write (*, '(a)') &
& max ('abc', 'bca', 'cab')
write (*, '(i0, 2 (1x, i0))') &
& max ([1, 8, 6], [7, 5, 3], [4, 2, 9])
write (*, '(f3.1, 2 (1x, f3.1))') &
& max ([1.0, 8.0, 6.0], [7.0, 5.0, 3.0], [4.0, 2.0, 9.0])
write (*, '(a, 2 (1x, a))') &
& max (['a', 'h', 'f'], ['g', 'e', 'c'], ['d', 'b', 'i'])
write (*, '(a, 2 (1x, a))') &
& max (['abc', 'hig', 'fde'], ['ghi', 'efd', 'cab'], ['def', 'bca', 'igh'])
end program test_max
- Output:
3 3.0 c cab 7 8 9 7.0 8.0 9.0 g h i ghi hig igh
FreeBASIC
' FB 1.05.0 Win64
Function MaxElement(a() As Double) As Double
Dim max As Double = a(LBound(a))
For i As Integer = LBound(a) + 1 To UBound(a)
If a(i) > max Then max = a(i)
Next
Return max
End Function
Dim As Integer i, n
Input "How many values are to be input "; n
If n < 1 Then End
Dim a(1 To n) As Double
For i = 1 To n
Print " Value"; i; " : ";
Input "", a(i)
Next
Dim max As Double = MaxElement(a())
Print
Print "The greatest value is"; max
Print
Print "Press any key to quit"
Sleep
Example of use :
- Output:
How many values are to be input ? 4 Value 1 : 70.5 Value 2 : 23.67 Value 3 : 150.2 Value 4 : 145 The greatest value is 150.2
Frink
println[max[[1,2,3,5,10,20]]]
FunL
Using the pre-defined function max
:
println( max([1,2,3,-1,0]) )
- Output:
3
It can be implemented as:
def
maximum( xs ) =
def
max( a, b ) = if a <= b then b else a
foldl( f, z, [] ) = z
foldl( f, z, x:xs ) = foldl( f, f(z, x), xs )
foldl1( f, x:xs ) = foldl( f, x, xs )
foldl1( _, [] ) = error( "foldl1: empty list" )
foldl1( max, xs )
Futhark
This parallel formulation exploits the fact that negative infinity constitutes a neutral element for the maximum operator.
let main (xs: []f64) = reduce f64.max (-f64.inf) xs
FutureBasic
The function fn GreatestElementInList() will sort and return the greatest element of any list that supports the @"compare:" operator.
include "NSLog.incl"
local fn GreatestElementInList( list as CFArrayRef ) as CFTypeRef
CfArrayRef array = fn ArraySortedArrayUsingSelector( list, @"compare:" )
CFTypeRef result = fn ArrayLastObject( array )
end fn = result
CFArrayRef array
array = @[@1, @-2, @10, @5.0, @10.5]
NSLog( @"%@", fn GreatestElementInList( array ) )
// Greatest element will be letter with highest ASCII value
array = @[@"A", @"b", @"C", @"d", @"E"]
NSLog( @"%@", fn GreatestElementInList( array ) )
array = @[@"ant", @"antelope", @"dog", @"cat", @"cow", @"wolf", @"wolverine", @"aardvark"]
NSLog( @"%@", fn GreatestElementInList( array ) )
array = @[@"abc", @"123", @"zyx", @"def"]
NSLog( @"%@", fn GreatestElementInList( array ) )
HandleEvents
- Output:
10.5 d wolverine zyx
Fōrmulæ
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
Programs in Fōrmulæ are created/edited online in its website.
In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.
Solution
Fōrmulæ provides a built-in expression "Max" that reduces to the maximum element of a given list:
Case 1. With numbers
Case 2. With strings
Case 3. With time expressions
GW-BASIC
10 INPUT "How many items? ", N%
20 DIM ARR(N%)
30 FOR I% = 0 TO N%-1
40 PRINT "Value of item #";I%
50 INPUT ARR(I%)
60 NEXT I%
70 CHAMP = ARR(0) : INDEX = 0
80 FOR I% = 1 TO N%-1
90 IF ARR(I%)>CHAMP THEN CHAMP=ARR(I%):INDEX=I%
100 NEXT I%
110 PRINT "The maximum value was ";CHAMP;" at index ";INDEX;"."
120 END
GAP
# Built-in
L := List([1 .. 100], n -> Random(1, 10));
MaximumList(L);
# 10
Go
- Library
-
package main import ( "fmt" "github.com/gonum/floats" ) func main() { fmt.Println(floats.Max([]float64{63, 70, 37, 34, 83, 27, 19, 97, 9, 17})) // prt 97 fmt.Println(floats.Min([]float64{63, 70, 37, 34, 83, 27, 19, 97, 9, 17})) // prt 9 }
package main import "fmt" func main() { x := []int{ 48, 96, 86, 68, 57, 82, 63, 70, 37, 34, 83, 27, 19, 97, 9, 17, } smallest, biggest := x[0], x[0] for _, v := range x { if v > biggest { biggest = v } if v < smallest { smallest = v } } fmt.Println("The biggest number is ", biggest) // prt 97 fmt.Println("The smallest number is ", smallest) // prt 9 }
- List
The task title says list. This solution uses a Go slice as a list.
package main
import (
"fmt"
"math/rand"
"time"
)
// function, per task description
func largest(a []int) (lg int, ok bool) {
if len(a) == 0 {
return
}
lg = a[0]
for _, e := range a[1:] {
if e > lg {
lg = e
}
}
return lg, true
}
func main() {
// random size slice
rand.Seed(time.Now().UnixNano())
a := make([]int, rand.Intn(11))
for i := range a {
a[i] = rand.Intn(101) - 100 // fill with random numbers
}
fmt.Println(a)
lg, ok := largest(a)
if ok {
fmt.Println(lg)
} else {
fmt.Println("empty list. no maximum.")
}
}
- Set
The task description says set. This solution uses a Go map as a set.
package main
import (
"fmt"
"math"
"math/rand"
"time"
)
// Function, per task description. Interesting with the float64 type because
// of the NaN value. NaNs do not compare to other values, so the result of
// a "largest" function on a set containing a NaN might be open to
// interpretation. The solution provided here is to return the largest
// of the non-NaNs, and also return a bool indicating the presense of a NaN.
func largest(s map[float64]bool) (lg float64, ok, nan bool) {
if len(s) == 0 {
return
}
for e := range s {
switch {
case math.IsNaN(e):
nan = true
case !ok || e > lg:
lg = e
ok = true
}
}
return
}
func main() {
rand.Seed(time.Now().UnixNano())
// taking "set" literally from task description
s := map[float64]bool{}
// pick number of elements to add to set
n := rand.Intn(11)
// add random numbers, also throw in an occasional NaN or Inf.
for i := 0; i < n; i++ {
switch rand.Intn(10) {
case 0:
s[math.NaN()] = true
case 1:
s[math.Inf(1)] = true
default:
s[rand.ExpFloat64()] = true
}
}
fmt.Print("s:")
for e := range s {
fmt.Print(" ", e)
}
fmt.Println()
switch lg, ok, nan := largest(s); {
case ok && !nan:
fmt.Println("largest:", lg)
case ok:
fmt.Println("largest:", lg, "(NaN present in data)")
case nan:
fmt.Println("no largest, all data NaN")
default:
fmt.Println("no largest, empty set")
}
}
Golfscript
{$-1=}:max;
[1 4 8 42 6 3]max # Example usage
Groovy
println ([2,4,0,3,1,2,-12].max())
- Output:
4
Haskell
The built-in Haskell function maximum returns a maximum based on default comparison between members of an ordered type.
my_max = maximum
It can alternately be defined as a "fold" on the built-in two-argument max function.
my_max = foldl1 max
More generally, maximum is a special case of maximumBy, which allows us to define or supply our own comparison function, and define the particular type of maximum that we need:
import Data.List (maximumBy)
import Data.Ord (comparing)
wds :: [String]
wds = ["alpha", "beta", "gamma", "delta", "epsilon", "zeta"]
main :: IO ()
main = print $ maximumBy (comparing length) wds
As a fold, maximumBy could be defined along the lines of:
maximumBy
:: Foldable t
=> (a -> a -> Ordering) -> t a -> a
maximumBy cmp =
let max_ x y =
case cmp x y of
GT -> x
_ -> y
in foldr1 max_
hexiscript
fun greatest a
let l len a
let max a[0]
for let i 1; i < l; i++
if max < a[i]
let max a[i]
endif
endfor
return max
endfun
HicEst
max_value = MAX( -123, 234.56, 345.678, -456E3, -455) ! built-in function MAX(...)
! or for an array:
max_value = MAX( array_of_values )
! or to find a maximum value in a file named filename:
CHARACTER List, filename='Greatest element of a list.hic' ! filename contains this script
REAL values(1) ! unknown number of values, allocate more below
OPEN(FIle=filename, BINary, LENgth=len)
ALLOCATE(values, len/2) ! number of values <= half byte count of file
! read all values, returns item count in values_found:
READ(FIle=filename, ItemS=values_found, CLoSe=1) values ! no Format needed for plain text numbers
max_value = MAX(values)
! write values found in filename and result to spreadsheet type dialog window:
DLG(Text=values, Text=max_value, TItle=values_found)
WRITE(ClipBoard, Name) max_value, values_found, values ! pasted to line below
! max_value=345.678; values_found=30; values(1)=-123; values(2)=234.56; values(3)=345.678; values(4)=-456E3; values(5)=-455; values(6)=1; values(7)=2; values(8)=1; values(9)=0; values(10)=0; ...truncated
END
Hoon
:- %say
|= [^ [a=(list ,@) ~] ~]
:- %noun
(snag 0 (sort a gte))
Usage: Add to a file gen/max.hoon
> +max [1 2 3 ~] 3
i
concept largest(l) {
large = l[0]
for element in l
if element > large
large = element
end
end
return large
}
software {
print(largest([23, 1313, 21, 35757, 4, 434, 232, 2, 2342]))
}
Icon and Unicon
Insitux
max
is a built-in operation.
(max 1 2 3 4)
;or
(... max [1 2 3 4])
- Output:
4
J
Solution:
>./
Example:
>./ 1 2 3 2 1
3
>./'' NB. Maximum value of an empty list = identity element (or neutral) of max = -∞
__
(J's lists know how long they are.)
Janet
(def elems @[3 1 3 2])
# Use extreme function from stdlib with > function.
(extreme > elems)
# Unpack list as arguments to max function.
(max ;elems)
Java
int max(int[] values) {
int max = values[0];
for (int value : values)
if (max < value) max = value;
return max;
}
The first function works with arrays of floats. Replace with arrays of double, int, or other primitive data type.
public static float max(float[] values) throws NoSuchElementException {
if (values.length == 0)
throw new NoSuchElementException();
float themax = values[0];
for (int idx = 1; idx < values.length; ++idx) {
if (values[idx] > themax)
themax = values[idx];
}
return themax;
}
Optionally, if it is OK to rearrange the contents of the original array:
public static float max(float[] values) throws NoSuchElementException {
if (values.length == 0)
throw new NoSuchElementException();
Arrays.sort(values);//sorts the values in ascending order
return values[values.length-1];
}
The following functions work with Lists or arrays of reference types, respectively. Note that the type is required to implement Comparable, to ensure we can compare them. For Lists, there is a utility method Collections.max() that already does this. For arrays, we can just use the Arrays.asList() wrapper to wrap it into a list and then use the function for lists.
import java.util.List;
import java.util.Collections;
import java.util.Arrays;
public static <T extends Comparable<? super T>> T max(List<T> values) {
return Collections.max(values);
}
public static <T extends Comparable<? super T>> T max(T[] values) {
return Collections.max(Arrays.asList(values));
}
JavaScript
ES3-5
Math.max.apply(null, [ 0, 1, 2, 5, 4 ]); // 5
ES 5 maxima beyond simple numeric data types
Math.max() serves well with simple numeric types, but for less restricted use we can write a generic maximumBy function which returns the maximum value from an array containing a series of any consistent data type, and which takes a type-specific comparison function as an argument.
(function () {
// (a -> a -> Ordering) -> [a] -> a
function maximumBy(f, xs) {
return xs.reduce(function (a, x) {
return a === undefined ? x : (
f(x, a) > 0 ? x : a
);
}, undefined);
}
// COMPARISON FUNCTIONS FOR SPECIFIC DATA TYPES
//Ordering: (LT|EQ|GT)
// GT: 1 (or other positive n)
// EQ: 0
// LT: -1 (or other negative n)
function wordSortFirst(a, b) {
return a < b ? 1 : (a > b ? -1 : 0)
}
function wordSortLast(a, b) {
return a < b ? -1 : (a > b ? 1 : 0)
}
function wordLongest(a, b) {
return a.length - b.length;
}
function cityPopulationMost(a, b) {
return a.population - b.population;
}
function cityPopulationLeast(a, b) {
return b.population - a.population;
}
function cityNameSortFirst(a, b) {
var strA = a.name,
strB = b.name;
return strA < strB ? 1 : (strA > strB ? -1 : 0);
}
function cityNameSortLast(a, b) {
var strA = a.name,
strB = b.name;
return strA < strB ? -1 : (strA > strB ? 1 : 0);
}
var lstWords = [
'alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta', 'eta',
'theta', 'iota', 'kappa', 'lambda'
];
var lstCities = [
{
name: 'Shanghai',
population: 24.15
}, {
name: 'Karachi',
population: 23.5
}, {
name: 'Beijing',
population: 21.5
}, {
name: 'Tianjin',
population: 14.7
}, {
name: 'Istanbul',
population: 14.4
}, , {
name: 'Lagos',
population: 13.4
}, , {
name: 'Tokyo',
population: 13.3
}
];
return [
maximumBy(wordSortFirst, lstWords),
maximumBy(wordSortLast, lstWords),
maximumBy(wordLongest, lstWords),
maximumBy(cityPopulationMost, lstCities),
maximumBy(cityPopulationLeast, lstCities),
maximumBy(cityNameSortFirst, lstCities),
maximumBy(cityNameSortLast, lstCities)
]
})();
- Output:
[
"alpha",
"zeta",
"epsilon",
{
"name": "Shanghai",
"population": 24.15
},
{
"name": "Tokyo",
"population": 13.3
},
{
"name": "Beijing",
"population": 21.5
},
{
"name": "Tokyo",
"population": 13.3
}
]
ES6
For, numbers, a method of the standard Math object:
Math.max(...[ 0, 1, 2, 5, 4 ]); // 5
and for orderings defined over other datatypes:
(() => {
"use strict";
// ----------- GREATEST ELEMENT OF A LIST ------------
// maximumByMay :: (a -> a -> Ordering) ->
// [a] -> Maybe a
const maximumByMay = f =>
// Nothing, if the list is empty,
// or just the maximum value when compared
// in terms of f.
xs => Boolean(xs.length) ? (
Just(xs.slice(1).reduce(
(a, x) => 0 < f(a)(x) ? (
a
) : x,
xs[0]
))
) : Nothing();
// ---------------------- TEST -----------------------
const main = () =>
JSON.stringify(
catMaybes([
maximumByMay(
comparing(x => x.length)
)([
"alpha", "beta", "gamma", "delta",
"epsilon", "zeta", "eta"
]),
maximumByMay(comparing(x => x.length))([]),
maximumByMay(comparing(x => x.n))([{
k: "Bejing",
n: 21.5
}, {
k: "Delhi",
n: 16.7
}, {
k: "Karachi",
n: 23.5
}, {
k: "Lagos",
n: 16.0
}, {
k: "Shanghai",
n: 24.3
}, {
k: "Tokyo",
n: 13.2
}])
]),
null, 2
);
// --------------------- GENERIC ---------------------
// Just :: a -> Maybe a
const Just = x => ({
type: "Maybe",
Nothing: false,
Just: x
});
// Nothing :: Maybe a
const Nothing = () => ({
type: "Maybe",
Nothing: true
});
// catMaybes :: [Maybe a] -> [a]
const catMaybes = mbs =>
mbs.flatMap(
m => m.Nothing ? (
[]
) : [m.Just]
);
// comparing :: (a -> b) -> (a -> a -> Ordering)
const comparing = f =>
x => y => {
const
a = f(x),
b = f(y);
return a < b ? -1 : (a > b ? 1 : 0);
};
// MAIN ---
return main();
})();
- Output:
[ "epsilon", { "k": "Shanghai", "n": 24.3 } ]
Joy
DEFINE maximum == unswons [max] fold.
jq
jq defines a total ordering of all JSON entities, and the max filter can accordingly be used on any JSON array:
[1, 3, 1.0] | max # => 3
[ {"a": 1}, {"a":3}, {"a":1.0}] | max # => {"a": 3}
Warning: both "[null]|max" and "[]|max" yield null.
Given a stream, s, of JSON values, the following filter will emit null if the stream is empty, or the maximum value otherwise:
reduce s as $x (null; if $x > . then $x else . end)
Julia
Using the built-in maximum
function:
julia> maximum([1,3,3,7])
7
julia> maximum([pi,e+2/5,cos(6)/5,sqrt(91/10)])
3.141592653589793
julia> maximum([1,6,Inf])
Inf
julia> maximum(Float64[])
maximum: argument is empty
at In[138]:1
in maximum at abstractarray.jl:1591
(Note that it throws an exception on an empty array.)
K
|/ 6 1 7 4
7
Klingphix
include ..\Utilitys.tlhy
( "1" "1234" "62" "234" "12" "34" "6" )
dup "Alphabetic order: " print lmax ?
:f tonum ;
@f map
"Numeric order: " print lmax ?
" " input
Klong
list::[ 1.0 2.3 1.1 5.0 3 2.8 2.01 3.14159 77 ]
|/list
|/ [ 1.0 2.3 1.1 5.0 3 2.8 2.01 3.14159 66 ]
|/ 1.0,2.3,1.1,5.0,3,2.8,2.01,3.14159,55
- Output:
77 66 55
Kotlin
Kotlin has a max() function in its standard library that applies to collection of Iterable :
fun main() {
listOf(1.0, 3.5, -1.1).max().also { println(it) } // 3.5
listOf(1, 3, -1).max().also { println(it) } // 3
setOf(1, 3, -1).max().also { println(it) } // 3
}
Lambdatalk
1) using the builtin primitive
{max 556 1 7344 4 7 52 22 55 88 122 55 99 1222 578}
-> 7344
2) buidling a function
{def my-max
{def max-h
{lambda {:l :greatest}
{if {A.empty? :l}
then :greatest
else {max-h {A.rest :l}
{if {> {A.first :l} :greatest}
then {A.first :l}
else :greatest}}}}}
{lambda {:l}
{if {A.empty? :l} then empty else {max-h :l {A.first :l}}}}}
-> my-max
{my-max {A.new 556 1 7344 4 7 52 22 55 88 122 55 99 1222 578}}
-> 7344
Lasso
define greatest(a::array) => {
return (#a->sort&)->last
}
local(x = array(556,1,7344,4,7,52,22,55,88,122,55,99,1222,578))
greatest(#x)
- Output:
7344
LDPL
data:
values is number list
n is number
procedure:
sub max
parameters:
x is number list
result is number
local data:
i is number
procedure:
store x:0 in result
for each i in values do
if i is greater than result then
store i in result
end if
repeat
end sub
create statement "get maximum of list $ in $" executing max
# Now let's use the sub-procedure.
push 1 to values
push 11 to values
push 5 to values
push 33 to values
push 99 to values
push 13 to values
push 37 to values
push 50 to values
get maximum of list values in n
display "The maximum is " n lf
- Output:
The maximum is 99
LFE
Builtin. Using it from the LFE shell:
>(: lists max '[9 4 3 8 5])
9
Liberty BASIC
aList$= "1 15 -5 6 39 1.5 14"
maxVal = val(word$(aList$, 1))
token$ = "?"
while token$ <> ""
index = index + 1
token$ = word$(aList$, index)
aVal = val(token$)
if aVal > maxVal then maxVal = aVal
wend
print "maxVal = ";maxVal
Lingo
l = [1,7,5]
put max(l)
-- 7
LiveCode
Max is built-in
put max(2,3,6,7,4,1)
Result: 7
To be fair to the exercise, an alternative implementation could be
function max2 lst
local maxNum
put item 1 of lst into maxNum
repeat with n = 1 to the number of items of lst
if item n of lst > maxNum then
put item n of lst into maxNum
end if
end repeat
return maxNum
end max2
on mouseUp
answer max2("1,2,5,6,7,4,3,2")
end mouseUp
Logo
If the template is, like SUM, the name of a procedure that is capable of accepting arbitrarily many inputs, it is more efficient to use APPLY instead of REDUCE. The latter is good for associative procedures that have been written to accept exactly two inputs:
to max :a :b
output ifelse :a > :b [:a] [:b]
end
print reduce "max [...]
Alternatively, REDUCE can be used to write MAX as a procedure that accepts any number of inputs, as SUM does:
to max [:inputs] 2
if emptyp :inputs ~
[(throw "error [not enough inputs to max])]
output reduce [ifelse ?1 > ?2 [?1] [?2]] :inputs
end
==Logo ==
to bigger :a :b
output ifelse [greater? :a :b] [:a] [:b]
end
to max :lst
output reduce "bigger :lst
end
Logtalk
max([X| Xs], Max) :-
max(Xs, X, Max).
max([], Max, Max).
max([X| Xs], Aux, Max) :-
( X @> Aux ->
max(Xs, X, Max)
; max(Xs, Aux, Max)
).
Lua
-- Table to store values
local values = {}
-- Read in the first number from stdin
local new_val = io.read"*n"
-- Append all numbers passed in
-- until there are no more numbers (io.read'*n' = nil)
while new_val do
values[#values+1] = new_val
new_val = io.read"*n"
end
-- Print the max
print(math.max(unpack(values)))
M2000 Interpreter
Module TestThis {
Print "Search a tuple type list (is an array also)"
A=(,)
For i=1 to Random(1,10)
Append A, (Random(1,100),)
Next
Print Len(A)
Print A
Print A#max()
Print "Search an array"
B=lambda->Random(1,100)
Rem Dim A(1 to Random(1,10))<<B()
Dim A(1 to Random(1,10))<<lambda->{=Random(1,100)}()
Print Len(A())
Print A()
Print A()#max()
\\ #max() skip non numeric values
Rem Print (1,"100",3)#max()=3
Print "Search an inventory list"
Inventory C
for i=1 to Random(1,10)
do
key=random(10000)
until not exist(c, key)
\\ we can put a number as string
if random(1,2)=1 then Append c, key:=B() else Append c, key:=str$(B())
Next
\\ if inventory item is string with a number work fine
Function MaxItem(a) {
k=each(a,2)
val=a(0!)
while k
\\ using stack of values
\\ over -equal to over 1 - copy value from 1 to top, means double the top value
\\ number - pop top value
\\ drop -equal to drop 1 : drop top value
Push a(k^!): Over : If Number>val then Read Val else drop
Rem If a(k^!)>Val Then Val=a(k^!)
end while
=val
}
Print Len(C)
Print C
Print MaxItem(C)
Print "Search a stack object"
\\ a stack object is the same as the stack of values
\\ which always is present
D=stack
I=0
J=Random(1,10)
\\ Stack stackobjext {}
\\ hide current stack and attach the D stack
Stack D {
Push B() : I++ : IF I>J Else Loop
}
\\ if stack item isn't numeric we get a run time error
Function MaxItemStack(a) {
Stack a {env$=envelope$()}
if replace$("N","", env$)<>"" then error "only numbers allowed"
k=each(a,2)
val=Stackitem(a,1)
while k
If Stackitem(k)>val then Val=stackitem(k)
end while
=val
}
Print Len(D)
Print D
Print MaxItemStack(D)
}
TestThis
Maple
This is a built-in, polymorphic procedure in Maple.
> max( { 1, 2, Pi, exp(1) } ); # set
Pi
> max( [ 1, 2, Pi, exp(1) ] ); # list
Pi
> max( 1, 2, Pi, exp(1) ); # sequence
Pi
> max( Array( [ 1, 2, Pi, exp(1) ] ) ); # Array
Pi
For numeric data in (multi-dimensional) rtables, a particularly flexible and powerful method for finding the maximum (and many other things) is the use of "rtable_scanblock". The maximum of an Array is a built-in rtable_scanblock operation and can be found as follows.
> A := Array([1,2,4/5,3,11]): rtable_scanblock( A, [rtable_dims(A)], Maximum );
11
Mathematica / Wolfram Language
Input:
Max[1, 3, 3, 7]
Max[Pi,E+2/5,17 Cos[6]/5,Sqrt[91/10]]
Max[1,6,Infinity]
Max[]
- Output:
7 17 Cos[6]/5 Infinity -Infinity
Note that Max returns minus infinity if supplied with no arguments; as it should:
Max[Max[],Max[a,b,c]]
Max[Max[a],Max[b,c]]
Max[Max[a,b],Max[c]]
Max[Max[a,b,c],Max[]]
should all give the same results, therefore max[] should give -Infinity. If it WOULD give 0 strange things can happen:
Max[Max[], Max[-4, -3]]
WOULD give 0 instead of -3
MATLAB
function [maxValue] = findmax(setOfValues)
maxValue = max(setOfValues);
Maxima
u : makelist(random(1000), 50)$
/* Three solutions */
lreduce(max, u);
apply(max, u);
lmax(u);
MAXScript
MAXScript has a built-in function called amax(), which will return the maximum of an array or the values supplied to it. The following custom function will return the maximum of the array supplied to it, or 'undefined' if an empty array is supplied.
fn MaxValue AnArray =
(
if AnArray.count != 0 then
(
local maxVal = 0
for i in AnArray do if i > maxVal then maxVal = i
maxVal
)
else undefined
)
Metafont
The max
macro (in the base set of macro for Metafont) accepts any number of arguments, and accepts both numerics (numbers), pairs (bidimensional vectors), and strings (not mixed).
show max(4,5,20,1);
show max((12,3), (10,10), (25,5));
show max("hello", "world", "Hello World");
min
(() ('> 'pop 'nip if) map-reduce) ^max
(5 3 2 7 4) max puts!
MiniScript
There is a list.max function in the listUtil module, but if you're working in an environment without this module or just want to write it yourself, you might do it as follows.
list.max = function()
if not self then return null
result = self[0]
for item in self
if item > result then result = item
end for
return result
end function
print [47, 11, 42, 102, 13].max
МК-61/52
П0 С/П x=0 07 ИП0 x<0 00 max БП 00
or
П0 ИП0 С/П - x<0 01 Вx П0 БП 01
Modula-3
Modula-3 provides a builtin MAX
function, but it only works on two elements (or enumerations) but not arrays or sets.
We provide a generic Maximum implementation:
GENERIC INTERFACE Maximum(Elem);
EXCEPTION Empty;
PROCEDURE Max(READONLY a: ARRAY OF Elem.T): Elem.T RAISES {Empty};
END Maximum.
GENERIC MODULE Maximum(Elem);
PROCEDURE Max(READONLY arr: ARRAY OF Elem.T): Elem.T RAISES {Empty} =
VAR max := FIRST(Elem.T);
BEGIN
IF NUMBER(arr) = 0 THEN
RAISE Empty;
END;
FOR i := FIRST(arr) TO LAST(arr) DO
IF arr[i] > max THEN
max := arr[i];
END;
END;
RETURN max;
END Max;
BEGIN
END Maximum.
Elem
can be instantiated to any type (any type that can be compared with the '>' function). For convenience Modula-3 provides interfaces/modules for the built in types, like Integer, Real, LongReal, etc, which contain type definitions as well as properties specific to the type.
To make a generic interface/module for a specific type, you must instantiate it:
INTERFACE RealMax = Maximum(Real) END RealMax.
MODULE RealMax = Maximum(Real) END RealMax.
Now we can import RealMax
into our source and use the Max
function:
MODULE Main;
IMPORT RealMax, IO, Fmt;
VAR realarr := ARRAY [1..5] OF REAL {1.1, 1.0, 0.0, 2.4, 3.3};
BEGIN
IO.Put(Fmt.Real(RealMax.Max(realarr)) & "\n");
END Main.
MontiLang
MontiLang has a builtin statement MAX
which finds the maximum of the top two items on the stack. By looping through an array and pushing to the stack, the largest item in an array can be found.
2 5 3 12 9 9 56 2 ARR
LEN VAR l .
0 VAR i .
FOR l
GET i SWAP
i 1 + VAR i .
ENDFOR .
STKLEN 1 - VAR st .
FOR st
MAX
ENDFOR PRINT
Another way to do it.
2 5 3 12 9 9 56 2 ARR
print
LEN VAR l .
0 VAR i .
0
FOR l
swap
GET i rot max
i 1 + VAR i .
ENDFOR
|Greatest number in the list: | out . print
|Press ENTER to exit | input
clear
MUMPS
MV(A,U)
;A is a list of values separated by the string U
NEW MAX,T,I
FOR I=1:1 SET T=$PIECE(A,U,I) QUIT:T="" S MAX=$SELECT(($DATA(MAX)=0):T,(MAX<T):T,(MAX>=T):MAX)
QUIT MAX
Usage:
USER>SET V="," USER>SET B="-1,-1000,1000,2.3E5,8A,""A"",F" USER>W $$MV^ROSETTA(B,V) 2.3E5
Nanoquery
def max(list)
if len(list) = 0
return null
end
largest = list[0]
for val in list
if val > largest
largest = val
end
end
return largest
end
Neko
/**
greatest element from a list (Neko Array)
Tectonics:
nekoc greatest-element.neko
neko greatest-element
*/
var greatest = function(list) {
var max, element;
var pos = 1;
if $asize(list) > 0 max = list[0];
while pos < $asize(list) {
element = list[pos];
if max < element max = element;
pos += 1;
}
return max;
}
$print(greatest($array(5, 1, 3, 5)), "\n");
$print(greatest($array("abc", "123", "zyx", "def")), "\n");
- Output:
prompt$ nekoc greatest-element.neko prompt$ neko ./greatest-element.n 5 zyx
Nemerle
using System;
using Nemerle.Collections;
using System.Linq;
using System.Console;
module SeqMax
{
SeqMax[T, U] (this seq : T) : U
where T : Seq[U]
where U : IComparable
{
$[s | s in seq].Fold(seq.First(), (x, y) => {if (x.CompareTo(y) > 0) x else y})
}
Main() : void
{
def numbers = [1, 12, 3, -5, 6, 23];
def letters = ['s', 'p', 'a', 'm'];
// using SeqMax() method (as task says to "create a function")
WriteLine($"numbers.SeqMax() = $(numbers.SeqMax())");
WriteLine($"letters.SeqMax() = $(letters.SeqMax())");
// using the already available Max() method
WriteLine($"numbers.Max() = $(numbers.Max())");
WriteLine($"letters.Max() = $(letters.Max())")
}
}
- Output:
numbers.SeqMax() = 23 letters.SeqMax() = s numbers.Max() = 23 letters.Max() = s
NetRexx
/* NetRexx */
options replace format comments java crossref savelog symbols binary
rn = Random()
maxElmts = 100
dlist = double[maxElmts]
rlist = Rexx[maxElmts]
loop r_ = 0 to maxElmts - 1
nr = rn.nextGaussian * 100.0
dlist[r_] = nr
rlist[r_] = Rexx(nr)
end r_
say 'Max double:' Rexx(getMax(dlist)).format(4, 9)
say 'Max Rexx:' getMax(rlist).format(4, 9)
return
method getMax(dlist = double[]) public static binary returns double
dmax = Double.MIN_VALUE
loop n_ = 0 to dlist.length - 1
if dlist[n_] > dmax then dmax = dlist[n_]
end n_
return dmax
method getMax(dlist = Rexx[]) public static binary returns Rexx
dmax = Rexx(Double.MIN_VALUE)
loop n_ = 0 to dlist.length - 1
dmax = dlist[n_].max(dmax)
end n_
return dmax
- Output:
Max double: 274.457568703 Max Rexx: 274.457568703
NewLISP
(max 1 2 3 5 2 3 4)
(apply max '(1 2 3 5 2 3 4)) ; apply to list
; Added by Nehal-Singhal 2018-05-29
Nial
The behavior of multi-dimensional arrays is like J
max 1 2 3 4
=4
Nim
echo max([2,3,4,5,6,1])
- Output:
6
Nu
By using math max
:
[1 5 3 11 7] | math max
- Output:
11
Oberon-2
MODULE GreatestElement1;
IMPORT
ADT:ArrayList,
Object:Boxed,
Out;
VAR
a: ArrayList.ArrayList(Boxed.LongInt);
max: Boxed.LongInt;
PROCEDURE Max(al: ArrayList.ArrayList(Boxed.LongInt)): Boxed.LongInt;
VAR
i: LONGINT;
item, max: Boxed.LongInt;
BEGIN
max := NEW(Boxed.LongInt,MIN(LONGINT));
i := 0;
WHILE (i < al.size) DO
item := al.Get(i);
IF item.value > max.value THEN max := item END;
INC(i)
END;
RETURN max
END Max;
BEGIN
a := NEW(ArrayList.ArrayList(Boxed.LongInt),5);
a.Append(NEW(Boxed.LongInt,10));
a.Append(NEW(Boxed.LongInt,32));
a.Append(NEW(Boxed.LongInt,4));
a.Append(NEW(Boxed.LongInt,43));
a.Append(NEW(Boxed.LongInt,9));
max := Max(a);
Out.String("Max: ");Out.LongInt(max.value,4);Out.Ln
END GreatestElement1.
Simple version
MODULE GreatestElement2;
IMPORT
Out;
VAR
a: ARRAY 10 OF LONGINT;
PROCEDURE Max(a: ARRAY OF LONGINT): LONGINT;
VAR
i, max: LONGINT;
BEGIN
max := MIN(LONGINT);
FOR i := 0 TO LEN(a) - 1 DO
IF a[i] > max THEN max := a[i] END;
END;
RETURN max
END Max;
BEGIN
a[0] := 10;
a[1] := 32;
a[2] := 4;
a[3] := 43;
a[4] := 9;
Out.String("Max: ");Out.LongInt(Max(a),4);Out.Ln
END GreatestElement2.
- Output:
(in both programs)
Max: 43
Objeck
The language has a "Max" method for vectors.
values := IntVector->New([4, 1, 42, 5]);
values->Max()->PrintLine();
Objective-C
This code "extends" (through Objective-C categories) the NSArray adding the method
maximumValue
; this one iterates over the objects of the collection
calling the method compare
, if it exists for the object of the
collection. Since normally comparing makes sense between numbers, the code
also check if the objects being compared are of "kind" NSNumber. If one eliminates
this check (substituting it maybe with one that checks if the two object are of
the same "kind"), the code is able to get a maximum value for any objects for
which make sense a compare method (e.g. strings), that must be implemented.
If there's no a known way of comparing two objects of the collection (or if the objects are not "NSNumber"), the the method return nil (the void object).
#import <Foundation/Foundation.h>
@interface NSArray (WithMaximum)
- (id)maximumValue;
@end
@implementation NSArray (WithMaximum)
- (id)maximumValue
{
if ( [self count] == 0 ) return nil;
id maybeMax = self[0];
for ( id el in self ) {
if ( [maybeMax respondsToSelector: @selector(compare:)] &&
[el respondsToSelector: @selector(compare:)] &&
[el isKindOfClass: [NSNumber class]] &&
[maybeMax isKindOfClass: [NSNumber class]] ) {
if ( [maybeMax compare: el] == NSOrderedAscending )
maybeMax = el;
} else { return nil; }
}
return maybeMax;
}
@end
This example mixes integers with a double value, just to show that everything is fine until they are NSNumber.
int main()
{
@autoreleasepool {
NSArray *collection = @[@1, @2, @10, @5, @10.5];
NSLog(@"%@", [collection maximumValue]);
}
return 0;
}
OCaml
let my_max = function
[] -> invalid_arg "empty list"
| x::xs -> List.fold_left max x xs
# my_max [4;3;5;9;2;3] ;; - : int = 9
Octave
Octave's max
accepts a vector (and can return also the index of the maximum value in the vector)
m = max( [1,2,3,20,10,9,8] ); % m = 20
[m, im] = max( [1,2,3,20,10,9,8] ); % im = 4
Oforth
[1, 2.3, 5.6, 1, 3, 4 ] reduce(#max)
Ol
Basics:
; builtin function
(max 1 2 3 4 5) ; 5
(define x '(1 2 3 4 5))
; using to numbers list
(apply max x) ; 5
; using list reducing
(fold max (car x) x) ; 5
; manual lambda-comparator
(print (fold (lambda (a b)
(if (less? a b) b a))
(car x) x)) ; 5
ooRexx
version
-- routine that will work with any ordered collection or sets and bags containing numbers.
::routine listMax
use arg list
items list~makearray -- since we're dealing with different collection types, reduce to an array
if items~isEmpty then return .nil -- return a failure indicator. could also raise an error, if desired
largest = items[1]
-- note, this method does call max one extra time. This could also use the
-- do i = 2 to items~size to avoid this
do item over items
largest = max(item, largest)
end
return largest
version 2 works with any strings
/* REXX ***************************************************************
* 30.07.2013 Walter Pachl as for REXX
**********************************************************************/
s=.list~of('Walter','lives','in','Vienna')
say listMax(s)
-- routine that will work with any ordered collection or sets and bags.
::routine listMax
use arg list
items=list~makearray -- since we're dealing with different collection types, reduce to an array
if items~isEmpty then return .nil -- return a failure indicator. could also raise an error, if desired
largest = items[1]
-- note, this method uses one extra comparison. It could use
-- do i = 2 to items~size to avoid this
do item over items
If item>>largest Then
largest = item
end
return largest
OxygenBasic
'Works on any list with element types which support '>' comparisons
macro max any(R, A, N, i)
============================
scope
indexbase 1
int i
R=A(1)
for i=2 to N
if A(i)>R
R=A(i)
endif
next
end scope
end macro
'DEMO
=====
redim double d(100)
d={ 1.1, 1.2, 5.5, -0.1, -12.0 }
double m=max(d,5)
print "greatest element of d(): " m '5.5
Oz
declare
fun {Maximum X|Xr} %% pattern-match on argument to make sure the list is not empty
{FoldL Xr Value.max X} %% fold the binary function Value.max over the list
end
in
{Show {Maximum [1 2 3 4 3]}}
PARI/GP
vecmax(v)
Pascal
See Delphi
or try this, for it shows the according position
program GElemLIst;
{$IFNDEF FPC}
{$Apptype Console}
{$else}
{$Mode Delphi}
{$ENDIF}
uses
sysutils;
const
MaxCnt = 1000000;
type
tMaxIntPos= record
mpMax,
mpPos : integer;
end;
tMaxfltPos= record
mpMax : double;
mpPos : integer;
end;
function FindMaxInt(const ia: array of integer):tMaxIntPos;
//delivers the highest Element and position of integer array
var
i : NativeInt;
tmp,max,ps: integer;
Begin
max := -MaxInt-1;
ps := -1;
//i = index of last Element
i := length(ia)-1;
IF i>=0 then Begin
max := ia[i];
ps := i;
dec(i);
while i> 0 do begin
tmp := ia[i];
IF max< tmp then begin
max := tmp;
ps := i;
end;
dec(i);
end;
end;
result.mpMax := Max;
result.mpPos := ps;
end;
function FindMaxflt(const ia: array of double):tMaxfltPos;
//delivers the highest Element and position of double array
var
i,
ps: NativeInt;
max : double;
tmp : ^double;//for 32-bit version runs faster
Begin
max := -MaxInt-1;
ps := -1;
//i = index of last Element
i := length(ia)-1;
IF i>=0 then Begin
max := ia[i];
ps := i;
dec(i);
tmp := @ia[i];
while i> 0 do begin
IF tmp^>max then begin
max := tmp^;
ps := i;
end;
dec(i);
dec(tmp);
end;
end;
result.mpMax := Max;
result.mpPos := ps;
end;
var
IntArr : array of integer;
fltArr : array of double;
ErgInt : tMaxINtPos;
ErgFlt : tMaxfltPos;
i: NativeInt;
begin
randomize;
setlength(fltArr,MaxCnt); //filled with 0
setlength(IntArr,MaxCnt); //filled with 0.0
For i := High(fltArr) downto 0 do
fltArr[i] := MaxCnt*random();
For i := High(IntArr) downto 0 do
IntArr[i] := round(fltArr[i]);
ErgInt := FindMaxInt(IntArr);
writeln('FindMaxInt ',ErgInt.mpMax,' @ ',ErgInt.mpPos);
Ergflt := FindMaxflt(fltArr);
writeln('FindMaxFlt ',Ergflt.mpMax:0:4,' @ ',Ergflt.mpPos);
end.
Out, because of the searchdirection Position of FindMaxFlt is below FindMaxInt
FindMaxInt 999999 @ 691620 FindMaxFlt 999999.0265 @ 14824
PascalABC.NET
##
var values := Lst(1,7,4,6,3,5,2,6);
values.Max.Print;
Perl
sub max {
my $max = shift;
for (@_) { $max = $_ if $_ > $max }
return $max;
}
It is already implemented in the module List::Util's max() function:
use List::Util qw(max);
max(@values);
Phix
with javascript_semantics ?max({1,1234,62,234,12,34,6}) ?max({"ant", "antelope", "dog", "cat", "cow", "wolf", "wolverine", "aardvark"})
- Output:
1234 "wolverine"
Phixmonti
"1" "1234" "62" "234" "12" "34" "6" stklen tolist
dup "Alphabetic order: " print max print nl
len for
var i
i get tonum i set
endfor
"Numeric order: " print max print
With syntactic sugar
include ..\Utilitys.pmt
( "1" "1234" "62" "234" "12" "34" "6" )
dup "Alphabetic order: " print max print nl
def f
tonum
enddef
getid f map
dup "Numeric order: " print max print
PHP
The built-in PHP function max() already does this.
max($values)
PicoLisp
: (max 2 4 1 3) # Return the maximal argument
-> 4
: (apply max (2 4 1 3)) # Apply to a list
-> 4
: (maxi abs (2 -4 -1 3)) # Maximum according to given function
-> -4
PL/I
maximum = A(lbound(A,1));
do i = lbound(A,1)+1 to hbound(A,1);
if maximum < A(i) then maximum = A(i);
end;
PostScript
Ghostscript has a max
built-in:
/findmax {
dup 0 get exch % put the first element underneath the array
{max} forall % replace it by the respective larger value if necessary
} def
If not using Ghostscript this gets a bit longer:
/findmax {
dup 0 get exch % put the first element underneath the array
{
dup % duplicate the current item
2 index % duplicate the current maximum value
gt % if the current item is larger
{exch} if % swap the two items so the previous maximum is now the top of the stack
pop % remove it
} forall
} def
[1 2 3 4 5 4 3 2 1] uncons exch {max} fold
PowerBASIC
FUNCTION PBMAIN()
DIM x AS LONG, y AS LONG, z AS LONG
RANDOMIZE TIMER
FOR x = 1 TO 10
y = INT(RND * 10000)
z = MAX(y, z)
NEXT
? STR$(z) & " was the highest value"
END FUNCTION
- Output:
8104 was the highest value
PowerShell
The Measure-Object
cmdlet in PowerShell already has this capability:
function Get-Maximum ($a) {
return ($a | Measure-Object -Maximum).Maximum
}
Prolog
SWI-Prolog already knows max_list.
?- max_list([1, 2, 10, 3, 0, 7, 9, 5], M).
M = 10.
can be implemented like this:
max_list(L, V) :-
select(V, L, R), \+((member(X, R), X > V)).
PureBasic
Procedure.f Max (Array a.f(1))
Protected last, i, ret.f
ret = a(0)
last = ArraySize(a())
For i = 1 To last
If ret < a(i)
ret = a(i)
EndIf
Next
ProcedureReturn ret
EndProcedure
PureBasic: another solution
Procedure.f maxelement(List tl.f())
ForEach tl() : mx.f=mx*Bool(mx>=tl())+tl()*Bool(mx<tl()) : Next
ProcedureReturn mx
EndProcedure
NewList testlist.f() : OpenConsole()
For i=0 To 99 : AddElement(testlist()) : testlist()=Sqr(Random(1000)) : Next
Print("Greatest element = "+StrF(maxelement(testlist()),8)) : Input()
- Output:
Greatest element = 31.59113884
Python
Numeric values
The built-in Python function max() already does this.
max(values)
Of course this assumes we have a list or tuple (or other sequence like object). (One can even find the max() or min() character of a string since that's treated as a sequence of characters and there are "less than" and "greater than" operations (object methods) associate with those characters).
If we truly were receiving a stream of data then in Python, such streams are usually iterable, meaning they have a way of generating one item at a time from the stream.
max(), (and min()), can take iterables and a key argument which takes a function that can transform each item into a type that we can compare, for example, if the stream were returning string representations of integers, one to a line, you could do
>>> floatstrings = ['1\n', ' 2.3\n', '4.5e-1\n', '0.01e4\n', '-1.2']
>>> max(floatstrings, key = float)
'0.01e4\n'
>>>
Normally we would want the converted form as the maximum and we could just as easily write:
>>> max(float(x) for x in floatstrings)
100.0
>>>
Or you can write your own functional version, of the maximum function, using reduce and lambda
>>> mylist = [47, 11, 42, 102, 13]
>>> reduce(lambda a,b: a if (a > b) else b, mylist)
102
And if you are being lazy but still want to meet this task's requirements :
max(list(map(int,input("").split(","))))
Non-numeric values
'''Non-numeric maxima'''
print(
f'max a-z: "{max(["epsilon", "zeta", "eta", "theta"])}"'
)
print(
f'max length: "{max(["epsilon", "zeta", "eta", "theta"], key=len)}"'
)
print(
'max property k by a-z: ' + str(max([
{"k": "epsilon", "v": 2},
{"k": "zeta", "v": 4},
{"k": "eta", "v": 32},
{"k": "theta", "v": 16}], key=lambda x: x["k"]))
)
print(
'max property k by length: ' + str(max([
{"k": "epsilon", "v": 2},
{"k": "zeta", "v": 4},
{"k": "eta", "v": 32},
{"k": "theta", "v": 16}], key=lambda x: len(x["k"])))
)
print(
'max property v: ' + str(max([
{"k": "epsilon", "v": 2},
{"k": "zeta", "v": 4},
{"k": "eta", "v": 32},
{"k": "theta", "v": 16}], key=lambda x: x["v"]))
)
- Output:
max a-z: "zeta" max length: "epsilon" max property k by a-z: {'k': 'zeta', 'v': 4} max property k by length: {'k': 'epsilon', 'v': 2} max property v: {'k': 'eta', 'v': 32}
Q
q)l:2 9 3 8 4 7
q)max l
9
Quackery
[ behead swap witheach max ] is [max] ( [ --> n )
R
v <- c(1, 2, 100, 50, 0)
print(max(v)) # 100
Racket
The "max" function it built in and takes an arbitrary amount of arguments.
(max 12 9 8 17 1)
- Output:
17
To use with a list, there is apply:
(apply max '(12 9 8 17 1))
However, if you want to write the function yourself:
(define (my-max l)
(define (max-h l greatest)
(cond [(empty? l) greatest]
[(> (first l) greatest) (max-h (rest l) (first l))]
[else (max-h (rest l) greatest)]))
(if (empty? l) empty (max-h l (first l))))
or with a "for" loop:
(define (my-max l)
(for/fold ([max #f]) ([x l])
(if (and max (> max x)) max x)))
Raku
(formerly Perl 6) The built-in function works with any type that defines ordering.
say max 10, 4, 5, -2, 11;
say max <zero one two three four five six seven eight nine>;
# Even when the values and number of values aren't known until runtime
my @list = flat(0..9,'A'..'H').roll((^60).pick).rotor(4,:partial)».join.words;
say @list, ': ', max @list;
- Sample output:
11 zero [6808 013C 6D5B 4219 29G9 DC13 CA4F 55F3 AA06 0AGF DAB0 2]: DC13
RapidQ
functioni FindMax(...) as double
dim x as integer
for x = 1 to ParamValCount
IF ParamVal(x) > Result THEN Result = ParamVal(x)
next
End functioni
Print FindMax(50, 20, 65, 20, 105)
Rascal
Rascal has a built-in function that gives the greatest element of a list
rascal>import List;
ok
rascal>max([1,2,3,4]);
int: 4
Raven
[ 1 2 3 4 ] max "%d\n" print
- Output:
4
Randomly generated list size and elements
100 choose as $cnt
[ ] as $lst
0 $cnt 1 range each drop 100 choose $lst push
$lst print
$lst max "max value: %d\n" print
REBOL
REBOL [
Title: "Maximum Value"
URL: http://rosettacode.org/wiki/Maximum_Value
]
max: func [
"Find maximum value in a list."
values [series!] "List of values."
] [
first maximum-of values
]
print ["Max of" mold d: [5 4 3 2 1] "is" max d]
print ["Max of" mold d: [-5 -4 -3 -2 -1] "is" max d]
- Output:
Max of [5 4 3 2 1] is 5 Max of [-5 -4 -3 -2 -1] is -1
Red
Red []
list: [1 2 3 5 4]
print last sort list
REXX
The numbers in the list may be any valid REXX number (integer, negative, floating point, etc.)
using a list
/*REXX program finds the greatest element in a list (of the first 25 reversed primes).*/
$ = reverse(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97)
say 'list of numbers = ' $ /*show the original list of numbers. */
big=word($, 1) /*choose an initial biggest number. */
# = words($); do j=2 to # /*traipse through the list, find max. */
big=max(big, word($, j) ) /*use the MAX BIF to find the biggie.*/
end /*j*/
say /*stick a fork in it, we're all done. */
say 'the biggest value in a list of ' # " numbers is: " big
- output when using the default (internal) input:
list of numbers = 79 98 38 97 37 17 76 16 95 35 74 34 14 73 13 92 32 91 71 31 11 7 5 3 2 the biggest value in a list of 25 numbers is: 98
using an array
/*REXX program finds the greatest element in a list (of the first 25 reversed primes).*/
@.=; @.1 = 2; @.2 = 3; @.3 = 5; @.4 = 7; @.5 =11; @.6 =31; @.7 =71
@.8 =91; @.9 =32; @.10=92; @.11=13; @.12=73; @.13=14; @.14=34
@.15=74; @.16=35; @.17=95; @.18=16; @.19=76; @.20=17; @.21=37
@.22=97; @.23=38; @.24=98; @.25=79
big=@.1 /*choose an initial biggest number. */
do #=2 while @.#\=='' /*traipse through whole array of nums. */
big = max(big, @.#) /*use a BIF to find the biggest number.*/
end /*#*/
/*stick a fork in it, we're all done. */
say 'the biggest value in an array of ' #-1 " elements is: " big
- output when using the default (internal) input:
the biggest value in an array of 25 elements is: 98
using a list from the terminal
/*REXX program finds the greatest element in a list of numbers entered at the terminal*/
say '────────────────── Please enter a list of numbers (separated by blanks or commas):'
parse pull $; #=words($) /*get a list of numbers from terminal. */
$=translate($, , ',') /*change all commas (,) to blanks. */
big=word($,1); do j=2 to # /*traipse through the list of numbers. */
big=max(big, word($,j)) /*use a BIF for finding the max number.*/
end /*j*/
say /*stick a fork in it, we're all done. */
say '────────────────── The biggest value in the list of ' # " elements is: " big
Programming note: the max BIF normalizes the number returned (eliding the leading superfluous zeroes).
If this is undesirable, then the do loop (shown above) can be replaced with:
···; do j=2 to #; _=word($,j)
if _>big then big=_
end /*j*/
- output when using the input from the terminal via a user prompt:
────────────────── Please enter a list of numbers (separated by blanks or commas): -12 -3 0 1.1 1e2 99.2 00245 ◄■■■■■■■■■■ user input ────────────────── The biggest value in the list of 7 elements is: 245
list of any strings
/* REXX ***************************************************************
* If the list contains any character strings, the following will work
* Note the use of >> (instead of >) to avoid numeric comparison
* Note that max() overrides the builtin function MAX
* 30.07.2013 Walter Pachl
**********************************************************************/
list='Walter Pachl living in Vienna'
Say max(list)
list='8 33 -12'
Say max(list)
Exit
max: Procedure
Parse Arg l
max=word(l,1)
Do i=2 To words(l)
If word(l,i)>>max Then
max=word(l,i)
End
Return max
- output when using an ASCII system:
living 8
- output when using an EBCDIC system:
Walter 8
output when using a list which is: 12 111111 1 (lexigraphically 12 is greater than 111111)
12
Ring
aList = [1,2,4,5,10,6,7,8,9]
see max(aList)
- Output:
10
RPL
{ 2 718 28 18 28 46 } ≪ MAX ≫ STREAM
- Output:
1: 718
Ruby
max is a method of all Enumerables
values.max
Run BASIC
list$= "1 12 -55 46 41 3.66 19"
while word$(list$,i+1," ") <> ""
mx = max(mx,val(word$(list$,i+1," ")))
i = i + 1
wend
print mx
Rust
This is built in functionality for everything that can be iterated over. It returns an Option<T>, meaning Some(e) if there are elements in the iterator and None if it is empty.
fn main() {
let nums = [1,2,39,34,20];
println!("{:?}", nums.iter().max());
println!("{}", nums.iter().max().unwrap());
}
- Output:
Some(39) 39
S-lang
Starting w/an array, this is trivial:
variable a = [5, -2, 0, 4, 666, 7];
print(max(a));
output: 666
If a is a list instead of an array, then:
a = {5, -2, 0, 4, 666, 7};
print(max(list_to_array(a)));
Scala
def noSweat(list: Int*) = list.max
// Test
assert(noSweat(1, 3, 12, 7) == 12)
Scheme
The built-in Scheme function max takes the max of all its arguments.
(max 1 2 3 4)
(apply max values) ; find max of a list
Seed7
$ include "seed7_05.s7i";
const func integer: max (in array integer: values) is func
result
var integer: max is 0;
local
var integer: index is 0;
begin
max := values[1];
for index range 2 to length(values) do
if values[index] > max then
max := values[index];
end if;
end for;
end func;
const proc: main is func
begin
writeln(max([] (1, 2, 6, 4, 3)));
end func;
- Output:
6
Self
Using reduceWith: it is very simple to find the maximum value among a collection.
(1 & 2 & 3 & 4 & 20 & 10 & 9 & 8) asVector reduceWith: [:a :b | a max: b] "returns 20"
Or, since it's "built-in", you can simply do:
(1 & 2 & 3 & 4 & 20 & 10 & 9 & 8) asVector max. "returns 20"
SenseTalk
put the max of (1, 5, 666, -1000, 3)
put the highest value of [88,-2,6,55,103,0]
Output:
666
103
Sidef
max method returns the greatest element in a list. It works only if the array's elements have the same type (e.g.: strings, numbers).
values.max;
Slate
#(1 2 3 4 20 10 9 8) reduce: [| :a :b | a max: b]
Smalltalk
Using fold it is very simple to find the maximum value among a collection.
#(1 2 3 4 20 10 9 8) fold: [:a :b | a max: b] "returns 20"
Or, since it's "built-in", you can simply do:
#(1 2 3 4 20 10 9 8) max. "returns 20"
using #inject:into:
| list |
list := #(1 2 3 4 20 10 9 8).
list inject: (list at: 1) into: [ :number :each |
number max: each ]
SNOBOL4
while a = trim(input) :f(stop)
max = gt(a,max) a :(while)
stop output = max
end
Standard ML
Comparisons are specific for each type. Here is a max function for a list of ints:
fun max_of_ints [] = raise Empty
| max_of_ints (x::xs) = foldl Int.max x xs
- max_of_ints [4,3,5,9,2,3]; val it = 9 : int
Stata
Use the summarize command to compute the maximum value of a variable:
qui sum x
di r(max)
Mata has also several functions to compute minimum or maximum of a vactor or matrix:
a = 1,5,3,4,2,7,9,8
max(a)
Swift
if let x = [4,3,5,9,2,3].maxElement() {
print(x) // prints 9
}
let x = maxElement([4,3,5,9,2,3])
println(x) // prints 9
Symstatic
let max([first|tail]) := max(first, tail)
let max(curMax, []) := curMax
let max(curMax, [first|tail]) := max(
if curMax > first then curMax else first,
tail,
)
assert(max([3, 5, 7, 2, 4, 8, -1]) = 8)
Tailspin
Simplest is to use the built-in collector
[1, 5, 20, 3, 9, 7] ... -> ..=Max&{by: :(), select: :()} -> !OUT::write
// outputs 20
// This is how the Max-collector is implemented in the standard library:
processor Max&{by:, select:}
@:[];
sink accumulate
<?($@Max <=[]>)
| ?($(by) <$@Max(1)..>)> @Max: [$(by), $(select)];
end accumulate
source result
$@Max(2) !
end result
end Max
But here is how to find the max more manually/programmatically, it is pretty easy as well
templates max
@: $(1);
$(2..last)... -> #
$@!
when <$@..> do @: $;
end max
[1, 5, 20, 3, 9, 7] -> max -> !OUT::write
// outputs 20
Can also be written as an inline templates
[1, 5, 20, 3, 9, 7] -> \(@: $(1); $(2..last)... -> # $@ ! when <$@..> do @: $;\) -> !OUT::write
// outputs 20
Or we can do just the matching in an inline templates referencing the outer state
templates max
@: $(1);
$(2..last)... -> \(<$@max..> @max: $;\) -> !VOID
$@!
end max
[1, 5, 20, 3, 9, 7] -> max -> !OUT::write
// outputs 20
Tcl
Use the {*}
expansion operator to substitute the list value with its constituent elements
package require Tcl 8.5
set values {4 3 2 7 8 9}
::tcl::mathfunc::max {*}$values ;# ==> 9
TI-83 BASIC
The builtin max
function can be applied to lists. max({1, 3, 2
.
TI-89 BASIC
The builtin max
function can be applied to lists. max({1, 3, 2})
= 3.
Transd
#lang transd
MainModule: {
_start: (λ
(textout (max 9 6 2 11 3 4) " ")
(with v [1, 45, 7, 274, -2, 34]
(textout (max-element v) " ")
(textout (max-element-idx v))
))
}
- Output:
11 274 3
Trith
[1 -2 3.1415 0 42 7] [max] foldl1
TUSCRIPT
$$ MODE TUSCRIPT
LOOP n,list="2'4'0'3'1'2'-12"
IF (n==1) greatest=VALUE(list)
IF (list>greatest) greatest=VALUE(list)
ENDLOOP
PRINT greatest
- Output:
4
uBasic/4tH
Since uBasic/4tH has a stack, it's only logical to use it.
Push 13, 0, -6, 2, 37, -10, 12 ' Push values on the stack
Print "Maximum value = " ; FUNC(_FNmax(7))
End ' We pushed seven values
_FNmax Param(1)
Local(3)
d@ = -(2^31) ' Set maximum to a tiny value
For b@ = 1 To a@ ' Get all values from the stack
c@ = Pop()
If c@ > d@ THEN d@ = c@ ' Change maximum if required
Next
Return (d@) ' Return the maximum
UNIX Shell
max() {
local m=$1
shift
while [ $# -gt 0 ]
do
[ "$m" -lt "$1" ] && m=$1
shift
done
echo "$m"
}
max 10 9 11 57 1 12
max() {
m=$1 # Bourne Shell has no local command.
shift
while [ $# -gt 0 ]
do
[ "$m" -lt "$1" ] && m=$1
shift
done
echo "$m"
}
Ursa
The max
function:
def max (int<> list)
decl int max i
set max list<0>
for (set i 1) (< i (- (size list) 1)) (inc i)
if (> list<i> max)
set max list<i>
end if
end for
return max
end max
In use: (assuming the function is in the file max.u
)
cygnus/x ursa v0.75 (default, release 0) [Oracle Corporation JVM 1.8.0_51 on Mac OS X 10.10.5 x86_64] > import "max.u" > decl int<> list > append 5 1 7 3 9 2 list > out (max list) endl console 9 > _
Ursala
The built-in $^
operator takes a binary predicate of any type to a
function extracting the maximum value from a non-empty list of that type. In this
case it is used with fleq
, the partial order relation on floating point
numbers.
#import flo
#cast %e
example = fleq$^ <-1.,-2.,0.,5.,4.,6.,1.,-5.>
- Output:
6.000000e+00
V
Assuming it is a list of positive numbers
[4 3 2 7 8 9] 0 [max] fold
=9
If it is not
[4 3 2 7 8 9] dup first [max] fold
=9
VBA
Option Explicit
Sub Main()
Dim a
a = Array(1, 15, 19, 25, 13, 0, -125, 9)
Debug.Print Max_VBA(a)
End Sub
Function Max_VBA(Arr As Variant) As Long
Dim i As Long, temp As Long
temp = Arr(LBound(Arr))
For i = LBound(Arr) + 1 To UBound(Arr)
If Arr(i) > temp Then temp = Arr(i)
Next i
Max_VBA = temp
End Function
- Output:
25
VBScript
Function greatest_element(arr)
tmp_num = 0
For i = 0 To UBound(arr)
If i = 0 Then
tmp_num = arr(i)
ElseIf arr(i) > tmp_num Then
tmp_num = arr(i)
End If
Next
greatest_element = tmp_num
End Function
WScript.Echo greatest_element(Array(1,2,3,44,5,6,8))
- Output:
44
Vim Script
for numbers (not floats):
max([1, 3, 2])
result: 3
for strings (with configurable ignore-case):
function! Max(list, ...)
" {list} list of strings
" {a:1} 'i': ignore case, 'I': match case, otherwise use 'ignorecase' option
if empty(a:list)
return 0
endif
let gt_op = a:0>=1 ? get({'i': '>?', 'I': '>#'}, a:1, '>') : '>'
let cmp_expr = printf('a:list[idx] %s maxval', gt_op)
let maxval = a:list[0]
let len = len(a:list)
let idx = 1
while idx < len
if eval(cmp_expr)
let maxval = a:list[idx]
endif
let idx += 1
endwhile
return maxval
endfunction
Visual Basic
Public Function ListMax(anArray())
'return the greatest element in array anArray
'use LBound and UBound to find its length
n0 = LBound(anArray)
n = UBound(anArray)
theMax = anArray(n0)
For i = (n0 + 1) To n
If anArray(i) > theMax Then theMax = anArray(i)
Next
ListMax = theMax
End Function
Public Sub ListMaxTest()
Dim b()
'test function ListMax
'fill array b with some numbers:
b = Array(5992424433449#, 4534344439984#, 551344678, 99800000#)
'print the greatest element
Debug.Print "Greatest element is"; ListMax(b())
End Sub
Result:
ListMaxTest Greatest element is 5992424433449
V (Vlang)
fn max<T>(list []T) T {
mut max := list[0]
for i in 1..list.len {
if list[i] > max {
max = list[i]
}
}
return max
}
fn main() {
println('int max: ${max<int>([5,6,4,2,8,3,0,2])}')
println('float max: ${max<f64>([1e4, 1e5, 1e2, 1e9])}')
}
- Output:
int max: 8 float max: 1e9
Wart
Wart defines max
in terms of the more general best
.
def (best f seq)
if seq
ret winner car.seq
each elem cdr.seq
if (f elem winner)
winner <- elem
def (max ... args)
(best (>) args)
(>)
is >
while suppressing infix expansion.
WDTE
let s => import 'stream';
let a => import 'arrays';
let max list =>
a.stream list
-> s.extent 1 >
-> at 0
;
extent
is a standard library function that returns a sorted list of the elements of a stream that fit the given function best, so >
results in the maximum element.
Wortel
The @maxl
returns the maximum value of a list:
@maxl [1 6 4 6 4 8 6 3] ; returns 8
Wren
var max = Fn.new { |a| a.reduce { |m, x| (x > m) ? x : m } }
var a = [42, 7, -5, 11.7, 58, 22.31, 59, -18]
System.print(max.call(a))
- Output:
59
XPL0
The set of values is the lengths of the lines of text in the input file.
include c:\cxpl\codes; \include 'code' declarations
def Tab=$09, LF=$0A, CR=$0D, EOF=$1A;
int CpuReg, Hand;
char CmdTail($80);
int I, Max, C;
[\Copy file name on command line, which is in the Program Segment Prefix (PSP)
\ ES=CpuReg(11), to the CmdTail array, which is in our Data Segment = CpuReg(12)
CpuReg:= GetReg; \point to copy of CPU registers
Blit(CpuReg(11), $81, CpuReg(12), CmdTail, $7F);
Hand:= FOpen(CmdTail, 0); \open file for input and get its handle
FSet(Hand, ^I); \assign handle to device 3
OpenI(3); \initialize file for input
Max:= 0; \scan file for longest line
repeat I:= 0;
repeat C:= ChIn(3);
case C of
CR, LF, EOF: []; \don't count these characters
Tab: [I:= I+8 & ~7] \(every 8th column)
other I:= I+1; \count all other characters
until C=LF or C=EOF;
if I > Max then Max:= I;
until C = EOF;
Text(0, "Longest line = "); IntOut(0, Max); CrLf(0);
]
Example of running the program on its source code:
maxline maxline.xpl Longest line = 80
XSLT
The desired value is the first in a sequence that has been sorted numerically in descending order.
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="text"/>
<xsl:template match="/">
<xsl:for-each select="/*/*">
<!-- without data-type="number", items are sorted alphabetically -->
<xsl:sort data-type="number" order="descending"/>
<xsl:if test="position() = 1">
<xsl:value-of select="."/>
</xsl:if>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
Sample input:
<numbers>
<number>3</number>
<number>1</number>
<number>12</number>
<number>7</number>
</numbers>
- Output:
12
Yabasic
l$ = "1,1234,62,234,12,34,6"
dim n$(1)
n = token(l$, n$(), ", ")
for i = 1 to n
t$ = n$(i)
if t$ > m$ then m$ = t$ end if // or: if t$ > m$ m$ = t$
if val(t$) > m then m = val(t$) end if // or: if val(t$) > m m = val(t$)
next
print "Alphabetic order: ", m$, ", numeric order: ", m
Yacas
Input:
Max({1, 3, 3, 7})
Max({Pi,Exp(1)+2/5,17*Cos(6)/5,Sqrt(91/10)})
Max({1,6,Infinity})
Max({})
- Output:
7 (17*Cos(2*Pi-6))/5 Infinity Undefined
Yorick
The built-in function max does this. Interactive example:
> foo = [4, 3, 2, 7, 8, 9] > max(foo) 9
Zig
Works with: 0.10.x, 0.11.x, 0.12.0-dev.1389+42d4d07ef
/// Asserts that `input` is not empty (len >= 1).
pub fn max(comptime T: type, input: []const T) T {
var max_elem: T = input[0];
for (input[1..]) |elem| {
max_elem = @max(max_elem, elem);
}
return max_elem;
}
zkl
(1).max(1,2,3) //-->3
(66).max(1,2,3.14) //-->66
If given a list, the max of the list is returned. The number/object just selects the method to call. Notice the difference between Int.max and Float.max.
(66).max(T(1,2,3)) //-->3
(66).max(T(1,2,3.14)) //-->3
(6.6).max(T(1,2,3.14)) //-->3.14
For other object types, you could use:
fcn max{ vm.arglist.reduce(fcn(p,n){ if(p < n) n else p }) }
max(2,1,-40,50,2,4,2) //-->50 max(2) //-->2 max("foo","bar") //-->"foo" max("3",4,"5") //-->"5" only if strings contain only digits
Zoea
program: max
case: 1
input: [7,3,5,9,2,6]
output: 9
case: 2
input: [1,5,3,2,7]
output: 7
ZX Spectrum Basic
10 PRINT "Values"''
20 LET z=0
30 FOR x=1 TO INT (RND*10)+1
40 LET y=RND*10-5
50 PRINT y
60 LET z=(y AND y>z)+(z AND y<z)
70 NEXT x
80 PRINT '"Max. value = ";z
- Programming Tasks
- Arithmetic operations
- Simple
- 11l
- 8th
- AArch64 Assembly
- ACL2
- Action!
- ActionScript
- Ada
- Aime
- ALGOL 68
- ALGOL W
- Amazing Hopper
- AntLang
- APL
- AppleScript
- Applesoft BASIC
- ARM Assembly
- Arturo
- AutoHotkey
- AWK
- Axe
- BASIC
- BaCon
- BASIC256
- Chipmunk Basic
- Minimal BASIC
- IS-BASIC
- MSX Basic
- Quite BASIC
- SmallBASIC
- Batch File
- BBC BASIC
- Bc
- Befunge
- BQN
- Bracmat
- Brat
- Burlesque
- C
- C sharp
- C++
- CFEngine
- Clojure
- CLU
- CMake
- COBOL
- CoffeeScript
- ColdFusion
- Common Lisp
- Component Pascal
- Crystal
- D
- Dart
- Dc
- DCL
- Delphi
- Dyalect
- Déjà Vu
- Draco
- E
- EasyLang
- EchoLisp
- ECL
- Efene
- Eiffel
- Ela
- Elena
- Elixir
- Emacs Lisp
- Cl-lib
- Seq.el
- Erlang
- ERRE
- Euler
- Euler Math Toolbox
- Euphoria
- Excel
- F Sharp
- Factor
- Fancy
- Fantom
- Forth
- Fortran
- FreeBASIC
- Frink
- FunL
- Futhark
- FutureBasic
- Fōrmulæ
- GW-BASIC
- GAP
- Go
- Golfscript
- Groovy
- Haskell
- Hexiscript
- HicEst
- Hoon
- I
- Icon
- Unicon
- Insitux
- J
- Janet
- Java
- JavaScript
- Joy
- Jq
- Julia
- K
- Klingphix
- Klong
- Kotlin
- Lambdatalk
- Lasso
- LDPL
- LFE
- Liberty BASIC
- Lingo
- LiveCode
- Logo
- Logtalk
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Maxima
- MAXScript
- Metafont
- Min
- MiniScript
- МК-61/52
- Modula-3
- MontiLang
- MUMPS
- Nanoquery
- Neko
- Nemerle
- NetRexx
- NewLISP
- Nial
- Nim
- Nu
- Oberon-2
- Objeck
- Objective-C
- OCaml
- Octave
- Oforth
- Ol
- OoRexx
- OxygenBasic
- Oz
- PARI/GP
- Pascal
- PascalABC.NET
- Perl
- Phix
- Phixmonti
- PHP
- PicoLisp
- PL/I
- PostScript
- Initlib
- PowerBASIC
- PowerShell
- Prolog
- PureBasic
- Python
- Q
- Quackery
- R
- Racket
- Raku
- RapidQ
- Rascal
- Raven
- REBOL
- Red
- REXX
- Ring
- RPL
- Ruby
- Run BASIC
- Rust
- S-lang
- Scala
- Scheme
- Seed7
- Self
- SenseTalk
- Sidef
- Slate
- Smalltalk
- SNOBOL4
- Standard ML
- Stata
- Swift
- Symstatic
- Tailspin
- Tcl
- TI-83 BASIC
- TI-89 BASIC
- Transd
- Trith
- TUSCRIPT
- UBasic/4tH
- UNIX Shell
- Ursa
- Ursala
- V
- VBA
- VBScript
- Vim Script
- Visual Basic
- V (Vlang)
- Wart
- WDTE
- Wortel
- Wren
- XPL0
- XSLT
- Yabasic
- Yacas
- Yorick
- Zig
- Zkl
- Zoea
- ZX Spectrum Basic
- Pages with too many expensive parser function calls