Greatest element of a list: Difference between revisions

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

11l already has a "Maximum Value" function.

 

=={{header|8th}}==

[ 1.0, 2.3, 1.1, 5.0, 3, 2.8, 2.01, 3.14159 ] ' n:max 0 a:reduce . cr

Output: 5

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program rechMax64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

 

=={{header|ACL2}}==

(if (endp (rest xs))

(first xs)

(max (first xs)

 

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

BYTE i,res

 

m=Max(tab,size)

PrintF("Greatest: %I%E",m)

{{out}}

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

 

=={{header|ActionScript}}==

{

var curMax:Number = -Infinity;

curMax = Math.max(curMax, args[i]);

return curMax;

 

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

 

procedure Max_Test isco

begin

Ada.Text_IO.Put_Line(Float'Image(Max(Buf)));

A generic function Max to deal with any floating-point type.

type Item is digits <>;

type Items_Array is array (Positive range <>) of Item;

Implementation of:

Result : Item := List (List'First);

begin

end loop;

return Result;

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

lmax(list l)

{

 

max;

or

lmax(list l)

{

 

max;

 

=={{header|ALGOL 68}}==

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

MODE FLT = REAL;

 

except empty array:

SKIP

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% simple list type %

record IntList( integer val; reference(IntList) next );

write( maxElement( IntList( -767, IntList( 2397, IntList( 204, null ) ) ) ) )

 

{{out}}

<pre>

=={{header|Amazing Hopper}}==

Version 1:

#include <hopper.h>

main:

{"\n"} print

exit(0)

Version 2:

#include <hopper.h>

#define SIZE_LIST 100000

{"\n"} print

exit(0)

{{out}}

<pre>

 

=={{header|AntLang}}==

 

=={{header|APL}}==

{{out}} <pre>8</pre>

 

=={{header|AppleScript}}==

max({1, 2, 3, 4, 20, 6, 11, 3, 9, 7})

 

return _curMax

end max

 

 

{{trans|JavaScript}}

 

-- maximumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a

on maximumByMay(f, xs)

end script

end if

{{Out}}

 

=={{header|Applesoft BASIC}}==

110 R$ = "":E$ = ""

120 L = LEN (L$)

270 R = VAL (V$)

280 IF R < V THEN RETURN

GOSUB 100MAX

{{Out}}

<pre>20</pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

 

 

=={{header|Arturo}}==

 

{{out}}

=={{header|AutoHotkey}}==

=== CSV Data ===

Loop Parse, list, `,

x := x < A_LoopField ? A_LoopField : x

=== Pseudo-arrays ===

StringSplit, list, list,`, ; creates a pseudo-array

Loop % List0

x := x < List%A_Index% ? List%A_Index% : x

=== True arrays ===

{{works with|AutoHotkey_L}}

For each, value in List

x := x < value ? value : x

 

=={{header|AWK}}==

One-liner:

 

More readable version:

# Usage: awk -f greatest_list_element.awk

#

print max(a)

}

 

=={{header|Axe}}==

This example assumes the array is null-terminated so that the program can stop at the end of the data.

0→M

While {r₁}

End

M

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

DECLARE FUNCTION findMax% ()

 

NEXT

findMax = tmp2

 

{{Out}}

 

==={{header|BaCon}}===

' Populate sample array of numbers

READ elements

NEXT

RETURN mx

 

{{out}}

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

 

{{trans|Yabasic}}

dim n$(1)

n$ = explode(l$, ",")

next i

 

 

=={{header|Batch File}}==

@echo off

setlocal enabledelayedexpansion

if "%2" equ "" goto :eof

if %2 gtr !%1! set res=%2

 

''Invocation from command line or from internal prompt''

 

234243

 

>max

Input stream: 5 4 3 2 67 1

 

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

PRINT "Maximum value = " ; FNmax(ListOfValues$)

END

IF number > max THEN max = number

UNTIL index% = 0

 

=={{header|bc}}==

auto m, i

 

}

return(m)

 

=={{header|Befunge}}==

>&:01g`#v_1+#^_01g.@

Only works with positive integers. List must be terminated with -1.

 

=={{header|BQN}}==

 

{{out}}

=={{header|Bracmat}}==

When comparing two rational numbers, Bracmat compares numerically. In all other cases Bracmat compares lexically.

= max

. !arg:

biggest

$ (5 100000 -5 43756243978569758/13 3365864921428443 87512487957139516/27 3446)

{{Out}}

<pre>1: mies

=={{header|Brat}}==

Arrays have a max function, but here's a manual implementation.

list.reduce { n, max |

true? n > max

}

 

 

=={{header|Burlesque}}==

 

blsq ) {88 99 77 66 55}>]

99

 

=={{header|C}}==

This works well with floats. Replace with double, int or what-have-you before passing a different data type.

 

float max(unsigned int count, float values[]) {

}

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

 

#define MAX(A,...) ({ inline __typeof__ (A) _max_(__typeof__ (A) a, ...) {\

}\

_max_((A),__VA_ARGS__);\

 

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

C# already has a "Maximum Value" function.

 

 

 

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

A simple wrapper around the standard library function <tt>max_element()</tt>.

Requires C++17.

#include <iterator> //std::begin and std::end

#include <functional> //std::less

using std::begin; using std::end;

return max_value(begin(container), end(container), compare);

 

=={{header|CFEngine}}==

Note: CFEngine bundles are NOT functions, however they can behave in some ways that are similar to functions.

 

bundle agent __main__

{

bundle_return_value_index => "max";

}

 

{{output}}

=={{header|Clojure}}==

The Clojure.core function max returns the max of its arguments.

;; If the values are already in a collection, use apply:

 

=={{header|CLU}}==

% the container type has an elements iterator and the

% data type is comparable.

rmax: real := maximum[sequence[real], real](reals)

stream$putl(po, "maximum real: " || real$unparse(rmax))

 

{{out}}

Only for lists of integers.

 

# integers. If list is empty, sets var to NO.

function(max var)

set(list 33 11 44 22 66 55)

max(maximum ${list})

 

<pre>-- maximum of 33;11;44;22;66;55 => 66</pre>

=={{header|COBOL}}==

This is already built into the language for tables of numbers.

 

A sample implementation:

FUNCTION-ID. greatest-elt.

 

GOBACK

.

 

=={{header|CoffeeScript}}==

# using Math library

max1 = (list) ->

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

alert(max1(a)+". The answer is "+max2(a));

 

=={{header|ColdFusion}}==

<Cfset theList = '1, 1000, 250, 13'>

<Cfparam name="maxNum" default=0>

</Cfloop>

<Cfoutput>#maxNum#</Cfoutput>

 

<Cfset theList = '1, 1000, 250, 13'>

<Cfset maxNum = ListFirst(ListSort(thelist, "numeric", "desc"))>

<Cfoutput>#maxNum#</Cfoutput>

 

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

The built-in Common Lisp function <tt>max</tt> takes the max of all its arguments.

(reduce #'max values) ; find max of a list

(loop for x in values

 

=={{header|Component Pascal}}==

BalckBox Component Builder

MODULE Operations;

IMPORT StdLog,Args,Strings;

 

END Operations.

Execute: ^Q Operations..DoMax 23 12 3 45 34 54 84 ~<br/>

{{Out}}

 

=={{header|Crystal}}==

 

=={{header|D}}==

D already has a "Maximum Element" function.

 

{

import std.algorithm.searching : maxElement;

 

[9, 4, 3, 8, 5].maxElement.writeln;

{{out}}

<pre>9</pre>

 

=={{header|Dart}}==

num findGreatestElement(List<num> list){

num greatestElement = list[0];

return list.reduce(max);

}

 

=={{header|dc}}==

[lm p q] sq

[d lm <u s_ z 0 =q llx] sl

_275.0 _111.19 0.0 _1234568.0 lp lp _1 *

 

 

{{Out}}

 

=={{header|DCL}}==

$ max = f$integer( f$element( 0, ",", list ))

$ i = 1

$ goto loop

$ done:

{{out}}

<pre>$ @greatest

 

=={{header|Delphi}}==

program GElemLIst;

{$IFNDEF FPC}

writeln(Math.MaxValue(fltArr));

end.

 

=={{header|Dyalect}}==

var y

for x in xs {

var xs = [1..10]

 

=={{header|Déjà Vu}}==

lst! 0

for item in copy lst:

item drop

 

{{out}}

<pre>999</pre>

 

=={{header|Draco}}==

proc nonrec max([*] int a) int:

int INT_MIN = ~((~0) >> 1);

type arr = [8] int;

writeln("Maximum: ", max(arr(1,5,17,2,53,99,61,3)))

{{out}}

<pre>Maximum: 99</pre>

This function works for any value which responds to <code>[http://wiki.erights.org/wiki/Category:Message_max/1 max/1]</code>:

 

 

def max([first] + rest) {

return accum first for x in rest { _.max(x) }

 

 

To require only the comparison protocol, one needs to write out the algorithm a little more explicitly:

 

for x ? (x > bestSoFar) in rest {

bestSoFar := x

}

return bestSoFar

 

# value: 3

 

? max([[1].asSet(), [2].asSet(), [1, 2].asSet()])

 

=={{header|EasyLang}}==

 

for e in a[]

max = higher e max

.

 

=={{header|EchoLisp}}==

;; a random length list of random values

(define L (map random (make-list (random 50) 100))) → L

;; find max

(apply max L) → 97

 

=={{header|ECL}}==

MaxVal(SET OF INTEGER s) := MAX(s);

 

SetVals := [4,8,16,2,1];

MaxVal(SetVals) //returns 16;

 

=={{header|Efene}}==

 

list_max(Rest, Head)

}

io.format("~p~n", [list_max1([9, 4, 3, 8, 5])])

}

 

=={{header|Eiffel}}==

The GREATEST_ELEMENT class:

class

GREATEST_ELEMENT [G -> COMPARABLE]

 

end

A test application:

class

APPLICATION

 

end

 

=={{header|Ela}}==

 

 

findBy p (x::xs) = foldl (\x y | p x y -> x | else -> y) x xs

maximum = findBy (>)

 

 

=={{header|Elena}}==

extension op

while (en.next())

{

if (nil == maximal)

{

{

console.printLine(new int[]{1,2,3,4,20,10,9,8}.Maximal)

{{out}}

<pre>

 

=={{header|Elixir}}==

 

=={{header|Emacs Lisp}}==

 

(let (max)

(dolist (item items)

max))

 

 

Built-in:

 

 

{{libheader|cl-lib}}

 

 

{{libheader|seq.el}}

 

=={{header|Erlang}}==

Builtin. Using it from the Erlang shell:

 

=={{header|ERRE}}==

PROGRAM MAXLIST

 

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.

 

=={{header|Euler Math Toolbox}}==

 

>v=random(1,100);

>max(v)

0.997492478596

 

=={{header|Euphoria}}==

===Applying a function to each element of an array===

for i = 1 to length( sArr ) do

sArr[ i ] = call_func( id, { sArr[ i ] } )

biggun = "ant"

a = aeval( s, routine_id("biggest") )

{{Out}}

<pre>

 

===More trivial example===

object biggun

biggun = s[1]

 

constant animals = {"ant", "antelope", "dog", "cat", "cow", "wolf", "wolverine", "aardvark"}

 

{{Out}}

Use the function MAX

 

=MAX(3;2;1;4;5;23;1;2)

{{out}}

<pre>

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)

{{out}}

<pre>

=={{header|Factor}}==

The following word is in factor's standard library.

 

=={{header|Fancy}}==

 

=={{header|Fantom}}==

Has a built-in method to get maximum from a list.

 

class Greatest

{

}

}

 

=={{header|Forth}}==

dup 0= if nip exit then

over @ rot cell+ rot 1-

cells bounds ?do i @ max cell +loop ;

 

 

=={{header|Fortran}}==

The intrinsic function <tt>maxval</tt> returns the maximum value of the elements in an integer or real array:

 

integer,dimension(5),parameter :: x = [10,100,7,1,2]

write(*,'(F5.1)') maxval(y)

 

 

{{Out}}

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.

 

implicit none

& max (['abc', 'hig', 'fde'], ['ghi', 'efd', 'cab'], ['def', 'bca', 'igh'])

 

{{Out}}

<pre>

 

=={{header|FreeBASIC}}==

 

Function MaxElement(a() As Double) As Double

Print "Press any key to quit"

Sleep

 

Example of use :

 

=={{header|Frink}}==

println[max[[1,2,3,5,10,20]]]

 

=={{header|FunL}}==

Using the pre-defined function <code>max</code>:

{{out}}

<pre>

 

It can be implemented as:

maximum( xs ) =

def

foldl1( _, [] ) = error( "foldl1: empty list" )

 

 

=={{header|Futhark}}==

 

 

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|GW-BASIC}}==

20 DIM ARR(N%)

30 FOR I% = 0 TO N%-1

100 NEXT I%

110 PRINT "The maximum value was ";CHAMP;" at index ";INDEX;"."

 

=={{header|GAP}}==

 

L := List([1 .. 100], n -> Random(1, 10));

 

MaximumList(L);

 

=={{header|Go}}==

;Library

 

import (

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

 

import "fmt"

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.

 

import (

fmt.Println("empty list. no maximum.")

}

;Set

The task description says set. This solution uses a Go map as a set.

 

import (

fmt.Println("no largest, empty set")

}

 

=={{header|Golfscript}}==

 

=={{header|Groovy}}==

 

{{Out}}

=={{header|Haskell}}==

The built-in Haskell function <tt>maximum</tt> returns a maximum based on default comparison between members of an ordered type.

It can alternately be defined as a "fold" on the built-in two-argument <tt>max</tt> function.

 

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.Ord (comparing)

 

 

main :: IO ()

 

As a fold, maximumBy could be defined along the lines of:

 

:: Foldable t

=> (a -> a -> Ordering) -> t a -> a

GT -> x

_ -> y

 

=={{header|hexiscript}}==

let l len a

let max a[0]

endfor

return max

 

=={{header|HicEst}}==

max_value = MAX( -123, 234.56, 345.678, -456E3, -455) ! built-in function MAX(...)

 

! 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

 

=={{header|Hoon}}==

|= [^ [a=(list ,@) ~] ~]

:- %noun

Usage: Add to a file gen/max.hoon

<pre>

 

=={{header|i}}==

large = l[0]

for element in l

software {

print(largest([23, 1313, 21, 35757, 4, 434, 232, 2, 2342]))

 

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

local l

l := [7,8,6,9,4,5,2,3,1]

every max <:= !l

return max

 

 

=={{header|J}}==

3

>./'' NB. Maximum value of an empty list = identity element (or neutral) of max = -∞

 

=={{header|Janet}}==

(def elems @[3 1 3 2])

 

# Unpack list as arguments to max function.

(max ;elems)

 

=={{header|Java}}==

The first function works with arrays of floats. Replace with arrays of double, int, or other primitive data type.

if (values.length == 0)

throw new NoSuchElementException();

}

return themax;

 

Optionally, if it is OK to rearrange the contents of the original array:

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

import java.util.Collections;

import java.util.Arrays;

public static <T extends Comparable<? super T>> T max(T[] values) {

return Collections.max(Arrays.asList(values));

 

=={{header|JavaScript}}==

===ES3-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.

 

 

// (a -> a -> Ordering) -> [a] -> a

]

 

 

 

{{Out}}

 

"alpha",

"zeta",

"population": 13.3

}

 

===ES6===

For, numbers, a method of the standard Math object:

 

and for orderings defined over other datatypes:

"use strict";

 

// maximumByMay :: (a -> a -> Ordering) ->

const maximumByMay = f =>

// Nothing, if the list is empty,

xs => Boolean(xs.length) ? (

Just(xs.slice(1).reduce(

// MAIN ---

return main();

{{Out}}

<pre>[

}

]</pre>

 

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

 

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:

 

=={{header|Julia}}==

Using the built-in <code>maximum</code> function:

7

 

at In[138]:1

in maximum at abstractarray.jl:1591

(Note that it throws an exception on an empty array.)

 

=={{header|K}}==

 

=={{header|Klingphix}}==

 

( "1" "1234" "62" "234" "12" "34" "6" )

"Numeric order: " print lmax ?

 

 

=={{header|Klong}}==

|/list

|/ [ 1.0 2.3 1.1 5.0 3 2.8 2.01 3.14159 66 ]

{{out}}

<pre>77

 

=={{header|Kotlin}}==

 

 

=={{header|Lambdatalk}}==

1) using the builtin primitive

 

{my-max {A.new 556 1 7344 4 7 52 22 55 88 122 55 99 1222 578}}

-> 7344

 

=={{header|Lasso}}==

return (#a->sort&)->last

}

 

local(x = array(556,1,7344,4,7,52,22,55,88,122,55,99,1222,578))

 

{{out}}

<pre>7344</pre>

 

=={{header|LFE}}==

Builtin. Using it from the LFE shell:

 

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

 

maxVal = val(word$(aList$, 1))

wend

 

 

=={{header|Lingo}}==

put max(l)

 

=={{header|LiveCode}}==

 

Result: 7

 

local maxNum

put item 1 of lst into maxNum

on mouseUp

answer max2("1,2,5,6,7,4,3,2")

 

=={{header|Logo}}==

to use APPLY instead of REDUCE. The latter is good for associative

procedures that have been written to accept exactly two inputs:

output ifelse :a > :b [:a] [:b]

end

 

 

Alternatively, REDUCE can be used to write MAX as a procedure

that accepts any number of inputs, as SUM does:

if emptyp :inputs ~

[(throw "error [not enough inputs to max])]

output reduce [ifelse ?1 > ?2 [?1] [?2]] :inputs

{{works with|UCB Logo}}

output ifelse [greater? :a :b] [:a] [:b]

end

to max :lst

output reduce "bigger :lst

 

=={{header|Logtalk}}==

max([X| Xs], Max) :-

max(Xs, X, Max).

max(Xs, X, Max)

; max(Xs, Aux, Max)

 

=={{header|Lua}}==

local values = {}

-- Read in the first number from stdin

-- Print the max

print(math.max(unpack(values)))

 

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

Module TestThis {

Print "Search a tuple type list (is an array also)"

}

TestThis

 

=={{header|Maple}}==

This is a built-in, polymorphic procedure in Maple.

Pi

 

 

> max( Array( [ 1, 2, Pi, exp(1) ] ) ); # Array

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.

 

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

Input:

Max[Pi,E+2/5,17 Cos[6]/5,Sqrt[91/10]]

Max[1,6,Infinity]

{{Out}}

<pre> 7

-Infinity</pre>

Note that Max returns minus infinity if supplied with no arguments; as it should:

Max[Max[a],Max[b,c]]

Max[Max[a,b],Max[c]]

should all give the same results, therefore max[] should give -Infinity. If it WOULD give 0 strange things can happen:

WOULD give 0 instead of -3

 

=={{header|MATLAB}}==

 

=={{header|Maxima}}==

 

/* Three solutions */

apply(max, u);

 

 

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

(

if AnArray.count != 0 then

)

else undefined

 

=={{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).

 

show max((12,3), (10,10), (25,5));

 

=={{header|min}}==

 

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

if not self then return null

result = self[0]

end function

 

 

=={{header|МК-61/52}}==

 

or

 

 

=={{header|Modula-3}}==

 

We provide a generic Maximum implementation:

 

EXCEPTION Empty;

PROCEDURE Max(READONLY a: ARRAY OF Elem.T): Elem.T RAISES {Empty};

 

 

 

PROCEDURE Max(READONLY arr: ARRAY OF Elem.T): Elem.T RAISES {Empty} =

 

BEGIN

 

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

 

Now we can import <code>RealMax</code> into our source and use the <code>Max</code> function:

 

IMPORT RealMax, IO, Fmt;

BEGIN

IO.Put(Fmt.Real(RealMax.Max(realarr)) & "\n");

 

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

 

LEN VAR l .

FOR st

MAX

 

Another way to do it.

 

print

LEN VAR l .

|Greatest number in the list: | out . print

|Press ENTER to exit | input

 

=={{header|MUMPS}}==

MV(A,U)

;A is a list of values separated by the string U

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:

<pre>

 

=={{header|Nanoquery}}==

if len(list) = 0

return null

end

return largest

 

=={{header|Neko}}==

greatest element from a list (Neko Array)

Tectonics:

 

$print(greatest($array(5, 1, 3, 5)), "\n");

 

{{out}}

 

=={{header|Nemerle}}==

using Nemerle.Collections;

using System.Linq;

WriteLine($"letters.Max() = $(letters.Max())")

}

 

{{Out}}

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols binary

end n_

return dmax

{{Out}}

<pre>

 

=={{header|NewLISP}}==

 

 

=={{header|Nial}}==

The behavior of multi-dimensional arrays is like J

 

 

=={{header|Nim}}==

 

{{out}}<pre>6</pre>

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

{{Works with|oo2c Version 2}}

MODULE GreatestElement1;

IMPORT

Out.String("Max: ");Out.LongInt(max.value,4);Out.Ln

END GreatestElement1.

 

Simple version

MODULE GreatestElement2;

IMPORT

Out.String("Max: ");Out.LongInt(Max(a),4);Out.Ln

END GreatestElement2.

{{out}}(in both programs):

<pre>

=={{header|Objeck}}==

The language has a "Max" method for vectors.

values := IntVector->New([4, 1, 42, 5]);

values->Max()->PrintLine();

 

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

 

 

@interface NSArray (WithMaximum)

return maybeMax;

}

 

This example mixes integers with a double value, just to show that

everything is fine until they are NSNumber.

 

{

@autoreleasepool {

}

return 0;

 

=={{header|OCaml}}==

[] -> invalid_arg "empty list"

 

# my_max [4;3;5;9;2;3] ;;

Octave's <code>max</code> accepts a vector (and can return also the index of the maximum value in the vector)

 

 

=={{header|Oforth}}==

 

 

=={{header|Ol}}==

Basics:

; builtin function

(max 1 2 3 4 5) ; 5

(if (less? a b) b a))

(car x) x)) ; 5

 

=={{header|ooRexx}}==

===version===

-- routine that will work with any ordered collection or sets and bags containing numbers.

::routine listMax

 

return largest

 

===version 2 works with any strings===

* 30.07.2013 Walter Pachl as for REXX

**********************************************************************/

largest = item

end

 

=={{header|OxygenBasic}}==

'Works on any list with element types which support '>' comparisons

 

double m=max(d,5)

print "greatest element of d(): " m '5.5

 

=={{header|Oz}}==

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

 

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

 

=={{header|Pascal}}==

{{works with | Free Pascal}}

or try this, for it shows the according position

{$IFNDEF FPC}

{$Apptype Console}

Ergflt := FindMaxflt(fltArr);

writeln('FindMaxFlt ',Ergflt.mpMax:0:4,' @ ',Ergflt.mpPos);

Out, because of the searchdirection Position of FindMaxFlt is below FindMaxInt

 

 

=={{header|Perl}}==

my $max = shift;

for (@_) { $max = $_ if $_ > $max }

return $max;

 

It is already implemented in the module <tt>List::Util</tt>'s <tt>max()</tt> function:

 

 

=={{header|Phix}}==

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

{{out}}

<pre>

 

=={{header|Phixmonti}}==

dup "Alphabetic order: " print max print nl

 

i get tonum i set

endfor

 

With syntactic sugar

 

 

( "1" "1234" "62" "234" "12" "34" "6" )

 

dup "Numeric order: " print max print

 

=={{header|PHP}}==

The built-in PHP function <tt>max()</tt> already does this.

 

=={{header|PicoLisp}}==

-> 4

: (apply max (2 4 1 3)) # Apply to a list

-> 4

: (maxi abs (2 -4 -1 3)) # Maximum according to given function

 

=={{header|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;

 

=={{header|PostScript}}==

 

{{works with|Ghostscript}}

dup 0 get exch % put the first element underneath the array

{max} forall % replace it by the respective larger value if necessary

 

If not using Ghostscript this gets a bit longer:

 

dup 0 get exch % put the first element underneath the array

{

pop % remove it

} forall

 

{{libheader|initlib}}

[1 2 3 4 5 4 3 2 1] uncons exch {max} fold

 

=={{header|PowerBASIC}}==

 

DIM x AS LONG, y AS LONG, z AS LONG

RANDOMIZE TIMER

 

? STR$(z) & " was the highest value"

 

{{Out}}

=={{header|PowerShell}}==

The <code>Measure-Object</code> cmdlet in PowerShell already has this capability:

return ($a | Measure-Object -Maximum).Maximum

 

=={{header|Prolog}}==

SWI-Prolog already knows max_list.

 

can be implemented like this:

 

select(V, L, R), \+((member(X, R), X > V)).

 

=={{header|PureBasic}}==

Protected last, i, ret.f

 

ProcedureReturn ret

===PureBasic: another solution===

ForEach tl() : mx.f=mx*Bool(mx>=tl())+tl()*Bool(mx<tl()) : Next

ProcedureReturn mx

NewList testlist.f() : OpenConsole()

For i=0 To 99 : AddElement(testlist()) : testlist()=Sqr(Random(1000)) : Next

{{out}}

<pre>Greatest element = 31.59113884</pre>

 

=={{header|Python}}==

The built-in Python function <tt>max()</tt> already does this.

 

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

 

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(floatstrings, key = float)

'0.01e4\n'

Normally we would want the converted form as the maximum and we could just as easily write:

100.0

Or you can write your own functional version, of the maximum function, using reduce and lambda

>>> reduce(lambda a,b: a if (a > b) else b, mylist)

 

=={{header|Q}}==

q)max l

 

=={{header|Quackery}}==

 

=={{header|R}}==

 

=={{header|Racket}}==

The "max" function it built in and takes an arbitrary amount of arguments.

{{Out}}

<pre>17</pre>

 

To use with a list, there is <tt>apply</tt>:

 

However, if you want to write the function yourself:

(define (my-max l)

(define (max-h l greatest)

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

 

=={{header|Raku}}==

(formerly Perl 6)

The built-in function works with any type that defines ordering.

say max <zero one two three four five six seven eight nine>;

 

my @list = flat(0..9,'A'..'H').roll((^60).pick).rotor(4,:partial)».join.words;

say @list, ': ', max @list;

{{out|Sample output}}

<pre>11

 

=={{header|RapidQ}}==

dim x as integer

 

Print FindMax(50, 20, 65, 20, 105)

 

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

 

=={{header|Raven}}==

{{out}} <pre>4</pre>

 

'''Randomly generated list size and elements'''

[ ] as $lst

0 $cnt 1 range each drop 100 choose $lst push

$lst print

 

=={{header|REBOL}}==

Title: "Maximum Value"

URL: http://rosettacode.org/wiki/Maximum_Value

 

print ["Max of" mold d: [5 4 3 2 1] "is" max d]

 

{{Out}}

 

=={{header|Red}}==

list: [1 2 3 5 4]

print last sort list

 

=={{header|REXX}}==

The numbers in the list may be any valid REXX number &nbsp; (integer, negative, floating point, etc.)

===using a list===

$ = 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. */

end /*j*/

say /*stick a fork in it, we're all done. */

{{out|output|text=&nbsp; when using the default (internal) input:}}

<pre>

 

===using an array===

@.=; @.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

end /*#*/

/*stick a fork in it, we're all done. */

{{out|output|text=&nbsp; when using the default (internal) input:}}

<pre>

 

===using a list from the terminal===

say '────────────────── Please enter a list of numbers (separated by blanks or commas):'

parse pull $; #=words($) /*get a list of numbers from terminal. */

end /*j*/

say /*stick a fork in it, we're all done. */

Programming note: &nbsp; the &nbsp; '''max''' &nbsp; BIF normalizes the number returned (eliding the leading superfluous zeroes).

 

If this is undesirable, then the &nbsp; '''do''' &nbsp; loop (shown above) can be replaced with:

if _>big then big=_

{{out|output|text=&nbsp; when using the input from the terminal via a user prompt:}}

<pre>

 

===list of any strings===

* If the list contains any character strings, the following will work

* Note the use of >> (instead of >) to avoid numeric comparison

max=word(l,i)

End

{{out|output|text=&nbsp; when using an &nbsp; '''ASCII''' &nbsp; system:}}

<pre>

 

=={{header|Ring}}==

{{out}}

<pre>

10

</pre>

 

=={{header|Ruby}}==

<tt>max</tt> is a method of all Enumerables

 

=={{header|Run BASIC}}==

while word$(list$,i+1," ") <> ""

mx = max(mx,val(word$(list$,i+1," ")))

i = i + 1

wend

 

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

let nums = [1,2,39,34,20];

println!("{:?}", nums.iter().max());

println!("{}", nums.iter().max().unwrap());

 

{{out}}

=={{header|S-lang}}==

Starting w/an array, this is trivial:

 

output:

 

If a is a list instead of an array, then:

 

=={{header|Scala}}==

{{libheader|Scala}}

// Test

 

=={{header|Scheme}}==

The built-in Scheme function <tt>max</tt> takes the max of all its arguments.

 

=={{header|Seed7}}==

 

const func integer: max (in array integer: values) is func

begin

writeln(max([] (1, 2, 6, 4, 3)));

 

{{Out}}

Using ''reduceWith:'' it is very simple to find the maximum value among a collection.

 

 

Or, since it's "built-in", you can simply do:

 

 

=={{header|SenseTalk}}==

Output:

 

=={{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).

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

Using ''fold'' it is very simple to find the maximum value among a collection.

 

 

Or, since it's "built-in", you can simply do:

{{works with|Pharo|1.4}}

{{works with|Smalltalk/X}}

 

using #inject:into:

| list |

list := #(1 2 3 4 20 10 9 8).

list inject: (list at: 1) into: [ :number :each |

number max: each ]

 

=={{header|SNOBOL4}}==

max = gt(a,max) a :(while)

stop output = max

 

=={{header|Standard ML}}==

Comparisons are specific for each type. Here is a max function for a list of ints:

 

- max_of_ints [4,3,5,9,2,3];

Use the '''[https://www.stata.com/help.cgi?summarize summarize]''' command to compute the maximum value of a variable:

 

 

Mata has also several [https://www.stata.com/help.cgi?mf_minmax functions] to compute minimum or maximum of a vactor or matrix:

 

 

=={{header|Swift}}==

{{works with|Swift|2.x}}

print(x) // prints 9

{{works with|Swift|1.x}}

 

=={{header|Tailspin}}==

Simplest is to use the built-in collector

[1, 5, 20, 3, 9, 7] ... -> ..=Max&{by: :(), select: :()} -> !OUT::write

// outputs 20

sink accumulate

<?($@Max <=[]>)

end accumulate

source result

end result

end Max

But here is how to find the max more manually/programmatically, it is pretty easy as well

templates max

@: $(1);

[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);

[1, 5, 20, 3, 9, 7] -> max -> !OUT::write

// outputs 20

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

Use the <code>{*}</code> expansion operator to substitute the list value with its constituent elements

 

set values {4 3 2 7 8 9}

 

=={{header|TI-83 BASIC}}==

 

=={{header|Transd}}==

 

MainModule: {

(textout (max-element-idx v))

))

<pre>

11 274 3

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

LOOP n,list="2'4'0'3'1'2'-12"

ENDLOOP

PRINT greatest

{{Out}}

<pre>

=={{header|uBasic/4tH}}==

Since uBasic/4tH has a stack, it's only logical to use it.

Print "Maximum value = " ; FUNC(_FNmax(7))

End ' We pushed seven values

If c@ > d@ THEN d@ = c@ ' Change maximum if required

Next

 

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

{{works with|pdksh}}

 

local m=$1

shift

}

 

 

{{works with|Bourne Shell}}

 

m=$1 # Bourne Shell has no local command.

shift

done

echo "$m"

 

=={{header|Ursa}}==

The <code>max</code> function:

decl int max i

set max list<0>

return max

 

In use: (assuming the function is in the file <code>max.u</code>)

case it is used with <code>fleq</code>, the partial order relation on floating point

numbers.

 

#cast %e

 

{{Out}}

<pre>6.000000e+00</pre>

=={{header|V}}==

Assuming it is a list of positive numbers

 

If it is not

=9

 

=={{header|VBA}}==

 

Sub Main()

Next i

Max_VBA = temp

 

{{Out}}

 

=={{header|VBScript}}==

Function greatest_element(arr)

tmp_num = 0

 

WScript.Echo greatest_element(Array(1,2,3,44,5,6,8))

 

{{Out}}

 

for numbers (not floats):

result: 3

 

for strings (with configurable ignore-case):

if empty(a:list)

endif

let gt_op = a:0>=1 ? get({'i': '>?', 'I': '>#'}, a:1, '>') : '>'

let idx = 1

while idx < len

endwhile

return maxval

 

=={{header|Visual Basic}}==

'return the greatest element in array anArray

'use LBound and UBound to find its length

'print the greatest element

Debug.Print "Greatest element is"; ListMax(b())

 

Result:

<pre>ListMaxTest

Greatest element is 5992424433449</pre>

 

=={{header|Wart}}==

Wart defines <code>max</code> in terms of the more general <code>best</code>.

if seq

ret winner car.seq

 

def (max ... args)

 

<code>(&gt;)</code> is <code>&gt;</code> while suppressing infix expansion.

 

=={{header|WDTE}}==

let a => import 'arrays';

 

-> s.extent 1 >

-> at 0

 

<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>&gt;</code> results in the maximum element.

=={{header|Wortel}}==

The <code>@maxl</code> returns the maximum value of a list:

 

=={{header|Wren}}==

 

var a = [42, 7, -5, 11.7, 58, 22.31, 59, -18]

 

{{out}}

The set of values is the lengths of the lines of text in the input file.

 

 

def Tab=$09, LF=$0A, CR=$0D, EOF=$1A;

until C = EOF;

Text(0, "Longest line = "); IntOut(0, Max); CrLf(0);

 

Example of running the program on its source code:

 

The desired value is the first in a sequence that has been sorted numerically in descending order.

<xsl:output method="text"/>

 

</xsl:for-each>

</xsl:template>

 

Sample input:

 

<number>3</number>

<number>1</number>

<number>12</number>

<number>7</number>

 

{{Out}}

 

=={{header|Yabasic}}==

 

dim n$(1)

next

 

 

=={{header|Yacas}}==

Input:

Max({Pi,Exp(1)+2/5,17*Cos(6)/5,Sqrt(91/10)})

Max({1,6,Infinity})

{{Out}}

<pre> 7

> max(foo)

9</pre>

 

=={{header|zkl}}==

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.14)) //-->3

For other object types, you could use:

<pre>max(2,1,-40,50,2,4,2) //-->50

max(2) //-->2

 

=={{header|Zoea}}==

program: max

case: 1

input: [1,5,3,2,7]

output: 7

 

=={{header|ZX Spectrum Basic}}==

20 LET z=0

30 FOR x=1 TO INT (RND*10)+1

60 LET z=(y AND y>z)+(z AND y<z)

70 NEXT x