list manipulation - Using Position (which requires a pattern) in the same manner as Select (which requires a criterion)

I am using Mathematica7. I have a list of lists (creatively named list in the following sample code) containing data. I would like to find the positions of the elements that satisfy a particular criterion. However, Position takes a pattern as input, whereas Select takes a criterion as input.

Suppose I want to find the positions of all lists (i.e., sublists) whose first element is 1. The following code works (or so it seems), but it generates error messages as well:

list = {{1, "A"}, {1, "B"}, {2, "C"}};
Position[list, _?(#[[1]] == 1 &)]

The output looks correct: {{1},{2}}

But I also get the following error messages, which in a long computation seem to slow down Position:

Part::partd : Part specification List[[1]] is longer than depth of object.
Part::partd : Part specification List[[1]] is longer than depth of object.
Part::partd : Part specification [[1]][[1]] is longer than depth of object.
General::stop : Further output of Part::partd will be suppressed during this calculation.

Does my code indeed work properly? If so, why do I get the error messages? If not, how can I improve my code?

Answer

To understand why you're getting that error, try your code with _ as the pattern and see what elements are returned:

list[[Sequence @@ #]] & /@ Position[list, _]
(* {List, List, 1, "A", {1, "A"}, List, 1, "B", {1, "B"}, List, 2, "C", {2, "C"}, 
    {{1, "A"}, {1, "B"}, {2, "C"}}} *)

You can see that in your case, Position is walking down every branch and visiting every leaf of the expression tree and checking to see if the criterion fits. You can confirm that these results are indeed the leaves:

Level[list, -1, Heads -> True]
(* {List, List, 1, "A", {1, "A"}, List, 1, "B", {1, "B"}, List, 2, "C", {2, "C"}} *)

The last element is the entire expression itself. None of the elements in the above list except for elements of the original list have parts that are indexable as you've done in your pattern, which is why you get the error.

Once you understand this, you can now proceed to fix the errors and narrow down where position acts, namely:

• set Heads -> False so that you don't visit them


• look only at level 1 and not deeper/shallower levels


• narrow down the pattern to something more suitable (hint: you know the first element should be 1)

If you do these, you'll reach your desired solution (which Rojo and kguler have already answered). So going by the points above, you'd do something like,

Position[list, _?(First[#] == 1 &), {1}, Heads -> False]
(* {{1}, {2}} *)

which is the same as Rojo's answer. Now the pattern can be refined further and not require either the use of Heads -> False or the level {1}, and this leads you to kguler's answer:

Position[list, {1, ___}]
(* {{1}, {2}} *)

With experience, you'll recognize how to simplify and choose the right pattern. Note that in more complicated cases, you might have to operate at different levels or only at certain specific levels, etc., and you might have to specify the pattern and the level.