# Maximum tuple value

Is there a simple way to make a maximum tuple value (similar to python)?

For example, in python

max([ (1,2), (1,3), (3,1), (4,0) ])


returns (4,0), using lexicographic order.

If I have a tensor in Mathematica, is there a way to take the max without flattening it?

i.e. a way to call

Max[ { {1,2}, {1,3}, {3,1}, {4,0} } ]


so that it returns {4,0} instead of 4?

• The simplest solution would be: #[[Ordering[#, -1]]] &@ tuples – rm -rf Oct 9 '12 at 19:11
• @LeonidShifrin Fair enough. Made it a comment :) Now if only we can get Mr.Wizard to also stop answering all the low hanging fruit... :D – rm -rf Oct 9 '12 at 19:20
• @rm-rf I think this is an achievable goal :-) – Leonid Shifrin Oct 9 '12 at 19:23
• @rm sorry, I'm the king of low hanging fruit, it ain't happenin' :-p – Mr.Wizard Oct 9 '12 at 19:32
• @rm okay, I waited 40 minutes -- with effort. – Mr.Wizard Oct 9 '12 at 20:12

It's not clear to me from the question what you expect for { {1,2}, {1,3}, {3,1}, {4,0}, {2,3} } -- is {2,3} to be returned because it has the largest sum, or {4,0} because it will sort into the last place? I am assuming that you want the largest sum but you want to break ties based on lexicographic order. You can do that like this:

a = {{1, 2}, {1, 3}, {4, 0}, {3, 1}};

Last @ SortBy[a, {Total, Identity}]

{4, 0}


Or more tersely: Last @ SortBy[a, {Tr, # &}]

If you just want the last element of the list after lexicographic sort you can use:

a = {{1, 2}, {1, 3}, {4, 0}, {3, 1}, {2, 3}};  (* note inclusion of {2,3} *)

Last @ Sort @ a

{4, 0}


But there is a more efficient way which is faster than a full sort:

a ~Extract~ Ordering[a, -1]

{4, 0}


More examples of this last form: (1) (2) (3)

• @Oliver you're welcome; which interpretation was correct, if either? – Mr.Wizard Oct 9 '12 at 20:15
• I wanted lexicographic, so sorting or using ordering for fast selection is exactly what I want! – user Oct 9 '12 at 20:20

The simplest solution would be:

#[[Ordering[#, -1]]] &@ tuples

• This returns {{4, 0}} rather than {4, 0} (which is why I use Extract) if that matters. – Mr.Wizard Oct 9 '12 at 20:23
• @Mr.Wizard Pffft... :) One can always use First/Last – rm -rf Oct 9 '12 at 20:30

Sort and SortBy[..., Identity] for equal-length lists (and possibly this condition can be loosen anyway) seems to do lexicographical ordering:

In:= data = RandomSample@DeleteDuplicates@Flatten[#, 1] &@
Table[{a, b}, {a, CharacterRange["a", "z"]}, {b,
CharacterRange["a", "z"]}];

In:= data // RandomSample[#, 3] &

Out= {{"r", "s"}, {"i", "m"}, {"o", "p"}}


So the max is just the last of such sorted list

In:= SortBy[data, Identity] // Last
Sort[data] // Last

Out= {"z", "z"}

Out= {"z", "z"}


For numerical data

In:= data2 =
RandomSample@DeleteDuplicates@Flatten[#, 1] &@
Table[{a, b}, {a, Range[1, 9]}, {b, Range[1, 9]}];

In:= SortBy[data2, Identity] // Last
Sort[data2] // Last

Out= {9, 9}

Out= {9, 9}