Selecting a sublist based on Length

Question

If you have a simple list of lists as follows:

test = {{1, 2}, {4, 5, 6, 7}, {5, 4, 3}}

How do you ask Mathematica to return the sublist of greatest length?

I've been trying to write a Select command using pure functions without success.

Answer 1

One possibility:

test = {{1, 2}, {4, 5, 6, 7}, {5, 4, 3}};
lengths = Length /@ test;
max = Max[lengths];
pos = Position[lengths, max];
Extract[test, pos]

gives:

{{4, 5, 6, 7}}

If there are two or more sublists that are of 'greatest length' those will also be returned.

Answer 2

Reasonably fast and quite direct, but returns only one list if there are ties:

Last@SortBy[test, {Length}]

More whimsical but catching ties (warning: infix ahead):

test ~SortBy~ Length ~SplitBy~ Length // Last

---

Since Arnoud's method tests the fastest for functions that include ties, here is my terse version of it:

longest[L_List] := L ~Extract~ Position[#, Max@#] &[Length /@ L]

Answer 3

Sort automatically sorts by length, so it is as simple as

Last@Sort@test

Answer 4

A solution using Select is :

max = Max[Length /@ test];
Select[test, Length[#] == max &]

This solution and Arnoud's, as well as J.M.'s ones, are better if we have more lists of maximal length. E.g. for

test = {{1, 2}, {4, 5, 6, 7}, {5, 4, 3}, {2, 2, 3, 4}};

this returns

 {{4, 5, 6, 7}, {2, 2, 3, 4}}

Edit

Since one would like to know performance issues of various methods I've made a comparison of presented approaches (only for methods which return all longest sublists) on a very long list from the best to the slowest. On smaller lists proportions of timings may slightly change, but in general, the order is preserved.

longlist = Table[RandomInteger[{-10, 10}, RandomInteger[100]], {10^6}];

{lengths = Length /@ longlist;                                (*Arnoud*)
 max = Max[lengths];
 pos = Position[lengths, max];
 Extract[longlist, pos];} // Timing
(*
==>  {0.422, {Null}}
*)
{max = Max[Length /@ longlist];                               (*Artes*)
Select[longlist, Length[#] == max &];} // Timing
(*
==>  {1.685, {Null}}
*)
Pick[longlist, #, Max[#]] &[Length /@ longlist]; // Timing     (*J.M.*)
(*
==>  {2.012, Null}
*)
longlist~SortBy~Length~SplitBy~Length // Last; // Timing     (*Spartacus*) 
(*
==>  {7.098, Null}
*)
allMaxBy[longlist, Length]; // Timing                        (*Szabolcs*)
(*
==>  {7.144, Null}
*)

Answer 5

Alternatively:

test = {{2, 3}, {1, 2}, {4, 5, 6, 7}, {5, 4, 3}, {8, 9, 10, 11}};

Pick[test, #, Max[#]] &[Length /@ test]
{{4, 5, 6, 7}, {8, 9, 10, 11}}

Answer 6

If you only want one item from the resulting list, you can use the two-argument form of Ordering instead of Sort to be a bit more efficient:

test[[Ordering[test, -1]]]

---

biglist = 
  Table[RandomInteger[10, RandomInteger[100]], {10^5}];

Timing[biglist[[Ordering[biglist, -1]]]]

(*
==> {0.006476, {{10, 10, 10, 3, 4, 7, 4, 3, 9, 8, 8, 1, 2, 1, 5, 
   10, 10, 10, 9, 4, 6, 6, 9, 1, 2, 10, 8, 3, 0, 9, 1, 2, 5, 1, 1, 2, 
   7, 8, 9, 10, 8, 4, 8, 4, 7, 9, 3, 4, 5, 1, 6, 6, 4, 5, 8, 6, 3, 2, 
   6, 4, 9, 9, 9, 7, 1, 10, 4, 2, 10, 8, 0, 8, 1, 0, 9, 10, 7, 4, 5, 
   3, 6, 6, 6, 4, 2, 3, 1, 4, 9, 6, 5, 1, 8, 10, 0, 1, 3, 5, 10, 4}}}
*)

Timing[Last@Sort@biglist]

(*
==> {0.170369, {10, 10, 10, 3, 4, 7, 4, 3, 9, 8, 8, 1, 2, 1, 5, 
  10, 10, 10, 9, 4, 6, 6, 9, 1, 2, 10, 8, 3, 0, 9, 1, 2, 5, 1, 1, 2, 
  7, 8, 9, 10, 8, 4, 8, 4, 7, 9, 3, 4, 5, 1, 6, 6, 4, 5, 8, 6, 3, 2, 
  6, 4, 9, 9, 9, 7, 1, 10, 4, 2, 10, 8, 0, 8, 1, 0, 9, 10, 7, 4, 5, 3,
   6, 6, 6, 4, 2, 3, 1, 4, 9, 6, 5, 1, 8, 10, 0, 1, 3, 5, 10, 4}}
*)

Answer 7

I sometimes use a little function MaxBy, made to be analogous with SortBy:

MaxBy[list_, fun_] := list[[First@Ordering[fun /@ list, -1]]]

You need the largest element by length, so you can evaluate

MaxBy[data, Length]

Note: this is based on the same principle as @Brett's solution, but it is slower. @Brett's and @R.M's exploit the fact that Mathematica sorts by length by default, while my solution explicitly uses Length. I still think it's a useful little function, so I shared it again.

The problem with MaxBy is that it only returns a single element, while there may be more than one list of the same length. Here's a somewhat slow but simple implementation that returns all maxima:

allMaxBy[data_, fun_] := Last@SplitBy[SortBy[data, fun], fun]