Dê uma olhada na tabela de multiplicação sevens de 7 × 0 a 7 × 9:

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

Se apenas olharmos para os dígitos no lugar, obtemos uma permutação dos dígitos de 0 a 9:

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

Considere pegar algum número inteiro decimal positivo N e substituir cada dígito D em N pelo dígito no lugar de 7 × D.

Por exemplo, 15209torna-se 75403porque 1mapeia para 7, 5mapeia para 5, 2mapeia para 4, 0mapeia para 0e9 mapeia para 3.

Agora vamos repetir esse processo com esse novo número inteiro decimal até vermos um ciclo, ou seja, até que um número inteiro que já vimos apareça.

Por exemplo, com 15209o ciclo

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

Como outro exemplo, 505tem o ciclo curto

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

Acontece que para qualquer N esses ciclos sempre conterão exatamente 1 ou 4 números inteiros distintos. (Vou deixar para você descobrir por que isso é.) O interessante é que, se você soma todo o número inteiro distinto em um ciclo, quase sempre obtém um número decimal que consiste apenas de 2s e 0s.

Por exemplo, 15209 + 75403 + 95801 + 35607 = 222020.

N = 505 é uma das exceções. O único número inteiro no ciclo é 505, portanto, a soma total é 505 em si.

Aqui estão as somas dos ciclos para N = 1 a 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

Vamos chamar isso de Sequência de Soma do Ciclo dos Sete.

Desafio

Escreva um programa ou função que obtenha um número inteiro decimal positivo N e imprima ou retorne, em decimal, o termo correspondente da Sequência de Soma de Ciclo de Seven.

Por exemplo, se a entrada for 95801, a saída deve ser 222020. Se a entrada for 505, a saída deve ser 505. Se a entrada for 54, a saída deve ser 220.

O código mais curto em bytes vence.

Pitão, 14 bytes

s.uieM*R7jNTTQ

Não tenho certeza, por que todo mundo determina o resultado observando padrões nos números. Simplesmente fazer o processo, calcular todos os números do círculo e resumi-los é mais curto. Pelo menos em Pyth ;-)

Experimente on-line: Demonstration or Test Suite

Aliás, esta é a minha 200ª resposta de código-golfe. Portanto, este post me rende o distintivo de código-golfe Gold.

Explicação:

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 bytes

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

A função é simples de descrever:

• Se n consistir em apenas 0 e 5, produza-o inalterado.
• Caso contrário, substitua cada dígito de n por 2, exceto que 0 permanece 0 e coloque um 0 no final.

O golfe pode ser melhorado, estou postando principalmente para compartilhar o método. Um idioma com regex nativo deve permitir uma solução curta.

Uma declaração alternativa da função é

• Em n, substitua cada dígito por 5, exceto que 0 permanece como 0
• Se isso mudou n (tinha um dígito diferente de 0 ou 5), multiplique o resultado por 4

Python 2, 63 bytes

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

O argumento de entrada deve ser uma sequência.

CJam, 16 bytes

Usando o mesmo algoritmo que todos os outros:

r_50s-{:~2fe&0}&

Suíte de teste. (Gera todos os resultados de 1 à entrada.)

Explicação

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 bytes

Usando o método xnor :

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

Guardado 3 bytes graças a @charlie !

Explicação

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

Teste

<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>

Método ingênuo, 102 bytes

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 caracteres

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

Ungolfed

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

JavaScript (ES5), 40 bytes

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

É uma evolução da solução do user81655 , usando a abordagem alternativa descrita pelo xnor .

Explicação

A soma de um dígito diferente de zero no ciclo de 4 é sempre 20, uma vez que o dígito alterna entre 1 → 7 → 9 → 3 ou 2 → 4 → 8 → 6 ou 5 → 5 → 5 → 5. Portanto, substituir cada dígito por 5 não altera a soma.

Essa ação de substituição é reutilizada para distinguir o ciclo 4 do ciclo 1 - se o resultado da substituição for diferente da entrada, será um ciclo 4, caso contrário, será um ciclo.

NB: A sequência do modelo `${n}`é apenas para facilitar a leitura, (n+'')tem o mesmo comprimento.

sed, 26 bytes

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

(Outra abordagem sobre a abordagem "substituir por 2".)

Exemplos

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 bytes

{[+] $^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

Esta é definitivamente a maneira errada de fazer isso, se o número for composto apenas por 5s e 0s, ele retornará um objeto Match, caso contrário, substituirá tudo, exceto 0por a 2, e anexará 0a ao final.
(O objeto Match se comportará como um número se você o usar como um)

Embora, como ele esteja fazendo errado, seja fácil apontar os números raros chamando o gistmétodo.

uso:

# 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)