Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

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?

share|improve this question
    
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
show 1 more comment

3 Answers

up vote 3 down vote accepted

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)

share|improve this answer
    
+1 Thank you kind wizard! –  Oliver 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! –  Oliver Oct 9 '12 at 20:20
add comment

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}
share|improve this answer
add comment

The simplest solution would be:

#[[Ordering[#, -1]]] &@ tuples
share|improve this answer
    
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
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

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