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

=={{header|BASIC256}}==

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

ELENA 5.0 :

extension op

{

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

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

=={{header|FutureBasic}}==

The function fn GreatestElementInList() will sort and return the greatest element of any list that supports the @"compare:" operator.

include "NSLog.incl"

HandleEvents

{{output}}

<pre style="font-size: 13px">

=={{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|IS-BASIC}}==

1010 LET MX=ARR(LBOUND(ARR))

1020 FOR I=LBOUND(ARR)+1 TO UBOUND(ARR)

1040 NEXT

1050 LET FINDMAX=MX

=={{header|J}}==

3

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

(J's lists know how long they are.)

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