Top Player by Group Average

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Group = Table.Group(
    Source, 
    "Group", 
    {
      "Player", 
      each Table.Sort(
        Table.AddColumn(_, "P", each if [Matches] > 9 then - [Total Points] / [Matches] else null), 
        "P"
      )[Player]{0}
    }
  )
in
  Group

let
  Source = Excel.CurrentWorkbook(){[Name = "Input"]}[Content], 
  Solution = Table.Group(
    Table.AddColumn(
      Table.SelectRows(Source, each [Matches] >= 10), 
      "Avg", 
      each [Total Points] / [Matches]
    ), 
    {"Group"}, 
    {{"Player", each List.Last(Table.Sort(_, "Avg")[Player])}}
  )
in
  Solution

let
  Source = Excel.CurrentWorkbook(){[Name = "data"]}[Content], 
  Average = Table.AddColumn(Source, "Avg", each [Total Points] / [Matches]), 
  Return = Table.Group(
    Average, 
    "Group", 
    {"Player", each Table.Max(Table.Sort(_, {"Avg", 1}), {(f) => f[Matches] >= 10, "Avg"})[Player]}
  )
in
  Return

let
  Source = Table.SelectRows(Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], each [Matches] > 9), 
  Sol = Table.Group(
    Source, 
    {"Group"}, 
    {
      {
        "Player", 
        each 
          let
            a = Table.AddColumn(_, "Tot", each [Total Points] / [Matches]), 
            b = Table.Max(a, "Tot")[Player]
          in
            b
      }
    }
  )
in
  Sol

let
  Fonte = Tabela1, 
  gp = Table.Group(
    Fonte, 
    {"Group"}, 
    {
      {
        "Contagem", 
        each [
          a = Table.SelectRows(_, each [Matches] > 9), 
          b = List.Max(Table.AddColumn(a, "media", each [Total Points] / [Matches])[media]), 
          c = Table.SelectRows(a, each ([Total Points] / [Matches]) = b)
        ][c]
      }
    }
  ), 
  res = Table.ExpandTableColumn(gp, "Contagem", {"Player"})
in
  res

let
  Source = Table.SelectRows(
    Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
    each [Matches] >= 10
  ), 
  AddAvgPts = Table.AddColumn(Source, "AvgPts", each [Total Points] / [Matches]), 
  Group = Table.Group(
    AddAvgPts, 
    {"Group"}, 
    {
      {
        "All", 
        each _, 
        type table [
          Group = text, 
          Player = text, 
          Matches = number, 
          Total Points = number, 
          AvgPts = number
        ]
      }, 
      {"MaxAvgPts", each List.Max([AvgPts]), type number}
    }
  ), 
  Expand = Table.ExpandTableColumn(Group, "All", {"Player", "AvgPts"}, {"Player", "AvgPts"}), 
  FilterNClean = Table.SelectColumns(
    Table.SelectRows(Expand, each [AvgPts] = [MaxAvgPts]), 
    {"Group", "Player"}
  )
in
  FilterNClean

let
  Origen = Excel.CurrentWorkbook(){[Name = "Tabla1"]}[Content], 
  a      = Table.AddColumn(Origen, "Averege", each [Total Points] / [Matches]), 
  b      = Table.SelectRows(a, each [Matches] > 9), 
  c      = Table.Group(b, {"Group"}, {{"Aux", each _, type table}}), 
  d      = Table.AddColumn(c, "Player", each Record.Field(Table.Max([Aux], "Averege"), "Player")), 
  e      = Table.RemoveColumns(d, {"Aux"})
in
  e

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  FilteredRows = Table.SelectRows(Source, each [Matches] >= 10), 
  AddedCustom = Table.AddColumn(FilteredRows, "Points per Match", each [Total Points] / [Matches]), 
  Result = Table.Group(
    AddedCustom, 
    {"Group"}, 
    {
      {
        "Player", 
        each 
          let
            a = Table.Sort(_, {"Points per Match", Order.Descending})
          in
            a{0}[Player]
      }
    }
  )
in
  Result

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  FilteredRows = Table.SelectRows(Source, each [Matches] >= 10), 
  AddedCustom = Table.AddColumn(
    FilteredRows, 
    "Points per Match", 
    each [Total Points] / [Matches], 
    type number
  ), 
  SortedRows = Table.Buffer(
    Table.Sort(AddedCustom, {{"Group", Order.Ascending}, {"Points per Match", Order.Descending}})
  ), 
  GroupedRows = Table.Group(SortedRows, {"Group"}, {{"MaxPlayer", each _{0}[Player]}})
in
  GroupedRows

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Grouped = Table.Group(
    Source, 
    {"Group"}, 
    {
      {
        "Count", 
        each 
          let
            a = Table.AddColumn(
              Table.SelectRows(_, each [Matches] > 9), 
              "Average", 
              each [Total Points] / [Matches]
            )
          in
            Table.Sort(a, {{"Average", Order.Descending}})[Player]{0}
      }
    }
  )
in
  Grouped

=LET(g,A2:A13,u,UNIQUE(g),m,C2:C13,HSTACK(u,MAP(u,LAMBDA(a,XLOOKUP(99,D2:D13/m/(m>9)/(g=a),B2:B13,,-1)))))

=LET(g,A2:A13,u,UNIQUE(g),m,C2:C13,HSTACK(u,XLOOKUP(u,g&m/D2:D13/(m>9),B2:B13,,1)))

=LET(a,A2:A13,c,C2:C13,d,D2:D13,u,UNIQUE(a),HSTACK(u,XLOOKUP(MAP(u,LAMBDA(u,MAX(FILTER(d/c,(a=u)*(c>9))))),d/c,B2:B13)))

=LET(g,A2:A13,m,C2:C13,a,D2:D13/m,FILTER(A2:B13,a=MAP(g,LAMBDA(x,MAX(a*(m>9)*(g=x))))))

=LET(u,UNIQUE(A2:A13),m,C2:C13,HSTACK(u,VLOOKUP(u,SORTBY(A2:B13,-(m>9)*D2:D13/m),2,)))

=LET(e,A2:A13,c,C2:C13,l,UNIQUE(e),HSTACK(l,MAP(l,LAMBDA(a,TAKE(SORT(FILTER(HSTACK(B2:D13,D2:D13/c),(e=a)*(c>10)),4),-1,1)))))

=LET(c,C2:C13,r,SORT(SORTBY(A2:D13,c>9,-1,D2:D13/c,-1)),l,UNIQUE(A2:A13),HSTACK(l,XLOOKUP(l,TAKE(r,,1),INDEX(r,,2))))

=LET(c,C2:C13,r,SORTBY(A2:D13,c>9,-1,D2:D13/c,-1),l,UNIQUE(A2:A13),HSTACK(l,XLOOKUP(l,TAKE(r,,1),INDEX(r,,2))))

=LET(e,A2:A13,c,C2:C13,l,UNIQUE(e),HSTACK(l,MAP(l,LAMBDA(a,LET(v,FILTER(HSTACK(B2:D13,D2:D13/c),(e=a)*(c>10)),r,TAKE(v,,-1),XLOOKUP(MAX(r),r,TAKE(v,,1)))))))

=LET(a,A2:A13,b,B2:B13,c,C2:C13,d,D2:D13/c,e,UNIQUE(a),HSTACK(e,XLOOKUP(MAP(e,LAMBDA(x,MAX((a=x)*d*(c>9)))),d,b)))

=LET(T,A2:D13,TT,HSTACK(TAKE(T,,3),TAKE(T,,-1)/CHOOSECOLS(T,3)),S,SORT(TT,4,-1),U,UNIQUE(TAKE(SORT(S,,1),,1)),HSTACK(U,MAP(U,LAMBDA(A,TAKE(FILTER(CHOOSECOLS(S,2),(TAKE(S,,1)=A)*(CHOOSECOLS(S,3)>9)),1)))))

=LET(A,A2:A13,B,B2:B13,D,C2:C13,E,D2:D13,HSTACK(UNIQUE(A),MAP(UNIQUE(A),LAMBDA(x,FILTER(B,E/D=(MAX(FILTER((E/D),(A=x)*(D>10)))))))))

=LET(m, C2:C13, t, T2:T13, g, A2:A13, c, t/IF(m<10, 100,m), HSTACK(UNIQUE(g), MAP(UNIQUE(g), LAMBDA(x, INDEX(SORT(FILTER(HSTACK(A2:B13,c), g=x),3,-1),1,2)))))

=LET(_a, A2:A13,_c, C2:C13,_u, UNIQUE(_a),_m, (D2:D13/_c)*(_c>9)*(_a=TOROW(_u)), HSTACK(_u, TOCOL(REPT(B2:B13, 1/(_m=BYCOL(_m,LAMBDA(c,MAX(c))))), 3)))

=LET(a,SORTBY(A1:D13,IFERROR(D1:D13/C1:C13,0)),GROUPBY(INDEX(a,,1),INDEX(a,,2),LAMBDA(x,@TAKE(x,-1)),3,0,,INDEX(a,,3)>9))

=LET(
 _tbl, SORT(HSTACK(A2:D13, D2:D13 / C2:C13), {1, 5}, {1, -1}),
 Sortbl, FILTER(_tbl, CHOOSECOLS(_tbl, 3) >= 10),
 DROP(
 REDUCE(
 "",
 UNIQUE(TAKE(_tbl, , 1)),
 LAMBDA(a, v,
 VSTACK(
 a,
 LET(
 _ftbl, FILTER(Sortbl, CHOOSECOLS(Sortbl, 1) = v),
 FILTER(_ftbl, TAKE(_ftbl, , -1) = LARGE(TAKE(_ftbl, , -1), 1))
 )
 )
 )
 ),
 1,
 -3
 )
)

=LET(u,A2:D13,v,UNIQUE(TAKE(u,,1)),I,INDEX,cc,CHOOSECOLS,
a,SORT(FILTER(u,cc(u,3)>=10),1),
b,I(a,,4)/I(a,,3),
d,MAP(TOROW(v),LAMBDA(x,MAX(FILTER(b,TAKE(a,,1)=x)))),
e,TOCOL(BYCOL(IF(b=d,I(a,,2),""),CONCAT)),
VSTACK(A1:B1,HSTACK(v,e)))

=LET(
    a,
    A2:D13,
    b,
    FILTER(
        a,
        INDEX(
            a,
            ,
            3
        )>9
    ),
    c,
    SORTBY(
        TAKE(
            b,
            ,
            2
        ),
        INDEX(
            b,
            ,
            4
        )/INDEX(
            b,
            ,
            3
        ),
        -1
    ),
    g,
    TAKE(
        c,
        ,
        1
    ),
    CHOOSEROWS(
        c,
        XMATCH(
            UNIQUE(
                g
            ),
            g
        )
    )
)

=INDEX(UNIQUE($A$2:$A$13), ROWS($G$3:G3))

Formula for cell H3
=INDEX($B$2:$B$13, MATCH(AGGREGATE(14, 6, $D$2:$D$13/$C$2:$C$13/(( $A$2:$A$13=G3)*($C$2:$C$13>=10)), 1), $D$2:$D$13/$C$2:$C$13, 0))

=LET(_Keep, LAMBDA(x, FILTER(x, LEN(x))), 
_IsColMax, LAMBDA(x, x = BYCOL(x, LAMBDA(y, MAX(y)))), 
_MakeCols, LAMBDA(x, x = TOROW(UNIQUE(x))), _Keep(TOCOL(REPT(B2:B13, _IsColMax(D2:D13/C2:C13 * (C2:C13 >= 10) * _MakeCols(A2:A13))), , 1)))

=LET(a,C2:C13,b,SORT(FILTER(HSTACK(A2:B13,D2:D13/a),a>9),3,-1),c,UNIQUE(TAKE(b,,1)),HSTACK(c,VLOOKUP(c,b,2,0)))

=LET(
    q;
    D2:D13/C2:C13;
    w;
    UNIQUE(
        A2:A13
    );
    HSTACK(
        w;
        XLOOKUP(
            MAP(
                w;
                LAMBDA(
                    a;
                    LARGE(
                        IFERROR(
                            IF(
                                C2:C13>=10;
                                MAP(
                                    A2:A13;
                                    q;
                                    LAMBDA(
                                        x;
       &                                 y;
                                        XLOOKUP(
                                            a;
                                            x;
                                            y
                                        )
                                    )
                                );
                                ""
                            );
                            ""
                        );
                        1
                    )
                )
            );
            q;
            B2:B13
        )
    )
)

=LET(datas,FILTER(A2:D13,C2:C13>=10),scores,BYROW(datas,LAMBDA(a,CHOOSECOLS(a,4)/CHOOSECOLS(a,3))),groups,UNIQUE(CHOOSECOLS(datas,1)),
sorted,SORT(HSTACK(DROP(datas,0,-2),scores),3,-1),
HSTACK(groups,XLOOKUP(UNIQUE(CHOOSECOLS(datas,1)),CHOOSECOLS(sorted,1),CHOOSECOLS(sorted,2))))

=LET(m,A2:D13,d,HSTACK(m,INDEX(m,,4)/INDEX(m,,3)),b,SORT(UNIQUE(INDEX(d,,1))),HSTACK(b,MAP(b,LAMBDA(a,@CHOOSECOLS(SORT(FILTER(d,(INDEX(d,,1)=a)*(INDEX(d,,3)>9),""),5,-1),2)))))

=LET(s,SORT(FILTER(HSTACK(A2:D13,D2:D13/C2:C13),C2:C13>9),{1,5},{1,-1}),g,TAKE(s,,1),u,UNIQUE(g),
VSTACK(A1:B1,HSTACK(u,XLOOKUP(u,g,INDEX(s,,2)))))

=x)*($K$2:$K$13=MAX(FILTER($K$2:$K$13;($A$2:$A$13=x)*($L$2:$L$13=TRUE)))))))

=LET(a;UNICOS(A2:A13);b;FILTRAR(B2:D13;(C2:C13>=10)*(A2:A13=INDICE(a;1)));c;FILTRAR(B2:D13;(C2:C13>=10)*(A2:A13=INDICE(a;2)));d;FILTRAR(B2:D13;(C2:C13>=10)*(A2:A13=INDICE(a;3)));e;APILARH(a;APILARV(BUSCARX(PROMEDIO(INDICE(b;;3));INDICE(b;;3);INDICE(b;;1);;1);BUSCARX(PROMEDIO(INDICE(c;;3));INDICE(c;;3);INDICE(c;;1);;1);BUSCARX(PROMEDIO(INDICE(d;;3));INDICE(d;;3);INDICE(d;;1);;1)));e)

=LET(
_table,A2:D13,
_averages,D2:D13/C2:C13,
_averagetable,HSTACK(_table,_averages),
_filteredtable,FILTER(_averagetable,CHOOSECOLS(_averagetable,3)>10),
_sortedtable,SORT(_filteredtable,{1,5},{1,-1}),
_groups,UNIQUE(A2:A13),
_lookup,XLOOKUP(_groups,TAKE(_sortedtable,,1),INDEX(_sortedtable,,2)),
HSTACK(_groups,_lookup)
)

=LET(A, A2:D13,
B, INDEX(A,0,3),
C, INDEX(A,0,4)/B*(B>9),
D, INDEX(A,0,1),
E, C=MAX(IF(D="A",C,0)),
F, C=MAX(IF(D="B",C,0)),
G, C=MAX(IF(D="C",C,0)),
H, TAKE(A,,2),
I, VSTACK(FILTER(H,E),FILTER(H,F),FILTER(H,G)),
I)

=LET(mean,$D$2:$D$13/$C$2:$C$13,x,MAX(IF($A$2:$A$13=G3,IF($C$2:$C$13>=10,mean))),INDEX($B$2:$B$13,MATCH(G3&x,$A$2:$A$13&mean,0)))

ITALIAN VERSION
=LET(mean;$D$2:$D$13/$C$2:$C$13;x;MAX(SE($A$2:$A$13=G3;SE($C$2:$C$13>=10;mean)));INDICE($B$2:$B$13;CONFRONTA(G3&x;$A$2:$A$13&mean;0)))

=LET(a,A2:A13,b,C2:C13,d,D2:D13,e,UNIQUE(a),HSTACK(e,XLOOKUP(MAP(e,LAMBDA(x,MAX(FILTER(d/b,(b>=10)*(a=x))))),d/b,B2:B13)))

=LET(a,A2:A13,b,C2:C13,c,D2:D13,d,UNIQUE(a),e,MAP(d,LAMBDA(x,MAX(FILTER(c/b,(a=x)*(b>=10))))),HSTACK(d,MAP(e,LAMBDA(y,FILTER(B2:B13,c/b=y)))))

=LET(a,FILTER(A2:D13,C2:C13>=10),b,UNIQUE(A2:A13),d,INDEX(a,,4)/INDEX(a,,3),e,INDEX(a,,2),f,INDEX(a,,1),HSTACK(b,MAP(b,LAMBDA(x,FILTER(e,(d)=MAX(FILTER(d,(f=x))))))))

=LET(a,FILTER(A2:D13,C2:C13>=10),b,UNIQUE(A2:A13),d,CHOOSECOLS(a,4)/CHOOSECOLS(a,3),e,CHOOSECOLS(a,2),f,CHOOSECOLS(a,1),HSTACK(b,MAP(b,LAMBDA(x,FILTER(e,(d)=MAX(FILTER(d,(f=x))))))))