Top Rank Improvements

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  AJumb = Table.Sort(
    Table.AddColumn(Source, "Jumbed Ranking", each [2021] - [2022]), 
    {"Jumbed Ranking", 1}
  ), 
  Remove = Table.SelectColumns(AJumb, {"Player", "Jumbed Ranking"}), 
  Filter = Table.SelectRows(
    Remove, 
    each [Jumbed Ranking] >= List.Distinct(Remove[Jumbed Ranking]){2}
  )
in
  Filter

let
  Source = Excel.CurrentWorkbook(){[Name = "TennisPlayers"]}[Content], 
  FilteredEmptyRows = Table.SelectRows(Source, each ([2021] <> null) and ([2022] <> null)), 
  AddedJumpedRanking = Table.AddColumn(
    FilteredEmptyRows, 
    "Jumped Ranking", 
    each ([2022] - [2021]) * - 1
  ), 
  GroupedByJumpedRanking = Table.Group(
    AddedJumpedRanking, 
    {"Jumped Ranking"}, 
    {{"Player", each _[Player]}}
  ), 
  SortedJumpedRanking = Table.Sort(GroupedByJumpedRanking, {{"Jumped Ranking", Order.Descending}}), 
  AddedTopN = Table.AddIndexColumn(SortedJumpedRanking, "TopN", 1, 1, Int64.Type), 
  FilteredTop3 = Table.SelectRows(AddedTopN, each ([TopN] = 1 or [TopN] = 2 or [TopN] = 3)), 
  ExpandedPlayer = Table.ExpandListColumn(FilteredTop3, "Player")[[Player], [Jumped Ranking]]
in
  ExpandedPlayer

let
  Source   = Excel.CurrentWorkbook(){[Name = "data"]}[Content], 
  Criteria = 3, 
  Diff     = Table.AddColumn(Source, "Difference", each [2021] - [2022]), 
  Grouped  = Table.Group(Diff, "Difference", {"Group", each _}), 
  TopN     = Table.MaxN(Grouped, "Difference", 3), 
  Return   = Table.Combine(TopN[Group])[[Player], [Difference]]
in
  Return

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Added = Table.AddColumn(Source, "Jumped", each [2021] - [2022]), 
  Min = List.Min(
    List.FirstN(List.Distinct(List.Sort(List.RemoveNulls(Added[Jumped]), Order.Descending)), 3)
  ), 
  Filtered = Table.SelectRows(Added, each [Jumped] >= Min)[[Player], [Jumped]], 
  Sol = Table.Sort(Filtered, {{"Jumped", Order.Descending}, {"Player", Order.Descending}})
in
  Sol

let
  Fonte = Tabela1, 
  tab = Table.AddColumn(
    Fonte, 
    "Jumper Ranking", 
    each List.Min(List.Select({[2021] - [2022]}, each _ > 0))
  ), 
  fil = Table.SelectRows(tab, each ([Jumper Ranking] <> null)), 
  result = Table.Sort(fil, {{"Jumper Ranking", Order.Descending}, {"Player", Order.Descending}})[
    [Player], 
    [Jumper Ranking]
  ]
in
  result

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  RemoveNulls = Table.SelectRows(Source, each List.AllTrue({[2021] <> null, [2022] <> null})), 
  AddImprove = Table.AddColumn(RemoveNulls, "Jumped Rank", each [2021] - [2022]), 
  AddRank = Table.AddRankColumn(
    AddImprove, 
    "Rank", 
    {"Jumped Rank", Order.Descending}, 
    [RankKind = RankKind.Dense]
  ), 
  SelectNClean = Table.SelectColumns(
    Table.SelectRows(AddRank, each [Rank] <= 3), 
    {"Player", "Jumped Rank"}
  )
in
  SelectNClean

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Ranks = Table.FromRecords(
    Table.TransformRows(
      Table.SelectRows(Source, each not List.Contains(Record.ToList(_), null)), 
      each [Player = [Player], #"Jumped Ranking" = [2021] - [2022]]
    )
  ), 
  ExpectedOutput = Table.Combine(
    Table.FirstN(
      Table.Sort(
        Table.Group(Ranks, {"Jumped Ranking"}, {{"All", each _}}), 
        {{"Jumped Ranking", Order.Descending}}
      ), 
      3
    )[All]
  )
in
  ExpectedOutput

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  a      = Table.AddColumn(Source, "Subtraction", each [2021] - [2022], type number), 
  b      = Table.RemoveColumns(a, {"2021", "2022"}), 
  c      = Table.Sort(b, {{"Subtraction", Order.Descending}}), 
  d      = Table.TransformColumnTypes(c, {{"Player", type text}}), 
  e      = Table.FirstN(c, 4), 
  res    = Table.RenameColumns(e, {{"Subtraction", "Jumped Ranking"}})
in
  res

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  AddDiff = Table.TransformColumns(
    Table.AddColumn(Source, "Jumped Ranking", each List.Skip(Record.ToList(_))), 
    List.Transform({"Jumped Ranking"}, each {_, each _{0} - _{1}})
  ), 
  Result = Table.Sort(
    Table.SelectRows(
      AddDiff, 
      each [2021]
        <> null and [2022]
        <> null and [Jumped Ranking]
        >= List.MaxN(List.Distinct(AddDiff[Jumped Ranking]), 3){2}
    ), 
    {"Jumped Ranking", Order.Descending}
  )[[Player], [Jumped Ranking]]
in
  Result

=LET(
c,B2:B11-IF(C2:C11,C2:C11,99),
SORT(FILTER(
HSTACK(A2:A11,c),c>=LARGE(UNIQUE(c),3)),2,-1))

=LET(g,GROUPBY(A2:A11,B2:B11-C2:C11,SUM,,0,-2,MMULT(SIGN(B2:C11),{1;1})-1),c,DROP(g,,1),TAKE(g,XMATCH(3,XMATCH(c,UNIQUE(c)))))

=LET(
 p, SIGN(B2:B11 * C2:C11) * (B2:B11 - C2:C11),
 SORT(FILTER(HSTACK(A2:A11, p), p >= LARGE(UNIQUE(p), 3)), 2, -1)
)

=LET(
 p, IF(SIGN(B2:B11 * C2:C11), B2:B11 - C2:C11, -99),
 SORT(FILTER(HSTACK(A2:A11, B2:B11), p >= LARGE(UNIQUE(p), 3)), 2, -1)
)

=LET(a,A2:A11,b,B2:B11,c,C2:C11,d,b-c,e,IF(-d=c,0,d),f,IF(e=b,0,d),SORT(FILTER(HSTACK(a,f),f>=LARGE(UNIQUE(f),3)),2,-1))

=LET(a,A2:A11,b,B2:B11,c,C2:C11,d,b-c,e,IF(-d=c,-99,d),f,IF(e=b,-99,d),SORT(FILTER(HSTACK(a,f),f>=LARGE(UNIQUE(f),3)),2,-1))

=LET(
 data, A2:C11,
 filtData, FILTER(data, (ISNUMBER(INDEX(data, , 2))) * (ISNUMBER(INDEX(data, , 3)))),
 improv, MAP(INDEX(filtData, , 2), INDEX(filtData, , 3), LAMBDA(x, y, x - y)),
 sortData, SORTBY(filtData, improv, -1),
 topPlayers, TAKE(sortData, 4),
 HSTACK(INDEX(topPlayers, , 1), MAP(INDEX(topPlayers, , 2), INDEX(topPlayers, , 3), LAMBDA(x, y, x - y)))
)

=LET(
 _n, 3,
 _d, A2:C11,
 _fd, FILTER(_d, BYROW(_d, LAMBDA(a, AND(a <> "")))),
 _p, TAKE(_fd, , 1),
 _y1, INDEX(_fd, , 2),
 _y2, TAKE(_fd, , -1),
 _df, _y1 - _y2,
 _lg, LARGE(UNIQUE(_df), _n),
 _r, SORT(FILTER(HSTACK(_p, _df), _df >= _lg, ), 2, -1),
 _r
)

=LET(A, A2:A11,
B, IF((C2:C11<>"")*(B2:B11<>""),B2:B11-C2:C11,"NA"),
C, LARGE(UNIQUE(B),3), 
SORT(FILTER(HSTACK(A,B),(B>=C)*(B<>"NA")),2,-1))

=LET(a,B2:C11,b,BYROW(a*{1,-1},SUM)*BYROW(a>0,AND),SORT(FILTER(HSTACK(A2:A11,b),b>LARGE(UNIQUE(b),4)),2,-1))

=SORT(
LET(_col,MAP(B2:B11,C2:C11,LAMBDA(a,b,LET(_r,SEQUENCE(ROWS(a)),
_cond,AND(a>0,b>0,a-b>0),_cond*(a-b)))),
FILTER(HSTACK(A2:A11,_col),_col>0)),2,-1)

=LET(
a,A2:A11,
b,B2:B11,
c,C2:C11,
p,MAP(b,c,LAMBDA(x,y,IF(AND(x>0,y>0),x-y,0))),
q,LARGE(UNIQUE(p),SEQUENCE(3)),
s,XMATCH(p,q),
u,FILTER(HSTACK(a,p),ISNUMBER(s)),
v,SORT(u,2,-1),
w,VSTACK(HSTACK(A1,"Jumped Ranking"),v),
w)

=HSTACK(TEXTSPLIT(CONCAT(UNIQUE(MAP(SORT(LET(m;IF(C2:C11<>"";B2:B11-C2:C11;"");MAP(FILTER(A2:A11;(m>0)*(m<>""));LAMBDA(b;XLOOKUP(b;A2:A11;m))));;-1);LAMBDA(h;TEXTJOIN(";";;FILTER(A2:A11;IF(C2:C11<>"";B2:B11-C2:C11;"")=h)))))&";");;";";TRUE;0;"");SORT(LET(m;IF(C2:C11<>"";B2:B11-C2:C11;"");MAP(FILTER(A2:A11;(m>0)*(m<>""));LAMBDA(b;XLOOKUP(b;A2:A11;m))));;-1))

=LET(a,C2:C11,b,N(IF(a,B2:B11-a)),c,HSTACK(A2:A11,b),SORT(FILTER(c,INDEX(c,,2)>LARGE(UNIQUE(b),4)),2,-1))

=LET(_p,A2:A11,_r,B2:C11,_ra,BYROW(_r,LAMBDA(_jr,IF(OR(_jr=""),-9999,SUM(_jr*{1,-1})))),_f,SORT(HSTACK(_p,_ra),2,-1),TAKE(_f,XMATCH(LARGE(UNIQUE(_ra),3),CHOOSECOLS(_f,2))))

=LET(
 table, FILTER(A2:C11, ((B2:B11 > 0) * (C2:C11 > 0))),
 values, TAKE(table, , -2),
 Yone, TAKE(values, , 1),
 Ytwo, TAKE(values, , -1),
 sol, FILTER(HSTACK(TAKE(table, , 1), Yone - Ytwo), (Yone - Ytwo) > 0),
 SORTBY(sol, TAKE(sol, , -1), -1)
)

=QUERY(A2:C11,"SELECT A, B-C WHERE B-C > 0 ORDER BY B-C DESC LIMIT 4 LABEL A 'Player', B-C 'Jumped Ranking'")

QUERY, one of the things that give Sheets the edge over Excel 👀

Edit: Made it slightly more robust. I'm not hardcoding a 4 anymore!

=QUERY(A2:C11,"SELECT A, B-C WHERE B>0 AND C>0 AND B-C>="&MAX(1,LARGE(UNIQUE(IFERROR(ArrayFormula(IF(B2:B11="","A",B2:B11)-IF(C2:C11="","A",C2:C11)),-99)),3))&" ORDER BY B-C DESC LABEL A 'Player', B-C 'Jumped Ranking'")

=LET(a,B2:B11-C2:C11,b,FILTER(A2:A11,(a>1)*(B2:B11<>"")*(C2:C11<>"")),c,XLOOKUP(b,A2:A11,a),FILTER(SORT(HSTACK(b,c),2,-1),c>=LARGE(UNIQUE(c),3)))

=SORT(CHOOSECOLS(
 FILTER(HSTACK(Table2,Table2[2021]-Table2[2022]),
 LET(deltas,(Table2[2021]<>"")*(Table2[2022]<>"")*(Table2[2021]-Table2[2022]),
 deltas>=LARGE(UNIQUE(deltas),3))
 ),1,4),2,-1)

df = xl("A1:C11", headers=True)
df = df.dropna(subset=[2021, 2022])
df['Improvement'] = df[2021] - df[2022]
df = df.sort_values(by='Improvement', ascending=False).reset_index(drop=True)
top_4_df = df.head(4)
top_4_df = top_4_df[['Player', 'Improvement']]
top_4_df