Dai un'occhiata alla tabella di moltiplicazione dei sette da 7 × 0 a 7 × 9:

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

Se guardiamo solo le cifre al posto di una, otteniamo una permutazione delle cifre da 0 a 9:

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

Prendi in considerazione un numero intero decimale positivo N e sostituisci ogni cifra D in N con la cifra al posto di 7 × D.

Ad esempio, 15209diventa 75403perché 1mappe a 7, 5mappe a 5, 2mappe a 4, 0mappe a 0e 9mappe a 3.

Ora ripetiamo questo processo con questo nuovo numero intero decimale fino a quando non vediamo un ciclo, cioè fino a quando viene visualizzato un numero intero che abbiamo già visto.

Ad esempio, con 15209otteniamo il ciclo

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

Come altro esempio, 505ha il ciclo breve

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

Si scopre che per ogni N questi cicli conterranno sempre esattamente 1 o 4 interi distinti. (Lascerò a te capire perché è così.) La cosa interessante è che se sommi l'intero intero distinto in un ciclo, ottieni quasi sempre un numero intero decimale che consiste solo di 2'e 0'.

Ad esempio, 15209 + 75403 + 95801 + 35607 = 222020.

N = 505 è una delle eccezioni. L'unico numero intero nel ciclo è 505, quindi la somma totale è 505 stessa.

Ecco le somme dei cicli per 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

Chiameremo questa la sequenza della somma dei sette cicli.

Sfida

Scrivi un programma o una funzione che accetta un intero decimale positivo N e stampa o restituisce, in decimali, il termine corrispondente della sequenza della somma del ciclo di Seven.

Ad esempio, se l'input è 95801, l'output dovrebbe essere 222020. Se l'input è 505, l'output dovrebbe essere 505. Se l'input è 54, l'output dovrebbe essere 220.

Vince il codice più breve in byte.

Pyth, 14 byte

s.uieM*R7jNTTQ

Non sono sicuro, perché tutti determinano il risultato osservando i modelli nei numeri. Fare semplicemente il processo, calcolare tutti i numeri del cerchio e sommarli è più breve. Almeno in Pyth ;-)

Provalo online: dimostrazione o suite di test

A proposito, questa è la mia 200a risposta da golf di codice. Quindi questo post mi fa guadagnare il badge Gold da golf del codice.

Spiegazione:

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 byte

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

La funzione è semplice da descrivere:

• Se n è composto solo da 0 e 5, l'output è invariato.
• Altrimenti, sostituisci ogni cifra di n con 2, tranne 0 rimane 0 e vira su 0 fino alla fine.

Il golf può essere migliorato, sto postando principalmente per condividere il metodo. Una lingua con regex nativo dovrebbe consentire una soluzione breve.

Un'istruzione alternativa della funzione è

• In n, sostituisci ogni cifra con un 5, tranne 0 rimane 0
• Se questo cambiava n (aveva una cifra diversa da 0 o 5), moltiplica il risultato per 4

Python 2, 63 byte

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

L'argomento di input dovrebbe essere una stringa.

CJam, 16 byte

Utilizzando lo stesso algoritmo di tutti gli altri:

r_50s-{:~2fe&0}&

Suite di test. (Genera tutti i risultati da 1 all'input.)

Spiegazione

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 byte

Usando il metodo di xnor :

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

3 byte salvati grazie a @charlie !

Spiegazione

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

Test

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

Metodo ingenuo, 102 byte

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 caratteri

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

Ungolfed

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

JavaScript (ES5), 40 byte

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

È un'evoluzione del soluzione dell'utente81655 , usando l'approccio alternativo descritto da xnor .

Spiegazione

La somma di una cifra diversa da zero nel ciclo di 4 è sempre 20, poiché la cifra scorre tra 1 → 7 → 9 → 3 o 2 → 4 → 8 → 6 o 5 → 5 → 5 → 5. Quindi sostituire ogni cifra del genere con 5 non cambia la somma.

Quell'azione di sostituzione viene riutilizzata per distinguere il 4 cicli da 1 ciclo: se il risultato della sostituzione è diverso dall'input, allora è un 4 cicli, altrimenti è un 1 ciclo.

NB: la stringa del modello `${n}`è solo per leggibilità, (n+'')ha la stessa lunghezza.

sed, 26 byte

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

(Un'altra interpretazione dell'approccio "sostituisci con 2").

Esempi

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 byte

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

Questo è sicuramente il modo sbagliato di fare questo, se il numero è costituito solo da 5s ed 0è esso restituisce un oggetto Match, altrimenti si sostituisce tutto ma 0con una 2, e aggiungere un0 fino alla fine.
(L'oggetto Match si comporterà come un numero se lo usi come uno)

Sebbene dal momento che stia sbagliando, rende facile indicare i numeri rari chiamando il gist metodo.

utilizzo:

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