List All Dudeney Numbers

let
  Source = List.Transform(
    List.Select(
      {1 .. 99}, 
      each 
        let
          q = Number.Power(_, 3)
        in
          List.Sum(List.Transform(Text.ToList(Text.From(q)), Number.From)) = _
    ), 
    each Number.Power(_, 3)
  )
in
  Source

let
  Source = List.Transform(
    List.Select(
      List.Generate(
        () => [N = 1, F = true, C = 1], 
        each [C] <= 6, 
        each [
          N = [N] + 1, 
          F = (
            Number.Round(Number.Power(N, 1 / 3), 4)
              = List.Sum(List.Transform(Text.ToList(Text.From(N)), Number.From))
          ), 
          C = [C] + Number.From(F) + Number.From([C] = 6)
        ]
      ), 
      each [F]
    ), 
    each [N]
  )
in
  Source

let
  Source = List.Generate(
    () => [x = 0, y = 1, z = {0}], 
    each [x] < 7, 
    each [
      y = [y] + 1, 
      z = List.Transform(
        {[y]}, 
        (n) =>
          let
            a = Text.ToList(Text.From(n)), 
            b = List.Sum(List.Transform(a, Number.From)), 
            c = {Number.Power(b, 3)} & {[y]}, 
            d = if c{0} <> c{1} then null else [y]
          in
            d
      ), 
      x = if [z]{0} = null then [x] else [x] + 1
    ], 
    each [z]
  ), 
  Sol = List.Select(List.Transform(List.Skip(Source), each _{0}), each _ <> null)
in
  Sol

let
  Source = List.Select(
    List.Transform(
      {1 .. Number.Power(40, 3)}, 
      (x) =>
        let
          a = Number.Power(x, 3), 
          b = List.Sum(List.Transform(Text.ToList(Text.From(a)), Number.From)), 
          c = {a / Number.Power(x, 2)} & {b}, 
          d = if c{0} = c{1} then a else null
        in
          d
    ), 
    each _ <> null
  )
in
  Source

let
  Source = Table.FromList({1 .. 46}, Splitter.SplitByNothing(), {"Number"}, null, ExtraValues.Error), 
  SumOfCubeDigits = Table.AddColumn(
    Source, 
    "SumOfCubeDigits", 
    each [
      a = [Number], 
      b = Number.Power(a, 3), 
      c = Text.ToList(Text.From(b)), 
      d = List.Transform(c, each Number.From(_)), 
      e = List.Sum(d)
    ][e]
  ), 
  Filter = Table.SelectColumns(
    Table.SelectRows(SumOfCubeDigits, each [Number] = [SumOfCubeDigits]), 
    "Number"
  )
in
  Filter

let
  a = (x, y) =>
    if List.Count(y) = 6 then
      y
    else
      @a(
        x + 1, 
        if x
          = List.Sum(
            List.Transform(Text.ToList(Text.From(Number.Power(x, 3))), each Number.FromText(_))
          )
        then
          List.Combine({y, {Number.Power(x, 3)}})
        else
          y
      )
in
  a(2, {1})

Table.SelectRows(
  Table.FromRecords(
    List.Generate(
      () => [a = 1, d = 1], 
      each [a] < 20000, 
      each [
        a = [a] + 1, 
        d = 
          if Number.Round(Number.Power([a] + 1, (1 / 3)), 10)
            = List.Sum(List.Transform(Text.ToList(Text.From([a] + 1)), each Number.From(_)))
          then
            1
          else
            0
      ], 
      each [[a], [d]]
    )
  ), 
  each [d] = 1
)[a]

=TOCOL(MAP(SEQUENCE(99),LAMBDA(s,s^3/(s=SUM(--MID(s^3,SEQUENCE(LEN(s^3)),1))))),3)

=LET(n,SEQUENCE(1000),FILTER(n^3,MAP(n,LAMBDA(x,x=SUM(0+MID(x^3,SEQUENCE(,LEN(x^3)),1))))))

=LET(n,ROW(1:30),FILTER(n^3,MMULT(--MID(n^3/1%%,{1,2,3,4,5},1),{1;1;1;1;1})=n))

=LET(n,ROW(1:30),FILTER(n^3,MMULT(--(0&MID(n^3,TOROW(n),1)),n^0)=n))

=LET(r,SEQUENCE(20000),FILTER(r,r^(1/3)=MMULT((0&MID(r,{1,2,3,4,5},1))+0,{1;1;1;1;1})))

=LET(a,SEQUENCE(100),b,a^3,c,BYROW(DROP(IFNA(REDUCE("",b,LAMBDA(x,y,VSTACK(x,--MID(y,SEQUENCE(,LEN(y)),1)))),""),1),LAMBDA(z,SUM(z))),FILTER(b,c=a))

=LET(
 s, SEQUENCE(1000) ^ 3,
 m, MAP(s, LAMBDA(x, SUM(--MID(x, SEQUENCE(LEN(x)), 1)))),
 r, ROUND(POWER(s, 0.3333333), 0),
 FILTER(s, m = r)
)

==(c:=round(n**(1/3)))and c**3==n)

=LET(A,SEQUENCE(10^5),FILTER(A,(MAP(A,LAMBDA(x,SUM(MID(x,SEQUENCE(LEN(x)),1)*1)=x^(1/3))))))

=LET(
 _num, SEQUENCE(20000),
 _sum, MAP(_num, LAMBDA(a, SUM(MID(a, SEQUENCE(LEN(a)), 1) + 0))),
 _crt, POWER(_num, 1 / 3),
 _cri, _sum = _crt,
 FILTER(_num, _cri)
)

=TOCOL(
 MAP(
 SEQUENCE(20000),
 LAMBDA(s, IF(s ^ (1 / 3) = SUM(MID(s, SEQUENCE(LEN(s)), 1) + 0), s, NA()))
 ),
 3
)

=LET(n,SEQUENCE(99999),
u,MAP(n,LAMBDA(x,SUM(ABS(MID(x,SEQUENCE(LEN(x)),1)))=x^(1/3))),
v,FILTER(n,u),
v)

=LET(
 M, LAMBDA(f, f(f)),

 A, LAMBDA(f, LAMBDA(x, [y], SCAN(y, x, f))),

 K, LAMBDA(f, LAMBDA(x, [y], f(x))),

 S, LAMBDA(f, M(LAMBDA(g, LAMBDA(x,
 IF(f(x + 1), x + 1, g(g)(x + 1)))))),


 d, M(LAMBDA(g, LAMBDA(x,
 IF(LEN(x), LEFT(x) + g(g)(REPLACE(x, 1, 1, )))))),

 f, A(K(S(LAMBDA(n, n = d(n ^ 3))))),

 f(SEQUENCE(6)) ^ 3
)

=LET(M, LAMBDA(g, g(g)), 

Succ, LAMBDA(f, M(LAMBDA(g, LAMBDA(n, 
IF(f(n + 1), n + 1, g(g)(n + 1)))))), 

_sumDigits, M(LAMBDA(g, LAMBDA(n, 
MOD(n, 10) + IF(n, g(g)(QUOTIENT(n, 10)))))), 

_isDudeneyRoot, LAMBDA(n, n = _sumDigits(n ^ 3)), 

SixRoots, SCAN(, SEQUENCE(6), LAMBDA(n,_, Succ(_isDudeneyRoot)(n))), 

SixRoots ^ 3)

=LET(a,ROW(1:20000),FILTER(a,MMULT(--(0&MID(a,{1,2,3,4,5},1)),{1;1;1;1;1})^3=a))

=FILTER(SEQUENCE(999999),MAP(SEQUENCE(999999),LAMBDA(X,SUM(--MID(X,SEQUENCE(,LEN(X)),1))=X^(1/3))))

=LET(f;LAMBDA(a;b;c;IF(ROWS(c)=6;c;a(a;b+1;IF(b=SUM(--MID(b^3;SEQUENCE(LEN(b^3));1));VSTACK(c;b^3);c))));f(f;2;1))

=LET(s,SEQUENCE(99999),FILTER(s,(s^(1/3))=MAP(s,LAMBDA(x,SUM(--MID(x,SEQUENCE(LEN(x)),1))))))

=LET(
 list, MAP(
 SEQUENCE(20000),
 LAMBDA(a,
 LET(
 x, SUM(MID(a, SEQUENCE(LEN(a)), 1) + 0),
 y, POWER(a, 1 / 3),
 IF(x = y, a, 0)
 )
 )
 ),
 FILTER(list, list > 0)
)

=TOCOL(MAP(SEQUENCE(20000),LAMBDA(_range,LET(
_split,--MID(_range,SEQUENCE(LEN(_range)),1),
_cuberoot,_range^(1/3),
_check,SUM(_split)=_cuberoot,
FILTER(_range,_check)
))),3)