Say I have a list x={2,4,6,8,10} and I want to find out the positions of the elements that are greater than 7.
Select[x, #>7&] gives the elements themselves, and Position[x,8] gives the position of the elements satisfying one of the possible criteria, but what I am looking for would be a mix of the two returning {4,5}.
Any suggestions?
Position[{2, 4, 6, 8, 10}, _?(# > 7 &)] does the job. Apply Flatten[] if need be.
As noted by Dan in a comment alluding to Brett's answer, using the level-specification argument of Position[] might sometimes be needed, if the numbers are not Reals, Rationals or Integers.
Position[{2, 4, 6, 8, 10} - 6, _?Positive]
– ogerard
Jan 18 '12 at 18:15
As many have pointed out, Position can be used for this, but you may want to take care since Position will quite happily go into things you might not expect it to.
In[17]:= Position[Sin[{2, 4, 6, 8, 10}], _?(# > 0.5 &)]
Out[17]= {{1, 1}, {1}, {2, 1}, {3, 1}, {4, 1}, {4}, {5, 1}}
Note that we got match from the 4 in Sin[4] being bigger than 0.5, even though numerically Sin[4] around -0.75. We can use a level specification to limit the depth at which we're inspecting elements:
In[18]:= Position[Sin[{2, 4, 6, 8, 10}], _?(# > 0.5 &), 1]
Out[18]= {{1}, {4}}
Position can take very generic patterns. Here we ask for the position of values in the list given that they are larger than 7.
x={2,4,6,8,10};
In[11]:= Position[x,val_/;val>7]
Out[11]= {{4},{5}}
A couple of options come to mind, but I think Position can be manipulated into giving you what you want. The key is to use a PatternTest, as follows
Position[x, _?(#>7&)] // Flatten
returns
{4, 5}.
For another variant, MapIndexed can be used directly
MapIndexed[If[#1 > 7, #2, Unevaluated[Sequence[]]] &, {2, 4, 6, 8, 10}]
which relies on the properties of an empty Sequence in a List. The Unevaluated is necessary to unsure that you don't get Null in the list.
For really big list or a rectangular matrix I would suggest the following approaches:
list = RandomInteger[20, 1000000];
f1[list_,num_] := SparseArray[UnitStep[list-(num + 1)]]["NonzeroPositions"];
f2[list_,num_] := Position[UnitStep[list-(num + 1)], 1];
speed comparison relative to accepted answer:
r1 = f1[list,7];//AbsoluteTiming;
(* {0.0274773, Null} *)
r2 = f2[list,7];//AbsoluteTiming
(* {0.201376, Null}; *)
r3 = Position[list, _?(# > 7 &)]; // AbsoluteTiming (* accepted answer *)
(* {0.73195, Null} *)
r1 === r2 === r3
(* True *)
f1 is ~ 36 times faster than the combination of Position and PatternTest
Position is certainly the best for the job, but for the sake of completeness, you can do this in a way similar to Select:
DeleteCases[MapIndexed[If[#1 > 7, #2] &, {2, 4, 6, 8, 10}], Null]
While inefficient when you select only on content, this form allows to mix criteria on the content and position.
As others have said, Position does the job:
lst = {2, 4, 9, 6, 8, 10};
posns=Position[lst, _?(# > 7 &)]
(*
{{3}, {5}, {6}}
*)
This is now in the appropriate form for Extract:
Extract[lst, posns]
(*
{9, 8, 10}
*)
PositionIndex[UnitStep[x - 7]][1]
is another possibility
PositionIndex :) +1 !
– Ali Hashmi
Aug 09 '17 at 19:33
Here's another, more general (but probably less performant) solution based on PositionIndex:
Catenate@KeySelect[PositionIndex[{2, 4, 6, 8, 10}], # > 7 &]
(* {4, 5} *)
Version 13.2 introduced PositionLargest
list = {2, 4, 6, 8, 10}
PositionLargest[list, Length @ Select[# > 7 &] @ list]
{{5}, {4}}
Compare to:
ReverseSort @ Position[list, _?(# > 7 &)]
{{5}, {4}}
To see the result in descending order might be desirable or not.
Pickto enhance performance:x = {2, 4, 6, 8, 10}; Pick[Range[Length[x]], Sign[x - 6], 1]. – Sasha Jan 18 '12 at 20:46PatternTestrather thanCondition. Are any performance differences or is it just what people are used to? – Mike Honeychurch Jan 18 '12 at 22:15Conditionfor ease of naming elements to work with them. – Brett Champion Jan 19 '12 at 01:05{2, 4, 6, 8, 10} // Position[_?(GreaterThan[7])]– AsukaMinato Oct 13 '23 at 13:02