Jetez un oeil à la table de multiplication de sept de 7 × 0 à 7 × 9:

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

Si nous regardons simplement les chiffres à sa place, nous obtenons une permutation des chiffres de 0 à 9:

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

Envisagez de prendre un nombre décimal positif N et de remplacer chaque chiffre D dans N par le chiffre à la place de 7 × D.

Par exemple, 15209devient 75403parce que 1correspond à 7, 5correspond à 5, 2correspond à 4, 0correspond à 0et 9correspond à 3.

Maintenant, répétons ce processus avec ce nouvel entier décimal jusqu'à ce que nous voyions un cycle, c'est-à-dire jusqu'à ce qu'un entier que nous avons déjà vu apparaisse.

Par exemple, avec 15209nous obtenons le cycle

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

Comme autre exemple, 505le cycle court

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

Il s'avère que pour tout N, ces cycles contiendront toujours exactement 1 ou 4 entiers distincts. (Je vous laisse le soin de comprendre pourquoi.) Ce qui est intéressant, c'est que si vous additionnez tous les entiers distincts dans un cycle, vous obtenez presque toujours un entier décimal qui se compose uniquement de 2'et 0'.

Par exemple, 15209 + 75403 + 95801 + 35607 = 222020.

N = 505 est l'une des exceptions. Le seul entier du cycle est 505, la somme totale est donc 505 elle-même.

Voici les sommes des cycles pour 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

Nous appellerons cela la séquence de somme du cycle des sept.

Défi

Écrivez un programme ou une fonction qui prend un entier décimal positif N et imprime ou renvoie, en décimal, le terme correspondant de la séquence de somme du cycle de sept.

Par exemple, si l'entrée est 95801, la sortie doit l'être 222020. Si l'entrée est 505, la sortie devrait l'être 505. Si l'entrée est 54, la sortie devrait l'être 220.

Le code le plus court en octets gagne.

Pyth, 14 octets

s.uieM*R7jNTTQ

Je ne sais pas, pourquoi tout le monde détermine le résultat en regardant les modèles dans les chiffres. Faire simplement le processus, calculer tous les nombres du cercle et les additionner est plus court. Au moins en Pyth ;-)

Essayez-le en ligne: démonstration ou suite de tests

Btw, ceci est ma 200e réponse de code-golf. Donc, ce poste me vaut le badge Gold-golf.

Explication:

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 octets

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

La fonction est simple à décrire:

• Si n se compose uniquement de 0 et de 5, sortez-le inchangé.
• Sinon, remplacez chaque chiffre de n par 2, sauf que 0 reste 0 et clouez un 0 jusqu'à la fin.

Le golf peut être amélioré, je poste principalement pour partager la méthode. Une langue avec regex native devrait permettre une solution courte.

Une autre déclaration de la fonction est

• Dans n, remplacez chaque chiffre par un 5, sauf que 0 reste à 0
• Si cela a changé n (il avait un chiffre autre que 0 ou 5), multipliez le résultat par 4

Python 2, 63 octets

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

L'argument d'entrée devrait être une chaîne.

CJam, 16 octets

En utilisant le même algorithme que tout le monde:

r_50s-{:~2fe&0}&

Suite de tests. (Génère tous les résultats de 1 à l'entrée.)

Explication

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 octets

En utilisant la méthode de xnor :

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

Sauvegardé 3 octets grâce à @charlie !

Explication

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

Tester

<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éthode naïve, 102 octets

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 caractères

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

Non golfé

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

JavaScript (ES5), 40 octets

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

C'est une évolution de la solution de user81655 , en utilisant l'approche alternative décrite par xnor .

Explication

La somme d'un chiffre non nul dans le cycle 4 est toujours de 20, car le chiffre passe par 1 → 7 → 9 → 3, ou 2 → 4 → 8 → 6, ou 5 → 5 → 5 → 5. Donc, remplacer chacun de ces chiffres par 5 ne change pas la somme.

Cette action de remplacement est réutilisée pour distinguer le cycle 4 du cycle 1 - si le résultat du remplacement est différent de l'entrée, alors c'est un cycle 4, sinon c'est un cycle.

NB: La chaîne du modèle `${n}`est juste pour la lisibilité, (n+'')a la même longueur.

sed, 26 octets

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

(Un autre point de vue sur l'approche "remplacer par 2".)

Exemples

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 octets

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

C'est certainement la mauvaise façon de procéder, si le nombre est composé uniquement de 5s et 0s, il retournera un objet Match, sinon il remplace tout sauf 0par un 2, et ajoute un 0à la fin.
(L'objet Match se comportera comme un nombre si vous l'utilisez comme un seul)

Bien que comme il le fait mal, il est facile de signaler les rares numéros en appelant la gistméthode.

usage:

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