Running count starting over when the counted value is not present previous date

Hi Anonymous  and Anonymous ,
you might be interested in an approach that runs the full dataset in seconds instead of minutes:

let
fnIdx = 
(myTable as table) =>
let
partition = Table.Buffer(myTable),
dates = AllDatesWthIndex,
    #"Merged Queries" = Table.NestedJoin(partition, {"Date"}, dates, {"Date"}, "Changed Type", JoinKind.LeftOuter),
    #"Expanded Changed Type" = Table.ExpandTableColumn(#"Merged Queries", "Changed Type", {"Index"}, {"Index"}),
    Custom1 = Table.ToColumns(#"Expanded Changed Type"),
    IndexedTable = Table.Buffer( Table.FromColumns(Custom1 & { {null} & List.RemoveLastN(List.Last(Custom1),1) }, {"ID", "Date", "Index", "PrevIndex"}) ),
    Initial = IndexedTable{0} & [Counter = 0, Idx = 1],
    Custom3 = List.Generate( ()=> Initial,
        each [Counter] < Table.RowCount(IndexedTable),
        each [ Counter = [Counter] + 1,
               Idx = if IndexedTable[Index]{Counter} - IndexedTable[PrevIndex]{Counter} = 1 then [Idx] + 1 else 1
               ]),
    #"Converted to Table" = Table.FromList(Custom3, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
    #"Expanded Column1" = Table.ExpandRecordColumn(#"Converted to Table", "Column1", {"Idx"}, {"Idx"})[Idx],
    Custom2 = Table.FromColumns( Table.ToColumns( IndexedTable ) & { #"Expanded Column1" })
in
    Custom2,

    Origine = dataSample,
    Selection = Table.FirstN(Origine,CountRecordsImke),
    AllDates=Table.Buffer( Table.Distinct(Table.SelectColumns(Selection, {"Date"})) ),
    AllDatesWthIndex = Table.AddIndexColumn(AllDates, "Index", 0, 1, Int64.Type),
    AllProducts = Origine,
    #"Grouped Rows" = Table.Group(Selection, {"ProductID"}, {{"ProductPartition", each _}}),
    #"Added Custom" = Table.AddColumn(#"Grouped Rows", "Custom", each fnIdx([ProductPartition])),
    #"Expanded Custom" = Table.ExpandTableColumn(#"Added Custom", "Custom", {"Column2", "Column5"}, {"Date", "Index"}),
    #"Removed Columns" = Table.RemoveColumns(#"Expanded Custom",{"ProductPartition"}),
    #"Changed Type" = Table.TransformColumnTypes(#"Removed Columns",{{"Date", type date}, {"Index", Int64.Type}, {"ProductID", type text}})
in
    #"Changed Type"

It runs the logic on the level of the individual ProductIDs like I've described here: Performance Tip: Partition your tables at crossjoins where possible - PowerQuery PowerBI – The BIccountant
and uses a shifted index method which also makes comparisons very fast:  Fast and easy way to reference previous or next rows in Power Query or Power BI – The BIccountant

Power Query doesn't have to be slow if you do it the right way. I've collected some tipps and tricks to improve performance here: Speed/Performance aspects – The BIccountant

try this using small tables initially and check run times. if it works for you with small tables and doesn't take too long, increase the size of the tables as you go.

let
    Origine = Table.FromRows(Json.Document(Binary.Decompress(Binary.FromText("i45WclTSUTLTM9QzMjAyUIrViVZyQhdwRhcAabFE12KJrgVDhaEhuiGGJhhqTNCNQRVxwRABm2OKoQshEgsA", BinaryEncoding.Base64), Compression.Deflate)), let _t = ((type nullable text) meta [Serialized.Text = true]) in type table [prid = _t, date = _t]),
    
    d=Origine[date],
    all = Table.Group(Origine, {"date"}, {{"all", each _[prid]}})[all],
    allprid=List.Union(all),
    nprid=List.Count(allprid),
    rec0=Record.FromList(List.Repeat({0},nprid),allprid),
    lg=List.Generate(
                ()=>rec0&[n=0],
                each [n]<=List.Count(all),
                each   Record.TransformFields(_, List.Transform(allprid, (p)=> {p, (x)=>if List.Contains(all{[n]},p) then x+1 else 0}))&[n=[n]+1],
    each  Record.ToTable(Record.RemoveFields(_,"n"))
    ),

   tc=Table.Combine(lg),
    #"Filtrate righe" = Table.SelectRows(tc, each ([Value] <> 0)),
    ttc=Table.FromColumns({d}&Table.ToColumns(#"Filtrate righe"),{"date","grpid","idx"})
in
    ttc

let
    Origine = Table.FromRows(Json.Document(Binary.Decompress(Binary.FromText("i45WclTSUTLTM9QzMjAyUIrViVZyQhdwRhcAabFE12KJrgVDhaEhuiGGJhhqTNCNQRUB6zLFUIMQiQUA", BinaryEncoding.Base64), Compression.Deflate)), let _t = ((type nullable text) meta [Serialized.Text = true]) in type table [prid = _t, date = _t]),
    #"Raggruppate righe1" = Table.Group(Origine, {"date"}, {{"all", each _[prid]}}),
    #"Rimosse altre colonne" = Table.SelectColumns(#"Raggruppate righe1",{"all"}),
    all = #"Rimosse altre colonne"[all],

    lg=List.Generate(
                ()=>[A=0,B=0,C=0,n=0],
                each [n]<=List.Count(all),
                each   [A=if List.Contains(all{[n]},"A")then [A]+1 else 0,
                        B=if List.Contains(all{[n]},"B")then [B]+1 else 0, 
                        C=if List.Contains(all{[n]},"C")then [C]+1 else 0,
                        n=[n]+1],
    each  Table.Transpose(Table.DemoteHeaders(Table.FromRecords({_[[A],[B],[C]]}))
    )),

   tc=Table.Combine(lg),
    #"Filtrate righe" = Table.SelectRows(tc, each ([Column2] <> 0))
in
    #"Filtrate righe"

Try using a pattern like this. it's tangled (and for this reason I suggest you toi test carefully the script), but I can't find anything simpler and more direct for the moment.