Let's say I have the following list:
L = {2,4,6,8,10}
How can I get Mathematica to find the index position of the first value in the list that is over 4 (6 in this case). I tried Position[L, L > 4], but this gave no output. Any help would be appreciated.
In version 10 there is a new function FirstPosition:
L = {2, 4, 6, 8, 10};
FirstPosition[ L, x_ /; x > 4]
{3}
The second argument of Position as welll as of FirstPosition is a pattern, so this would yield what you seemed to expect:
Position[ L, x_ /; x > 4]
{{3}, {4}, {5}}
FirstPosition will apply at all levels (including the list as a whole) and at the list head: FirstPosition[{2, 4, 6, 8, 10}, x_ /; (Print[x]; x > 12)] prints List, 2, 4, 6, 8, 10, {2,4,6,8,10}. To get the expected behavior of only iterating over the list elements, you have to do something like FirstPosition[{2, 4, 6, 8, 10}, x_ /; x > 12, Null, {1}, Heads -> False] (or make the pattern more restrictive).
$\endgroup$
Commented
Jan 7, 2023 at 22:19
Just for interest:
pos[lst_] := First@Position[lst, _?(# > 4 &)];
fp[lst_] := FirstPosition[lst, _?(# > 4 &)];
nw[lst_] := NestWhile[# + 1 &, 1, lst[[#]] <= 4 &]
w[lst_] := Module[{n = 1}, While[lst[[n]] <= 4, n++]; n]
Comparing:
Needs["GeneralUtilities`"]
bmp = Quiet@
BenchmarkPlot[{pos, fp, nw, w}, RandomInteger[{-10, 10}, #] &,
PowerRange[10, 1000000], "IncludeFits" -> True]
NestWhile or While are more efficient than FirstPosition? I guess it is just an artefact of very special data you work with. In more general situation FirstPosition should be definitely faster, otherwise I can't see any argument for introducing this function to the system.
$\endgroup$
NestWhile or While. So it should be quite simple to point out different data where FirstPosition is much better even for long lists. This is what I meant in my former comment.
$\endgroup$
FisrtPosition has better performance than other methods?
$\endgroup$
Commented
Nov 4, 2014 at 14:41
RandomInteger[{-10, 10}, n] i.e. as a list it is of length $n$ (it may be whatever you want) but there are only $21$ different elements. If you played with e.g. long lists of primes with special properties and you were to choose a very special number then FirstPosition should be much better. I have no time to provide appropriate tests but I guess now it should be clear what I mean. I believe you can find a good example otherwise I'll try tomorow.
$\endgroup$
L = {2, 4, 6, 8, 10};
f = 1 + LengthWhile[#, # <= 4 &] &;
(* or f = 1 + LengthWhile[#, Not[# > 4] &] &; *)
f@L
(* 3 *)
More generally,
f2 = Function[{lst, t}, 1 + LengthWhile[lst, Not[# > t] &]];
f2[L, 4]
(* 3 *)
