Check Narcissistic Numbers

let
  Source = Excel.CurrentWorkbook(){[Name = "InputTable"]}[Content], 
  AddedCalculation = Table.AddColumn(
    Source, 
    "Answer Expected", 
    each List.Accumulate(
      Text.ToList(Number.ToText([Number])), 
      0, 
      (s, d) => s + Number.Power((Number.FromText(d)), Text.Length(Number.ToText([Number])))
    )
  ), 
  FilteredNarcissisticNumbers = Table.SelectRows(
    AddedCalculation, 
    each ([Number] = [Answer Expected])
  )[[Answer Expected]]
in
  FilteredNarcissisticNumbers

let
  Source = Excel.CurrentWorkbook(){[Name = "data"]}[Content], 
  Return = Table.SelectRows(
    Source, 
    each [
      Text = Text.From([Number]), 
      Power = List.Transform(
        Text.ToList(Text), 
        (f) => Number.Power(Number.From(f), Text.Length(Text))
      ), 
      Total = List.Sum(Power)
    ][Total]
      = [Number]
  )
in
  Return

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  AddPower = Table.AddColumn(
    Source, 
    "Custom", 
    each [
      a      = Text.ToList(Text.From([Number])), 
      b      = List.Transform(a, each Number.From(_)), 
      Length = List.Count(a), 
      Raised = List.Transform(b, each Number.Power(_, Length)), 
      Total  = List.Sum(Raised)
    ][Total]
  ), 
  Clean = Table.SelectColumns(Table.SelectRows(AddPower, each [Number] = [Custom]), "Number")
in
  Clean

let
  Source = Table.FromRows(
    Json.Document(
      Binary.Decompress(
        Binary.FromText(
          "JcuxEQAxCAPBXog/AAQGamHcfxvvgegUrLpJWOl+TQiZmtc0lXNGPbHLLRO2Gofhe1DhlBV2osAR8dT9AQ==", 
          BinaryEncoding.Base64
        ), 
        Compression.Deflate
      )
    ), 
    let
      _t = ((type nullable text) meta [Serialized.Text = true])
    in
      type table [Number = _t]
  ), 
  #"Filtered Rows" = Table.SelectRows(
    Source, 
    each 
      let
        _list     = Text.ToList([Number]), 
        length    = List.Count(_list), 
        transform = List.Transform(_list, each Number.Power(Number.From(_), length)), 
        sum       = List.Sum(transform), 
        totext    = Text.From(sum)
      in
        [Number] = totext
  )
in
  #"Filtered Rows"

let
  fxNarcissisticNumCheck = (num as number) =>
    let
      numText = Number.ToText(num), 
      numLen = Text.Length(numText), 
      digitList = Text.ToList(numText), 
      sumOfPowers = List.Sum(
        List.Transform(digitList, each Number.Power(Number.FromText(_), numLen))
      ), 
      narcissisticNumCheck = num = sumOfPowers
    in
      narcissisticNumCheck, 
  Source = Challenge147, 
  customFunctionInvoke = Table.AddColumn(
    Source, 
    "Narcissistic Number Check", 
    each fxNarcissisticNumCheck([Number]), 
    type logical
  ), 
  filteredRows = Table.SelectRows(customFunctionInvoke, each ([Narcissistic Number Check] = true)), 
  keepValidSentences = Table.SelectColumns(filteredRows, {"Number"})
in
  keepValidSentences

=TOCOL(MAP(A2:A10,LAMBDA(a,a/(a=SUM(MID(a,SEQUENCE(LEN(a)),1)^LEN(a))))),3)

=FILTER(A2:A10,MAP(A2:A10,LAMBDA(d,d=SUM(MID(d,SEQUENCE(LEN(d)),1)^LEN(d)))))

=LET(n,A2:A10,FILTER(n,MAP(n,LEN(n),LAMBDA(x,y,SUM(MID(x,SEQUENCE(y),1)^y)=x))))

✅ =LET(n,A2:A10,s,ROW(1:10),FILTER(n,n=MMULT(MID(10^9*n,TOROW(s),1)^LEN(n),s^0)))

=FILTER(A2:A10,MAP(A2:A10,LAMBDA(a,
SUM(MID(a,SEQUENCE(LEN(a)),1)^LEN(a))=a)))

=LET(a,A2:A10,FILTER(a,a=MAP(a,LEN(a),LAMBDA(x,y,SUM(MID(x,SEQUENCE(y),1)^y)))))

=FILTER(A2:A10,MAP(A2:A10,LAMBDA(N,LET(L,LEN(N),SUM(MID(N,SEQUENCE(L),1)^L)=N))))

=FILTER(
 A2:A10,
 MAP(
 A2:A10,
 LAMBDA(n,
 LET(
 num_str, TEXT(n, "0"),
 num_len, LEN(num_str),
 sumOfPowders, SUM(MAP(MID(num_str, SEQUENCE(1, num_len), 1), LAMBDA(d, VALUE(d) ^ num_len))),
 sumOfPowders = n
 )
 )
 )
)

=LET(
 _d, A2:A10,
 _c, MAP(_d, LEN(_d), LAMBDA(a, b, SUM(MID(a, SEQUENCE(b), 1) ^ b))),
 _r, FILTER(_d, _c = _d),
 _r
)

=LET(A,A2:A10, FILTER(A, MAP(A, LAMBDA(x, SUM( MAP(SEQUENCE(LEN(x)), LAMBDA(a, MID(x,a,1)^(LEN(x)))))))=A))

=TOCOL(MAP(A2:A10,LAMBDA(v,v/(v=SUM(MID(v,SEQUENCE(LEN(v)),1)^LEN(v))))),3)

=FILTER(A2:A10,
MAP(A2:A10,LAMBDA(a,
SUM(POWER(MID(a,SEQUENCE(,LEN(a)),1),LEN(a)))=a)))

=FILTER(A2:A10,MAP(A2:A10,LAMBDA(a,a=SUM(RIGHT(LEFT(a,SEQUENCE(LEN(a))))^LEN(a)))))

=FILTER(A2:A10,MAP(A2:A10,LAMBDA(x,LET(a,LEN(x),b,MID(x,SEQUENCE(a),1),c,SUM(ABS(b)^a),IF(c=x,1,0))))=1)

=LET(
 s, MAP(
 A2:A10,
 LAMBDA(n,
 LET(
 x, MID(n, SEQUENCE(LEN(n)), 1) + 0,
 y, SUM(x ^ LEN(n)),
 IF(n = y, n, 0)
 )
 )
 ),
 FILTER(s, s > 0)
)

=FILTER(A2:A10,MAP(A2:A10,LAMBDA(a,LET(b,LEN(a),c,MID(a,SEQUENCE(b),1),d,SUM(c^b),d)))=A2:A10)

[n for n in xl("A2:A10")[0] if n == sum(int(d)**len(str(n)) for d in str(n))]