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

try these versions, should perfom better (and the second better than first)

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 = List.Buffer(Table.Group(Origine, {"date"}, {{"all", each _[prid]}})[all]),
    nall=List.Count(all),
    allprid=List.Buffer(List.Union(all)),
    nprid=List.Count(allprid),
    rec0=Record.FromList(List.Repeat({0},nprid),allprid),
    lg=List.Generate(
                ()=>rec0&[n=0],
                each [n]<=nall,
                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("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 = List.Buffer(Table.Group(Origine, {"date"}, {{"all", each _[prid]}})[all]),
    nall=List.Count(all),
    allprid=List.Buffer(List.Union(all)),
    nprid=List.Count(allprid),
    rec0=Record.FromList(List.Repeat({0},nprid),allprid),
    lg=List.Generate(
                ()=>rec0&[n=0],
                each [n]<=nall,
                each   Record.TransformFields(_, List.Transform(allprid, (p)=> {p, (x)=>if List.Contains(all{[n]},p) then x+1 else 0}))&[n=[n]+1]
    ),
    lglb=List.Buffer(lg),
    tc=Table.Combine(List.Transform(lglb, each Record.ToTable(_))),
    #"Filtrate righe" = Table.SelectRows(tc, each ([Value] <> 0 and [Name]<>"n")),
    ttc=Table.FromColumns({d}&Table.ToColumns(#"Filtrate righe"),{"date","grpid","idx"})
in
    ttc

PS

I came up with a different idea on how to do it, but I need time to implement it. In this case without using the list.generate function which works one record at a time and therefore could be much faster.

PPS

If you can upload a table with your productIDs and dates, I can do some tests. I don't think publishing productIDs and a list of dates is a problem (since they are just numeric codes), is it? eventually you can also "encode" them and dates by removing or adding something to all.

....

this adds the code to populate the table with the date column

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]),
    
    d=Origine[date],
    #"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)),
    ttc=Table.FromColumns({d}&Table.ToColumns(#"Filtrate righe"),{"date","grpid","idx"})
in
    ttc

as for the general problem, you should provide some more detailed examples (with fake data).

you should explain better in the more general cases the rule of formation of groups.

do you confirm, for example, that the productid groups to be considered are identified as those associated with each date?

Finally, if you explained more generally what you start from and what you want to achieve, perhaps we could find a different way from that of having to index the products in this complicated way.