看一下从7×0到7×9的7乘法表：

0, 7, 14, 21, 28, 35, 42, 49, 56, 63

如果只看一个人的数字，就可以得到数字0到9的排列：

0, 7, 4, 1, 8, 5, 2, 9, 6, 3

考虑采用某个正的十进制整数N并将N中的每个数字D替换为7×D处的数字。

例如，15209变得75403因为1映射到7，5映射到5，2映射到4，0映射到0，并9映射到3。

现在让我们用这个新的十进制整数重复此过程，直到看到一个循环，即直到我们已经看到的整数出现为止。

例如，有了15209周期

15209 -> 75403 -> 95801 -> 35607 -> 15209 -> repeats...
                                      ^
                                      |
                             cycle restarts here

再举一个例子，505周期短

505 -> 505 -> repeats...
        ^
        |
cycle restarts here

事实证明，对于任何N个循环，这些循环将始终恰好包含1或4个不同的整数。（我将留给您找出原因。）有趣的是，如果将一个循环中的所有不同整数相加，则几乎总是得到一个仅由2's和0's 组成的十进制整数。

例如，15209 + 75403 + 95801 + 35607 = 222020。

N = 505是例外之一。循环中唯一的整数是505，因此总和本身是505。

以下是N = 1到60的循环总和：

N sum
1 20
2 20
3 20
4 20
5 5
6 20
7 20
8 20
9 20
10 200
11 220
12 220
13 220
14 220
15 220
16 220
17 220
18 220
19 220
20 200
21 220
22 220
23 220
24 220
25 220
26 220
27 220
28 220
29 220
30 200
31 220
32 220
33 220
34 220
35 220
36 220
37 220
38 220
39 220
40 200
41 220
42 220
43 220
44 220
45 220
46 220
47 220
48 220
49 220
50 50
51 220
52 220
53 220
54 220
55 55
56 220
57 220
58 220
59 220
60 200

我们将其称为“七周期总和序列”。

挑战

编写一个程序或函数，该程序或函数接受一个正的十进制整数N，并以十进制形式打印或返回“ Seven's Cycle Sum Sequence”的相应项。

例如，如果输入为95801，则输出应为222020。如果输入为505，则输出应为505。如果输入为54，则输出应为220。

以字节为单位的最短代码获胜。

Pyth，14个字节

s.uieM*R7jNTTQ

不确定，为什么每个人都通过查看数字中的模式来确定结果。只需完成该过程，即可计算出圆的所有数字并将它们相加会更短。至少在Pyth ;-)

在线尝试：演示或测试套件

顺便说一句，这是我的第200个代码高尔夫球答案。因此，该帖子为我赢得了金代码高尔夫徽章。

说明：

s.uieM*R7jNTTQ   implicit: Q = input number
 .u          Q   apply the following expression to N=Q until it reaches a circle
         jNT        convert N to base 10
      *R7           multiply each digit with 7
    eM              and perform modulo 10 for each number
   i        T       convert digits from base 10 to a number
                    update N
                 .u returns the list of all intermediate results of N, 
                 so we have now all numbers of the circle
s                sum them up

Python 2，69个字节

lambda n:[''.join('02'[x>'0']for x in`n`)+'0',n][set(`n`)<=set('05')]

该函数易于描述：

• 如果n仅包含0和5，则将其输出不变。
• 否则，将n的每个数字替换为2，但0保持为0，然后将0固定到末尾。

打高尔夫球可以改善，我主要是在分享分享方法。具有本地正则表达式的语言应允许一个简短的解决方案。

该功能的另一种说法是

• 在n中，将每个数字替换为5，但0保持为0
• 如果将其更改为n（其数字不是0或5），则将结果乘以4

Python 2，63个字节

lambda s:s.strip('05')and''.join(`(c>'0')*2`for c in s)+'0'or s

输入参数应为字符串。

CJam，16个字节

使用与其他所有人相同的算法：

r_50s-{:~2fe&0}&

测试套件。（将所有结果从1生成到输入。）

说明

r_      e# Read input and duplicate
50s     e# Push the string "50".
-       e# Remove all '5' and '0' characters from the input.
{       e# If any characters remained in the input...
  :~    e#   Evaluate each digit character to turn it into an integer.
  2fe&  e#   Map (&& 2) over the list. Due to short-circuiting, zeros remain zeros and
        e#   everything else becomes 2.
  0     e#   Push a trailing zero.
}&

JavaScript（ES6），54 51字节

使用xnor的方法：

n=>/[^05]/.test(n)?`${n}0`.replace(/./g,d=>+d&&2):n

@charlie节省了3个字节！

说明

n=>
  (s=n+"").match`[^05]`          // if there are any digits which aren't 5 or 0
    ?s.replace(/\d/g,d=>+d&&2)+0 //     replace every digit except 0 with 2 then add a 0
  :s                             // else return the input unchanged

测试

<input type="number" id="input" value="0" oninput='result.textContent=(

n=>(s=n+"").match`[^05]`?s.replace(/\d/g,d=>+d&&2)+0:s

)(+input.value)' />
<pre id="result"></pre>

天真的方法，102字节

n=>(c=x=>~r.indexOf(x+=m="")?eval(r.join`+`):[...r[++i]=x].map(d=>m+="0741852963"[d])&&c(m))(n,i=r=[])

n=>
  (c=x=>                  // c = recursive function
    ~r.indexOf(           // if we have calculated this number before
      x+=m="")?           // cast x to a string, m = calculated result
        eval(r.join`+`):  //     return the sum of all the calculated numbers
    [...r[++i]=x].map(d=> // else add x to the list of calculated numbers
      m+="0741852963"[d]  // map each digit of x to the "seven" digits
    )&&c(m)               // calculate the value of the result
  )(n,i=r=[])             // r = array of previously calculated values

<input type="number" id="input" value="0" oninput='result.textContent=(

n=>(c=x=>~r.indexOf(x+=m="")?eval(r.join`+`):[...r[++i]=x].map(d=>m+="0741852963"[d])&&c(m))(n,i=r=[])

)(+input.value)' />
<pre id="result"></pre>

Mathematica，83 77 60个字符

Tr@Union@NestList[FromDigits@Mod[7IntegerDigits@#,10]&,#,4]&

不打高尔夫球

Tr@
  Union@
   NestList[
    FromDigits@Mod[7 IntegerDigits@#, 10] &,
    #,
    4
   ] &

JavaScript（ES5），40个字节

n=>(s=`${n}`.replace(/[^0]/g,5))^n?s*4:n

这是 user81655的解决方案，使用所描述的另一种方法XNOR。

说明

在4个周期中，非零数字的总和始终为20，因为数字周期是1→7→9→3或2→4→8→6或5→5→5→5。因此，将每个此类数字替换为5不会改变总和。

该替换动作被重用以将4周期与1周期区分开-如果替换结果与输入不同，则为4周期，否则为1周期。

注意：模板字符串`${n}`仅出于可读性考虑，(n+'')具有相同的长度。

sed，26个字节

/[^05]/{s/[^0]/2/g;s/$/0/}

（另一种采用“ 2代替”的方法。）

例子

echo '500' | sed '/[^05]/{s/[^0]/2/g;s/$/0/}' → 500

echo '501' | sed '/[^05]/{s/[^0]/2/g;s/$/0/}' → 2020

Perl 6的， 68个55 53 36  33字节

{[+] $^a,{[~] $^b.comb.map: {'0741852963'.comb[$_]}}...^{$++*?/$a/}} # 68

{$_=@=$_.comb;[~] (@$_,(|.map(2*?+*),0))[$_⊈qw<0 5>]} # 55

{[~] ($_=@=$_.comb)⊆qw<0 5>??@$_!!(|.map(2*?+*),0)} # 53

{/^<[05]>+$/??$_!!S:g/./{2*?+$/}/~0} # 36

{m/^<[05]>+$/||S:g/./{2*?+$/}/~0} # 33

这绝对是错误的方式做到这一点，如果这个数只由5S和0s时，会返回一个匹配对象，否则它代替一切，但0有一个2，并追加0到最后。
（如果将Match对象用作一个，则Match对象的行为将类似于数字）

尽管这样做做错了，但通过调用 gist方法。

用法：

# give it a name
my &code = {...}

.say for (0..60,505,15209).flat.map({ code($_).gist.fmt: '%4s' }).rotor(1,10 xx 6,:partial)

( ｢0｣)
(  20   20   20   20  ｢5｣   20   20   20   20  200)
( 220  220  220  220  220  220  220  220  220  200)
( 220  220  220  220  220  220  220  220  220  200)
( 220  220  220  220  220  220  220  220  220  200)
( 220  220  220  220  220  220  220  220  220 ｢50｣)
( 220  220  220  220 ｢55｣  220  220  220  220  200)
(｢505｣)
(222020)