# 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 – R. M. 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 – R. M. 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)

-
+1 Thank you kind wizard! – user Oct 9 '12 at 20:14
@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

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

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

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

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


So the max is just the last of such sorted list

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

Out[56]= {"z", "z"}

Out[57]= {"z", "z"}


For numerical data

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

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

Out[60]= {9, 9}

Out[61]= {9, 9}

-

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 – R. M. Oct 9 '12 at 20:30