Echa un vistazo a la tabla de multiplicar sietes de 7 × 0 a 7 × 9:

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

Si solo miramos los dígitos en su lugar, obtenemos una permutación de los dígitos del 0 al 9:

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

Considere tomar un número entero decimal positivo N y reemplazar cada dígito D en N con el dígito en el lugar de 7 × D.

Por ejemplo, 15209se hace 75403porque 1se asigna a 7, 5mapas para 5, 2mapas para 4, 0mapas para 0, y 9se asigna a 3.

Ahora repitamos este proceso con este nuevo entero decimal hasta que veamos un ciclo, es decir, hasta que aparezca un entero que ya hemos visto.

Por ejemplo, con 15209nosotros obtenemos el ciclo

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

Como otro ejemplo, 505tiene el ciclo corto

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

Resulta que para cualquier N estos ciclos siempre contendrán exactamente 1 o 4 enteros distintos. (Dejaré que usted descubra por qué es eso). Lo interesante es que si suma todos los enteros distintos en un ciclo, casi siempre obtiene un entero decimal que solo consiste en 2'sy 0' s.

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

N = 505 es una de las excepciones. El único entero en el ciclo es 505, por lo que la suma total es 505 en sí misma.

Aquí están las sumas de los 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

Llamaremos a esto la secuencia de la suma del ciclo de los siete.

Desafío

Escriba un programa o función que tome un entero decimal positivo N e imprima o devuelva, en decimal, el término correspondiente de la secuencia de la suma del ciclo de los siete.

Por ejemplo, si la entrada es 95801, la salida debería ser 222020. Si la entrada es 505, la salida debería ser 505. Si la entrada es 54, la salida debería ser 220.

El código más corto en bytes gana.

Pyth, 14 bytes

s.uieM*R7jNTTQ

No estoy seguro, por qué todos determinan el resultado al observar patrones en los números. Simplemente haciendo el proceso, calcular todos los números del círculo y resumirlos es más corto. Al menos en Pyth ;-)

Pruébelo en línea: Demostración o conjunto de pruebas

Por cierto, esta es mi 200a respuesta de código de golf. Así que esta publicación me gana la insignia de golf de código dorado.

Explicación:

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')]

La función es simple de describir:

• Si n consta de solo 0 y 5, déjelo sin cambios.
• De lo contrario, reemplace cada dígito de n con 2, excepto que 0 permanece 0, y agregue un 0 hasta el final.

El golf se puede mejorar, principalmente publico para compartir el método. Un lenguaje con expresiones regulares nativas debería permitir una solución corta.

Una declaración alternativa de la función es

• En n, reemplace cada dígito con un 5, excepto que 0 permanece como 0
• Si esto cambió n (tenía un dígito distinto de 0 o 5), multiplique el resultado por 4

Python 2, 63 bytes

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

Se espera que el argumento de entrada sea una cadena.

CJam, 16 bytes

Usando el mismo algoritmo que todos los demás:

r_50s-{:~2fe&0}&

Banco de pruebas. (Genera todos los resultados desde 1 a la entrada).

Explicación

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 el método de xnor :

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

Guardado 3 bytes gracias a @charlie !

Explicación

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

Prueba

<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 ingenuo, 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]&

Sin golf

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

JavaScript (ES5), 40 bytes

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

Es una evolución de la solución usuario 81655 , utilizando el enfoque alternativo descrito por xnor .

Explicación

La suma de un dígito distinto de cero en el ciclo 4 siempre es 20, ya que el dígito se desplaza por 1 → 7 → 9 → 3, o 2 → 4 → 8 → 6, o 5 → 5 → 5 → 5. Por lo tanto, reemplazar cada dígito con 5 no cambia la suma.

Esa acción de reemplazo se reutiliza para distinguir el ciclo 4 de 1 ciclo: si el resultado del reemplazo es diferente de la entrada, entonces es un ciclo 4, de lo contrario es un ciclo 1.

NB: La cadena de plantilla `${n}`es solo para facilitar la lectura, (n+'')tiene la misma longitud.

sed, 26 bytes

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

(Otra versión del enfoque "reemplazar por 2").

Ejemplos

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

Definitivamente, esta es la forma incorrecta de hacer esto, si el número consiste solo en 5sys 0, devolverá un objeto Match, de lo contrario, reemplazará todo menos 0con a 2, y agregará 0a al final.
(El objeto Match se comportará como un número si lo usa como uno)

Aunque como lo está haciendo mal, es fácil señalar los números raros llamando al gist mé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)