Yedi çarpım tablosuna 7 × 0'dan 7 × 9'a bir göz atın:

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

Sadece bir kişinin yerindeki rakamlara bakarsak, 0 ila 9 arasındaki rakamların permütasyonunu alırız:

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

Pozitif ondalık tamsayı N almayı ve N'deki her bir D rakamını, kişinin yerine 7 × D rakamı ile değiştirmeyi düşünün.

Örneğin, 15209olur 75403çünkü 1hiç haritalar 7, 5eşleştiren 5, 2eşleştiren 4, 0eşleştiren 0ve 9eşleştiren3 .

Şimdi bir döngü görene kadar, yani daha önce gördüğümüz bir tamsayı görünene kadar bu işlemi bu yeni ondalık sayı ile tekrarlayalım.

Örneğin 15209, döngüyü elde ederiz

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

Başka bir örnek olarak, 505kısa döngü var

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

Herhangi bir N için bu döngülerin her zaman tam olarak 1 veya 4 farklı tamsayı içereceği ortaya çıkıyor. (Bunun nedenini anlamanız için size bırakacağım.) İlginç olan şey, bir döngüdeki tüm farklı tamsayıyı toplarsanız, neredeyse her zaman yalnızca 2've 0' lerden oluşan bir ondalık tam sayı alırsınız .

Örneğin, 15209 + 75403 + 95801 + 35607 = 222020.

N = 505 istisnalardan biridir. Döngüdeki tek tam sayı 505'tir, bu nedenle toplam toplam 505'tir.

İşte N = 1 ila 60 arasındaki döngülerin toplamları:

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

Buna Seven'in Çevrim Toplamı Dizisi diyeceğiz.

Meydan okuma

Pozitif ondalık sayı tamsayısını N alan ve ondalık olarak Seven'in Çevrim Toplamı Sekansının ilgili terimini yazdıran veya döndüren bir program veya işlev yazın.

Örneğin, giriş ise 95801çıkış olmalıdır 222020. Giriş ise 505, çıkış olmalıdır 505. Girdi ise 54, çıktı220 .

Bayt cinsinden en kısa kod kazanır.

Pyth, 14 bayt

s.uieM*R7jNTTQ

Emin değilim, neden herkes sayıdaki kalıplara bakarak sonucu belirler. İşlemi yapmak, dairenin tüm sayılarını hesaplamak ve toplamak daha kısadır. En azından Pyth ;-)

Çevrimiçi deneyin: Gösteri veya Test Paketi

Btw, bu benim 200. kod golf cevabım. Bu yazı bana Altın kod golf rozetini kazandırdı.

Açıklama:

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 bayt

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

Fonksiyonun tanımlanması basittir:

• N yalnızca 0 ve 5'lerden oluşuyorsa, çıktıyı değiştirmeden çıkarın.
• Aksi takdirde, n'nin her bir basamağını 0 ile 0 hariç, 2 ile değiştirin ve 0'a sonuna kadar yapıştırın.

Golf geliştirilebilir, çoğunlukla yöntemi paylaşmak için gönderiyorum. Doğal regex içeren bir dil kısa bir çözüme izin vermelidir.

Fonksiyonun alternatif bir ifadesi

• N'de, 0 değerini 0 olarak kalması dışında her basamağı 5 ile değiştirin
• Bu n'yi değiştirdiyse (0 veya 5 dışında bir rakamı vardı) sonucu 4 ile çarpın

Python 2, 63 bayt

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

Girdi bağımsız değişkeninin bir dize olması bekleniyor.

CJam, 16 bayt

Herkesle aynı algoritmayı kullanarak:

r_50s-{:~2fe&0}&

Test odası. (1'den girişe kadar tüm sonuçları üretir.)

açıklama

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 bayt

Xnor yöntemini kullanarak :

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

3 bayt sayesinde kaydedildi @Charlie kaydedildi !

açıklama

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

Ölçek

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

Saf yöntem, 102 bayt

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

Ungolfed

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

JavaScript (ES5), 40 bayt

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

Bu bir evrim xnor tarafından açıklanan alternatif yaklaşımı kullanarak user81655'in çözümünün .

açıklama

4 döngüde sıfır olmayan bir rakamın toplamı her zaman 20'dir, çünkü rakam 1 → 7 → 9 → 3 veya 2 → 4 → 8 → 6 veya 5 → 5 → 5 → 5 arasında değişir. Dolayısıyla, böyle bir rakamı 5 ile değiştirmek toplamı değiştirmez.

Bu değiştirme eylemi, 4 döngüyü 1 döngüden ayırmak için yeniden kullanılır - değiştirme sonucu girişten farklıysa, 4 döngüdür, aksi takdirde 1 döngüdür.

Not: Şablon dizesi `${n}`yalnızca okunabilirlik içindir, (n+'')aynı uzunlukta.

sed, 26 bayt

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

("2 ile değiştir" yaklaşımına bir başka bakış.)

Örnekler

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 bayt

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

Bu kesinlikle numarası yalnızca oluşur ise, bunu yapmak için yanlış bir yoldur 5s ve 0aksi takdirde her şeyi değiştirir ama, bu bir maç nesnesi döndürür s 0bir ile 2, bir ekleme 0ucuna.
(Eşleştirme nesnesi, sayı olarak kullanırsanız sayı gibi davranır)

Yanlış yaptığı için, gistyöntemi çağırarak nadir sayıları belirtmeyi kolaylaştırır .

kullanımı:

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