Partition a list by count of a number

I want to take this list when the 2 appear 3 times

SeedRandom[1]
list = RandomChoice[{.2, .5, .3} -> {1, 2, 3}, 20]

{3,1,3,1,2,1,2,2,2,3,2,3,2,2,3,3,3,2,2,2}

Hope to get {{3, 1, 3, 1, 2, 1, 2, 2}, {2, 3, 2, 3, 2}, {2, 3, 3, 3, 2, 2},{2}}.I think GeneralUtilities`PartitionBy can help to do this,but I'm fail to do it.

i = 0; GeneralUtilities`PartitionBy[list, (If[# == 2, i++; 
    If[i == 4, i = 0]]; i === 3) &]

Will get nothing. Can anybody give a concise version? Of course, I will feel more happy if I get a GeneralUtilities`PartitionBy version. Because I have failed many times with it.

Answer

This problem is a variation of:

Applying my Split method:

list = {3,1,3,1,2,1,2,2,2,3,2,3,2,2,3,3,3,2,2,2};

Module[{n = 0}, Split[list, # != 2 || ++n < 3 || (n = 0) &]]

{{3, 1, 3, 1, 2, 1, 2, 2}, {2, 3, 2, 3, 2}, {2, 3, 3, 3, 2, 2}, {2}}

The obvious comparison is to march's similar code using SplitBy, and Kuba's Sow/Reap method:

SeedRandom[0]
list = RandomInteger[9, 500000];

Module[{i = 0}, SplitBy[list, ⌊1/3 If[# != 2, i, i++]⌋ &]] //
   Length // RepeatedTiming

Module[{i = 0}, Sow[#, ⌊If[# == 2, i++, i]/3⌋] & /@ list // Reap // Last] //

   Length // RepeatedTiming

Module[{n = 0}, Split[list, # != 2 || ++n < 3 || (n = 0) &]] // 
   Length // RepeatedTiming

{1.84, 16576}

{1.137, 16576}


{0.305, 16576}

So my code is at least several times faster than other manual index methods.

However Split itself is not very efficient, cf. Find continuous sequences inside a list.
Applying those faster methods here:

splitEvery[list_, x_, n_Integer] := (
  Unitize[list - x]
    // SparseArray[#, Automatic, 1] &
    // #["AdjacencyLists"][[n ;; ;; n]] &
    // {Prepend[# + 1, 1], Append[#, -1]} &

    // MapThread[Take[list, {##}] &, #] &
 )

splitEvery[list, 2, 3] // Length // RepeatedTiming

{0.021, 16576}

This is nearly an order of magnitude faster than even Kuba's Partition method.
(UpTo doesn't work in v10.1 so I use an older equivalent.)

Flatten /@ Partition[Split[list, #1 =!= 2 &], 3, 3, 1, {}] // 
  Length // RepeatedTiming

{0.194, 16576}

And as usual with list partitioning problems it is the partitioning itself that takes the most time. If we can work with an interval list instead:

intervalEvery[list_, x_, n_Integer] := (
  Unitize[list - x]
    // SparseArray[#, Automatic, 1] &

    // #["AdjacencyLists"][[n ;; ;; n]] &
    // {Prepend[# + 1, 1], Append[#, -1]} &
    // Transpose
 )

intervalEvery[list, 2, 3] // Length // RepeatedTiming

{0.00343, 16576}

The output of that last function:

intervalEvery[{3,1,3,1,2,1,2,2,2,3,2,3,2,2,3,3,3,2,2,2}, 2, 3]

{{1, 8}, {9, 13}, {14, 19}, {20, -1}}