# 一个数对应的排列的位数，肯定和它的位数相等，即8位数的排列，必然也是8位数
# 那么我们就从1位数开始，找到所有位数相同的立方数，然后尝试从中找5个立方数的数字相同的数

lastLen = 0
cubes = [] # 存放所有位数相同的立方数
i = 1
while True :
    cube = i**3
    if len(str(cube)) > lastLen : # 位数增加
        lastLen = len(str(cube))   

        # 至此，cubes 中已经保存了所有位数为 lastLen 的立方数    
        # 再判断 cubes 中是否存在 5 个数，它们包含的数字相同

        # (1) 先将所有数，分解成数字，然后将数字从小到大重组，得到新的一组字符串。比如 41063625 转换成 '01234566'
        cubes_str = [ ''.join(sorted(list(str(n)))) for n in cubes]

        # (2) 再对这组字符串做排序，这样包含的数字相同的数就排到了一起
        cubes_str = sorted(cubes_str)

        # (3) 再遍历排序后的这组字符串，找到出现了5次字符串
        repeatedCnt = 0
        lastStr = 0
        for n in cubes_str :
            if n == lastStr :
                repeatedCnt += 1
                if repeatedCnt == 4 : # 重复了4次，加上自己，共出现5次
                    answer = [ c for c in cubes  if ''.join(sorted(list(str(c)))) == lastStr ]
                    print(answer)
                    exit(0)
            else:
                lastStr = n
                repeatedCnt = 0
        # 重置 cubes
        cubes = []
    cubes.append(cube)
    i += 1

package main

import (
	"fmt"
	"sort"
	"strings"
)

// 将n分解成数字，然后将数字从小到大重组，得到新的一组字符串。
// 如 n = 41063625，返回 '01234566'
func sortNumber(n int64) string {

	// 分解
	str := fmt.Sprintf("%v", n)
	var digits []string
	for _, c := range str {
		digits = append(digits, fmt.Sprintf("%v", c-48))
	}

	// 排序
	sort.Slice(digits, func(i, j int) bool {
		return digits[i] < digits[j]
	})

	// 重组
	return strings.Join(digits, "")
}

func main() {

	// 一个数对应的排列的位数，肯定和它的位数相等，即8位数的排列，必然也是8位数
	// 那么我们就从1位数开始，找到所有位数相同的立方数，然后尝试从中找5个立方数的数字相同的数

	lastLen := 0
	var cubes []int64 // 存放所有位数相同的立方数
	for i := int64(1); ; i++ {
		cube := i * i * i
		cubeStr := fmt.Sprintf("%v", cube)
		if len(cubeStr) > lastLen { // 位数增加
			lastLen = len(cubeStr)

			// 至此，cubes 中已经保存了所有位数为 lastLen 的立方数 
			// 再判断 cubes 中是否存在 5 个数，它们包含的数字相同

			// (1) 先将所有数，分解成数字，然后将数字从小到大重组，得到新的一组字符串。比如 41063625 转换成 '01234566'
			var cubesStr []string
			for _, c := range cubes {
				// e.g. c = 41063625 转换成 '01234566'，存放到 cubesStr 中
				cubesStr = append(cubesStr, sortNumber(c))
			}

			// (2) 再对这组字符串做排序，这样包含的数字相同的数就排到了一起
			sort.Slice(cubesStr, func(i, j int) bool {
				return cubesStr[i] < cubesStr[j]
			})

			// (3) 再遍历排序后的这组字符串，找到出现了5次字符串
			repeatedCnt, lastStr := 0, ""
			for _, s := range cubesStr {
				if s == lastStr {
					repeatedCnt++
					if repeatedCnt == 4 { // 重复了4次，加上自己，共出现5次
						var answer []int64
						for _, c := range cubes {
							if sortNumber(c) == lastStr {
								answer = append(answer, c)
							}
						}

						fmt.Println(answer)
						return
					}
				} else {
					repeatedCnt = 0
					lastStr = s
				}
			}

			// 重置 cubes
			cubes = []int64{}

		} else {
			// 位数没有增加，继续添加
			cubes = append(cubes, cube)
		}
	}
}