get positions satisfying multiple criteria

Question

Given a list L. It is mathematically proven that there is no element in L matching 2 or more patterns in patt1/patt2/patt3/patt4/.../patt10. (Note that one can express a criteria/test into a pattern. I think it is safe to think as 'criteria' instead of 'pattern', if you want.)

Now I want get
positions matching patt1,
positions matching patt2,
positions matching patt3,
positions matching patt4,
...
positions matching patt10.

One method is

{Position[L,patt1],Position[L,patt2],Position[L,patt3],...,Position[L,patt10]}

But, it looks for each element 10 times.

Maybe we can increase the performance by

1. get positions matching patt1
2. except positions matching patt1, get positions matching patt2.
3. except positions matching patt1,2, get positions matching patt3.
4. except positions matching patt1,2,3, get positions matching patt4. ...
5. except positions matching patt1,2,3,...,10 get positions matching patt10.

Or we may increase the performance by..

'take the first element of L, check whether it matches patt1,patt2,patt3,patt4,...,patt10 in order. If it matched patt3, for example, then record 'the first element of L matched patt3' and then go to the next element. Check whether it matches patt1,patt2,patt3,patt4,...,patt10 in order. This time, for example, it doesn't match any pattern. Then go to the next element. It goes on like this.

The question is related to the built-in command GatherBy, but for GatherBy, we cannot restrict the range of values. (always all values.) And the output of GatherBy does not show values.

First I am not sure which method is the best (Because thinking and reality are always different.) Considering the performance, are there any commonly used techniques for these problem?

I made a problem in a hurry to give an example :

A = RandomInteger[{1, 100}, 1000];
B = RandomInteger[100, #] & /@ A;

The problem is :
Select level-1 positions in B, whose length is 2
Select level-1 positions in B, whose length is 3
Select level-1 positions in B, whose length is 5
Select level-1 positions in B, whose length is 7
...
Select level-1 positions in B, whose length is 97

There may be much better example though.

Answer 1

Granted that your example may not be actually representative of what you ultimately want, here's an attempt:

(* beefed up your list a bit *)
B = Table[ConstantArray[1, RandomInteger[1000]], 1000000]

PositionIndex seems like it will be interesting to you. We can first map the property you want to check. We'll start with a simplification: just Length.

AbsoluteTiming[PositionIndex[Length /@ B]] // Short
(* {0.232473,<|908->{1,657,1211,1595,<<967>>,996367,997446,998904,999600},<<999>>,35->{<<1>>}|>} *)

We can select just the ones with the desirable attribute with KeySelect:

AbsoluteTiming[KeySelect[PositionIndex[Length /@ B], PrimeQ]] // Short
(* {0.228517,<|463->{5,2118,3597,3981,<<961>>,995791,996307,997621,997842},<<166>>,193->{<<1>>}|>} *)

Alternatively, we can first map the property we want and then use PositionIndex:

PrimeLengthOrOtherwise[arg_] :=
  Which[
    PrimeQ[Length@arg], Length@arg,
    True, -1];
AbsoluteTiming[PositionIndex[PrimeLengthOrOtherwise /@ B]] // Short
(* {1.00528,<|-1->{1,2,3,4,6,<<832394>>,999994,999995,999996,999998,999999},<<167>>,19-><<1>>|>} *)

You could use something other than -1 if it would be clearer. It's pretty easy to now ignore that one "otherwise" value, so I think this is still in the spirit of your question and addresses your objection to GatherBy.

I don't know if I scaled the problem sufficiently, but hopefully the timings will give you some idea of what sort of performance you can expect if your real scenario is close to this toy example.