Lihatlah tabel multiplikasi tujuh dari 7 × 0 hingga 7 × 9:

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

Jika kita hanya melihat angka di tempatnya, kita mendapat permutasi dari angka 0 hingga 9:

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

Pertimbangkan untuk mengambil bilangan bulat desimal positif N dan mengganti setiap digit D dalam N dengan digit di tempat 7 × D.

Misalnya, 15209menjadi 75403karena 1peta 7, 5peta 5, 2peta 4, 0peta 0, dan 9peta 3.

Sekarang mari kita ulangi proses ini dengan bilangan bulat desimal baru ini sampai kita melihat siklus, yaitu sampai bilangan bulat yang telah kita lihat muncul.

Misalnya, dengan 15209kita mendapatkan siklus

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

Sebagai contoh lain, 505memiliki siklus pendek

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

Ternyata untuk setiap N siklus ini akan selalu mengandung tepat 1 atau 4 bilangan bulat yang berbeda. (Saya akan menyerahkan kepada Anda untuk mencari tahu mengapa itu terjadi.) Yang menarik adalah jika Anda menjumlahkan semua bilangan bulat yang berbeda dalam satu siklus, Anda hampir selalu mendapatkan bilangan bulat desimal yang hanya terdiri dari 2'dan 0'.

Misalnya, 15209 + 75403 + 95801 + 35607 = 222020.

N = 505 adalah salah satu pengecualian. Satu-satunya bilangan bulat dalam siklus adalah 505 sehingga jumlah totalnya adalah 505 itu sendiri.

Berikut adalah jumlah siklus untuk N = 1 hingga 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

Kami akan menyebutnya Urutan Jumlah Siklus Tujuh.

Tantangan

Tulis program atau fungsi yang mengambil dalam bilangan bulat desimal positif N dan mencetak atau mengembalikan, dalam desimal, istilah yang sesuai dari Urutan Jumlah Siklus Tujuh.

Misalnya, jika inputnya adalah 95801, outputnya seharusnya 222020. Jika inputnya adalah 505, output seharusnya 505. Jika inputnya adalah 54, output seharusnya 220.

Kode terpendek dalam byte menang.

Pyth, 14 byte

s.uieM*R7jNTTQ

Tidak yakin, mengapa semua orang menentukan hasilnya dengan melihat pola dalam angka. Cukup melakukan prosesnya, menghitung semua angka lingkaran dan menjumlahkannya lebih pendek. Setidaknya dalam Pyth ;-)

Cobalah online: Demonstrasi atau Test Suite

Btw, ini jawaban kode-golf ke-200 saya. Jadi posting ini memberi saya lencana kode-golf Gold.

Penjelasan:

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

Fungsi ini mudah dijelaskan:

• Jika n hanya terdiri dari 0 dan 5, output tidak berubah.
• Jika tidak, ganti setiap digit n dengan 2, kecuali 0 tetap 0, dan tempelkan 0 sampai akhir.

Golf dapat ditingkatkan, saya sebagian besar memposting untuk berbagi metode. Bahasa dengan regex asli harus memungkinkan solusi singkat.

Pernyataan alternatif dari fungsi tersebut adalah

• Dalam n, ganti setiap digit dengan 5, kecuali 0 tetap sebagai 0
• Jika ini berubah n (memiliki digit selain 0 atau 5), kalikan hasilnya dengan 4

Python 2, 63 byte

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

Argumen input diharapkan berupa string.

CJam, 16 byte

Menggunakan algoritma yang sama seperti orang lain:

r_50s-{:~2fe&0}&

Suite uji. (Menghasilkan semua hasil dari 1 hingga input.)

Penjelasan

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

Menggunakan metode xnor :

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

Disimpan 3 byte berkat @charlie !

Penjelasan

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

Uji

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

Metode naif, 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 karakter

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

Tidak disatukan

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

JavaScript (ES5), 40 byte

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

Ini adalah evolusi dari solusi user81655 , menggunakan pendekatan alternatif yang dijelaskan oleh xnor .

Penjelasan

Jumlah digit bukan nol dalam siklus 4 selalu 20, karena siklus digit dapat melalui 1 → 7 → 9 → 3, atau 2 → 4 → 8 → 6, atau 5 → 5 → 5 → 5 → 5. Jadi mengganti setiap digit dengan 5 tidak mengubah jumlahnya.

Tindakan penggantian itu digunakan kembali untuk membedakan 4-siklus dari 1-siklus - jika hasil penggantian berbeda dari input, maka itu adalah 4-siklus, kalau tidak itu adalah 1-siklus.

NB: String template `${n}`hanya untuk keterbacaan, (n+'')memiliki panjang yang sama.

sed, 26 byte

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

(Pandangan lain tentang pendekatan "ganti dengan 2".)

Contohnya

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

Ini jelas merupakan cara yang salah untuk melakukan ini, jika angka hanya terdiri dari 5s dan 0s itu akan mengembalikan objek Match, jika tidak maka akan menggantikan semuanya kecuali 0dengan a 2, dan tambahkan a 0sampai akhir.
(Objek Pencocokan akan berperilaku seperti angka jika Anda menggunakannya sebagai satu)

Meskipun karena itu salah, itu membuatnya mudah untuk menunjukkan angka langka dengan memanggil gist metode.

pemakaian:

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