Algorithm 整数的数分裂

我们将一个S-数定义为一个自然数n，即一个完美的平方，它的平方根可以通过将n的十进制表示形式拆分为两个或多个数，然后将这些数相加得到

比如说,

81是一个S数，因为sqrt（81）=8+1

6724是一个S-数：sqrt（6724）=6+72+4

8281是一个S-数：sqrt（8281）=8+2+81或82+8+1

9801是一个S-数：sqrt（9801）=98+0+1

此外，我们将T（N）定义为所有S数N1的总和，并编写程序

2检查您的程序是否给出T（10000）=41333

3如果您的程序失败，请在此处发布程序，以便我们查看并帮助您使其正常工作

提示：从小处开始，使用1位数字和2位数字。

1编写您的程序

2检查您的程序是否给出T（10000）=41333

3如果您的程序失败，请在此处发布程序，以便我们查看并帮助您使其正常工作

---

提示：从小处开始，用1位数字和2位数字。

对，我知道您标记了python，但它很慢，所以我将用C语言完成。python的原始版本在末尾

总计为：128088830547982

C代码：

#include <stdio.h>
#include <string.h>

#define BUF 20

int make_target(int nums[], int target, int mult, int length)
{
  long newtarget = target - nums[length - 1] * mult;

  if (length == 1)
    return newtarget == 0;
  else
    return
      (newtarget > 0) &&
      (make_target(nums, newtarget, mult * 10, length-1) ||
       make_target(nums, newtarget, 1, length-1));
}

int main()
{
  int len, i;
  long s, sqrt, total;
  char buf[BUF];
  int nums[BUF];

  total = 0;
  for (sqrt = 2; sqrt <= 1000000; sqrt++)
    {
      s = sqrt * sqrt;
      snprintf(buf, BUF, "%ld", s);
      len = strlen(buf);
      for (i = 0; i < len; i++)
        nums[i] = buf[i] - '0';
      if (make_target(nums, sqrt, 1, len)) {
        total += s;
        printf("%ld %ld %ld\n", s, sqrt, total);
      }
    }
  
  printf("TOTAL: %ld\n", total);
  return 0;
}

原始python代码（不包括缓存某些部分解决方案的失败尝试，这并没有真正提高速度，但会占用大量内存）：

---

好的，我知道您标记了python，但是它很慢，所以我将用C语言来做。python的原始版本在末尾

总计为：128088830547982

C代码：

#include <stdio.h>
#include <string.h>

#define BUF 20

int make_target(int nums[], int target, int mult, int length)
{
  long newtarget = target - nums[length - 1] * mult;

  if (length == 1)
    return newtarget == 0;
  else
    return
      (newtarget > 0) &&
      (make_target(nums, newtarget, mult * 10, length-1) ||
       make_target(nums, newtarget, 1, length-1));
}

int main()
{
  int len, i;
  long s, sqrt, total;
  char buf[BUF];
  int nums[BUF];

  total = 0;
  for (sqrt = 2; sqrt <= 1000000; sqrt++)
    {
      s = sqrt * sqrt;
      snprintf(buf, BUF, "%ld", s);
      len = strlen(buf);
      for (i = 0; i < len; i++)
        nums[i] = buf[i] - '0';
      if (make_target(nums, sqrt, 1, len)) {
        total += s;
        printf("%ld %ld %ld\n", s, sqrt, total);
      }
    }
  
  printf("TOTAL: %ld\n", total);
  return 0;
}

原始python代码（不包括缓存某些部分解决方案的失败尝试，这并没有真正提高速度，但会占用大量内存）：

---

我投票结束这个问题，因为它不是一个编程问题。事实上，这根本不是一个问题，这是一个指令。OP应该发布他到目前为止尝试过的内容，但这是一个编码/算法问题，对s/O有效。我正在尝试，因为它看起来很有趣。。。我有一个简单的算法，它会不断地重新计算很多相同的东西。我认为挑战在于找出哪些部分结果最有利于缓存在内存中。提示：在0和10^12之间只有10^6个完美平方。我投票结束这个问题，因为这不是一个编程问题。事实上，这根本不是一个问题，这是一个指令。OP应该发布他到目前为止尝试过的内容，但这是一个编码/算法问题，对s/O有效。我正在尝试，因为它看起来很有趣。。。我有一个简单的算法，它会不断地重新计算很多相同的东西。我认为挑战在于找出哪些部分结果最有利于缓存在内存中。提示：在0和10^12之间只有10^6个完美正方形。

def make_target(nums, target, mult, length):

    newtarget = target - nums[length - 1] * mult

    if length == 1:
        return newtarget == 0
    else:
        return (newtarget > 0
                and (make_target(nums, newtarget, mult * 10, length-1)
                     or make_target(nums, newtarget, 1, length-1)))
    

total = 0
for sqrt in range(2, 1000001):

    s = sqrt * sqrt
    nums = list(map(int, str(s)))
    if make_target(nums, sqrt, 1, len(nums)):
        total += s
        print(s, sqrt, total)

print("TOTAL:", total)