2
$\begingroup$

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?

$\endgroup$
  • $\begingroup$ The simplest solution would be: #[[Ordering[#, -1]]] &@ tuples $\endgroup$ – rm -rf Oct 9 '12 at 19:11
  • $\begingroup$ @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 $\endgroup$ – rm -rf Oct 9 '12 at 19:20
  • $\begingroup$ @rm-rf I think this is an achievable goal :-) $\endgroup$ – Leonid Shifrin Oct 9 '12 at 19:23
  • $\begingroup$ @rm sorry, I'm the king of low hanging fruit, it ain't happenin' :-p $\endgroup$ – Mr.Wizard Oct 9 '12 at 19:32
  • $\begingroup$ @rm okay, I waited 40 minutes -- with effort. $\endgroup$ – Mr.Wizard Oct 9 '12 at 20:12
3
$\begingroup$

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)

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

The simplest solution would be:

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

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}
$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.