Next Palindrome Number

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Res = List.Transform(
    Table.ToRows(Source), 
    each 
      let
        a = Text.ToList(Text.From(_{0})), 
        b = List.Count(a), 
        c = Number.IntegerDivide(b, 2), 
        d = Text.ToList(
          Text.From(Number.From(Text.Combine(List.FirstN(a, Number.RoundUp(b / 2)))) + 1)
        )
      in
        Number.From(Text.Combine(d & List.Reverse(List.RemoveLastN(d, Number.Mod(b, 2)))))
  )
in
  Res

let
  Source = Excel.CurrentWorkbook(){[Name = "Palindrome"]}[Content], 
  AddedPalindrome = Table.AddColumn(
    Source, 
    "Answer Expected", 
    each List.Last(
      List.Generate(
        () => [Number] + 1, 
        each Number.ToText(_) <> Text.Reverse(Number.ToText(_)), 
        each _ + 1, 
        each _ + 1
      )
    )
  )[[Answer Expected]]
in
  AddedPalindrome

let
  Source = Excel.CurrentWorkbook(){[Name = "data"]}[Content], 
  MyFun = (num) =>
    List.Last(
      List.Generate(
        () => [x = num + 1], 
        each [x] <> Number.From(Text.Reverse(Text.From([x]))), 
        each [x = [x] + 1], 
        each [x] + 1
      )
    ), 
  Return = Table.AddColumn(Source, "Output", each MyFun([Number]))
in
  Return

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Type = Table.TransformColumnTypes(Source, {{"Number", type text}}), 
  Sol = Table.AddColumn(
    Type, 
    "Expected Answer", 
    each Text.From(
      List.Last(
        List.Generate(
          () => [Number = Number.From([Number]) + 1], 
          each [Number] <> Number.From(Text.Reverse(Text.From([Number]))), 
          each [Number = [Number] + 1], 
          each [Number] + 1
        )
      )
    )
  )
in
  Sol

let
  Source = Table.SelectColumns(Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], "Number"), 
  Calculation = Table.AddColumn(
    Source, 
    "Dims", 
    each [
      ToList = Text.ToList(Text.From([Number])), 
      Length = List.Count(ToList), 
      Half = Number.IntegerDivide(Length, 2), 
      Mod = Number.Mod(Length, 2), 
      a = List.FirstN(ToList, Half), 
      arev = List.Reverse(a), 
      b = Text.Combine(a, ""), 
      brev = Text.Combine(arev, ""), 
      c = Text.From(Number.From(b) + 1), 
      crev = Text.Combine(List.Reverse(Text.ToList(c)), ""), 
      FirstPart = 
        if Number.From(List.First(List.RemoveFirstN(ToList, Half))) = 9 then
          Text.From(c)
        else
          Text.From(b), 
      SecondPart = Number.From(List.First(List.RemoveFirstN(ToList, Half))) + 1, 
      ThirdPart = brev, 
      Result = 
        if Number.IsEven(Length) then
          c & crev
        else
          FirstPart & Text.From(SecondPart) & ThirdPart
    ][Result]
  ), 
  ReType = Table.TransformColumnTypes(Calculation, {{"Dims", Int64.Type}})
in
  ReType

let
  Source = Excel.CurrentWorkbook(){[Name = "palindrome_numbers"]}[Content], 
  DatatypeChange = Table.TransformColumnTypes(Source, {{"Number", Int64.Type}}), 
  // calculate next palindrome number: 
  CustomColumnAddition = Table.AddColumn(
    DatatypeChange, 
    "Next Palindrome", 
    each List.Max(
      List.Generate(
        () => [Number] + 1, 
        each _ <> Number.FromText(Text.Reverse(Number.ToText(_))), 
        each _ + 1
      )
    )
      + 1, 
    Int64.Type
  )
in
  CustomColumnAddition

=LET(a,A2:A10,b,LEN(a),(1.1-MOD(b,2))*10^(EVEN(b)/2)+a)

=MAP(A2:A10,LAMBDA(a,LET(b,LEN(a),c,EVEN(b)/2,d,c-MOD(b,2),e,LEFT(a,c)+1,--IF(d,e&CONCAT(MID(e,d+1-SEQUENCE(d),1)),e+(e>9)))))

=LET(a,A2:A16,c,LEN(a),IF(MOD(c,2),a+10^INT(c/2),a+11*10^INT((c-1)/2)))

=LET(a,A2:A16,c,LEN(a),IF(0+MID(a,INT((c+1)/2),1)<9,IF(M
OD(c,2),a+10^INT(c/2),a+11*10^INT((c-1)/2)),a+11*10^ROUNDUP((c-4+(c<4))/2,0)))

=LET(n,A2:A10,s,LEN(n),o,ISODD(s),n+(11-10*o&REPT(0,INT((s+o-1)/2))))

=MAP(A2:A10,LAMBDA(a,a+LET(
r,LEN(a),
IF(ISODD(r),10^ROUNDUP(r/3,),(11&REPT(0,r/2-1))))))

=LET(
a,A2:A10,
r,LEN(a),
IF(ISODD(r),10^ROUNDUP(r/3,),11&REPT(0,r/2-1))+a)

=LET(
a,A2:A10,
r,LEN(a),
IF(ISODD(r),1&REPT(0,r/2),11&REPT(0,r/2-1))+a)

=MAP(A2:A10,LAMBDA(x,LET(a,LEN(x),b,EVEN(x),c,FLOOR(a/2,1),IF(ISODD(a),10^c,(10^c)+(10^(c-1)))+x)))

=MAP(A2:A10,LAMBDA(P,LET(L,LEN(P),T,ROUNDUP(L/2,0),TT,IF(ISODD(L),T-1,T),E,LEFT(P,T)+1,CONCAT(E,MID(E,SEQUENCE(TT,,TT,-1),1)))*1))

=MAP(A2:A10,LAMBDA(z,LET(A,LEN(z)/2,B,NOT(INT(A)=A),C,CONCAT(MID(z,IF(B,SEQUENCE(2,,A),SEQUENCE(3,,A-1)),1)),D,IF(B,TEXT(C+1,"00"), TEXT(C+11,"000")),E,IF(A-2>0,MID(z,1,ROUNDUP(A-2,0)),""),CONCAT(E,D, LEFT(D)&IFERROR(CONCAT(MID(E,SEQUENCE(LEN(E),,LEN(E),-1),1)),""))*1)))

=MAP(A2:A10, LAMBDA(x, LET(b, LEN(x), c, --MID(x, ROUNDUP(b/2,0), 1+ISEVEN(b)),REPLACE(x, ROUNDUP(b/2,0), 1+ISEVEN(b), c+1+ISEVEN(b)*10))))

=MAP(A2:A10,LAMBDA(a,LET(_len,LEN(a),_loc,ROUND(_len/2,0),_cnt,IF(ISEVEN(_len),2,1),
_left,LEFT(a,_loc-1),_midnor,MID(a,_loc,_cnt),
_midup,MID(_midnor,SEQUENCE(,LEN(_midnor)),1)+1,
_right,MID(a,_loc+_cnt,1000),TEXTJOIN("",,_left,_midup,_right)+0)))

=MAP(A2:A10,LAMBDA(z,LET(a,LEN(z),b,FLOOR(a/2,1),d,10^b,e,10^(b-1),f,d+e,g,IF(MOD(a,2)=0,f,d),h,z+g,h)))

=1*LET(a, A2:A10,          len, LEN(a),          center, MID(a, (len+1)/2, 1),          left, MID(a, 1, len-(len+1)/2),          right_odd, MID(a, 1+(len+1)/2, len-(len+1)/2),          right_even, MID(a, 2+(len+1)/2, len-(len)/2),          odd, 1*ISODD(len),  left&REPT(center+1, 2-odd)&REPT(right_odd, odd)&REPT(right_even, IF(odd, odd-1, odd+1)))

=MAP(A2:A10,LAMBDA(a,LET(l,LEN(a),n,LEFT(a,ROUNDUP(l/2,0))+1,p,LEN(n),--CONCAT(n,MID(LEFT(n,l-p),SEQUENCE(l-p,,l-p,-1),1)))))

SI(EST.IMPAIR(NBCAR(A2));A2+10^(NBCAR(A2)/2-0,5);A2+10^(NBCAR(A2)/2)+10^(NBCAR(A2)/2-1)) 
                    
                  

df = xl("A1:A10", headers=True)
def is_palindrome(n):
 return str(n) == str(n)[::-1]
def next_palindrome(n):
 n += 1
 while not is_palindrome(n):
 n += 1
 return n
df['Next Palindrome'] = df['Number'].apply(next_palindrome)
df['Next Palindrome']