How to find all the positions of max value of a list efficiently?

Question

For Example, list=RandomInteger[{1,100},2000]. Yes,I know Position[list,Max[list]] can do. But it's based on pattern matching! Ordering[list,-1] could find one position but not all. So how to find all the positions of max value of list in a more efficient way?Thank you.

Answer 1

A fast uncompiled alternative without pattern matching is to use the NonzeroPositions property of SparseArray, as long as you're dealing with numerical data.

list = RandomInteger[{1, 100}, 10^7];

SparseArray[Unitize[list - Max[list]] - 1]["NonzeroPositions"]; // RepeatedTiming
(* 0.0855 *)

Position[list, Max[list]] // RepeatedTiming
(* 0.509 *)

compPos[list, Max[list]] // RepeatedTiming (* Marius' solution *)
(* 0.0366 *)

SparseArray[Unitize[list - Max[list]], Automatic, 1][
   "NonzeroPositions"]; // RepeatedTiming (* MichaelE2's solutions *)
(* 0.0663 *)

Answer 2

For a 1D list you can also use

Pick[Range@Length@list, list, Max@list]

Answer 3

For a one-dimensional list:

compPos = 
 Compile[{{list, _Integer, 1}, {max, _Integer}},
  Block[{copy = list, i = 1},
   Do[
    If[
     list[[j]] == max, copy[[i++]] = j],
    {j, Length[list]}];
   copy[[1 ;; i - 1]]
  ], 
   CompilationTarget -> "C"
  ];

Though I think Position is a good non-compiled alternative in this case, since the "pattern" you use is a number. There won't be any useless matches to this pattern.

Performance Test

list = RandomInteger[{1, 100}, 10^7];
Position[list, Max[list]] // AbsoluteTiming // First

0.8220470

compPos[list, Max[list]] // AbsoluteTiming // First

0.0830048

Obviously, 10 times speed-up

Answer 4

It is possible to Compile Position itself for machine types (e.g. Integer or Real):

posmax = Compile[{{list, _Integer, 1}}, Position[list, Max@list] ];

Performance:

x = RandomInteger[{1, 100}, 10^7];

Position[x, Max@x] // Timing // First

posmax[x] // Timing // First

0.44754
0.0736

With a C compiler this should be faster still; I'll find out in a few minutes if the Microsoft compiler installs correctly.

Answer 5

My proposal:

Nearest[list -> Automatic, Max[list], {All, 0.5}]

Among non-C solutions, it's slightly faster than Pickett's, but slower than Simon Woods's.

list = RandomInteger[{1, 100}, 10^7];

Needs["GeneralUtilities`"];

Nearest[list -> Automatic, Max[list], {All, 0.5}] // AccurateTiming
SparseArray[Unitize[list - Max[list]] - 1]["NonzeroPositions"] // AccurateTiming (* P. *)
Pick[Range@Length@list, list, Max@list] // AccurateTiming                       (* S.W. *)
(*
  0.0925321
  0.121649
  0.0403738
*)

I have to say I was surprised, because I'd become accustomed to the superiority of SparseArray. But Nearest has been improved in V10. For instance, it takes 2.5 sec on my machine in V9.0.1!! Wow.

Answer 6

If you don't mind using an undocumented internal function, you could try using Random`Private`PositionsOf:

list = RandomInteger[100, 10^7];

r1 = Random`Private`PositionsOf[list, Max[list]]; //RepeatedTiming
r2 = Pick[Range@Length@list, list, Max@list]; //RepeatedTiming

r1 === r2

{0.011, Null}

{0.037, Null}

True

Answer 7

I think this works Ordering[dat, -Count[dat, Max[dat]]] but it is actually slower than Position[dat,Max[dat]]

This also works, but again, it's still slower

pos1[list_, max_] := Block[{i = 1, l = Length[list]},
  Last[Reap[While[i <= l,
  If[list[[i]] == max, CompoundExpression[Sow[i], i++], i++]]]]]

... unfortunately so is this more compact solution

pos2[list_, max_] := MapIndexed[If[#==max,Sow@#2,##&[]]&,list]

You could try compiling them; I can't use Compile with CompilationTarget->"C" on my system for various reasons. I'd just stick with using Position.

Answer 8

Since V 13.2 we have PositionLargest and PositionSmallest

list = RandomInteger[{1, 100}, 2000];
PositionLargest[list]

{55, 99, 248, 614, 654, 749, 894, 967, 1029, 1144, 1209, 1392, 1866, 1893, 1932}

It is comparatively fast:

list = RandomInteger[{1, 100}, 10^7];
PositionLargest[list]; // Timing // First

0.173024

Position[list, Max @ list] // Timing // First

0.346482

Answer 9

Using PositionIndex: (introduced 9th July 2014)

SeedRandom[1];
list = RandomInteger[{1, 10}, 10^7];
PositionIndex[list][Max[list]]; // RepeatedTiming

{0.155408, Null}