Schauen Sie sich die sieben Multiplikationstabellen von 7 × 0 bis 7 × 9 an:

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

Wenn wir uns nur die Ziffern an der Stelle ansehen, erhalten wir eine Permutation der Ziffern 0 bis 9:

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

Nehmen Sie eine positive Dezimalzahl N und ersetzen Sie jede Ziffer D in N durch die Ziffer anstelle von 7 × D.

Beispielsweise 15209wird, 75403weil 1Maps zu 7, 5Maps zu 5, 2Maps zu 4, 0Maps zu 0und 9Maps zu 3.

Wiederholen wir nun diesen Vorgang mit dieser neuen Dezimalzahl, bis wir einen Zyklus sehen, dh bis eine Ganzzahl auftaucht, die wir bereits gesehen haben.

Zum Beispiel mit 15209bekommen wir den Zyklus

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

Als weiteres Beispiel 505hat der kurze Zyklus

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

Es stellt sich heraus, dass diese Zyklen für jedes N immer genau 1 oder 4 verschiedene ganze Zahlen enthalten. (Ich überlasse es Ihnen, herauszufinden, warum das so ist.) Interessant ist, dass Sie fast immer eine Dezimalzahl erhalten, die nur aus 2's und 0' s besteht, wenn Sie die ganze bestimmte Ganzzahl in einem Zyklus summieren .

Zum Beispiel 15209 + 75403 + 95801 + 35607 = 222020.

N = 505 ist eine der Ausnahmen. Die einzige Ganzzahl im Zyklus ist 505, die Gesamtsumme ist also 505.

Hier sind die Summen der Zyklen für N = 1 bis 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

Wir nennen dies die Sieben-Zyklus-Summen-Sequenz.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine positive Dezimalzahl N akzeptiert und den entsprechenden Term der Zyklussummensequenz der Sieben als Dezimalzahl ausgibt oder zurückgibt.

Wenn der Eingang beispielsweise ist 95801, sollte der Ausgang sein 222020. Wenn der Eingang ist 505, sollte der Ausgang sein 505. Wenn der Eingang ist 54, sollte der Ausgang sein 220.

Der kürzeste Code in Bytes gewinnt.

Pyth, 14 Bytes

s.uieM*R7jNTTQ

Ich bin mir nicht sicher, warum jeder das Ergebnis bestimmt, indem er sich die Muster in den Zahlen ansieht. Einfach den Prozess zu machen, alle Zahlen des Kreises zu berechnen und sie zu summieren, ist kürzer. Zumindest in Pyth ;-)

Probieren Sie es online aus: Demo oder Test Suite

Übrigens, das ist meine 200. Code-Golf-Antwort. Dieser Beitrag bringt mir also das Gold Code-Golf-Abzeichen ein.

Erläuterung:

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

Die Funktion ist einfach zu beschreiben:

• Wenn n nur aus 0 und 5 besteht, wird es unverändert ausgegeben.
• Andernfalls ersetzen Sie jede Ziffer von n durch 2, außer 0 bleibt 0, und setzen Sie eine 0 bis zum Ende.

Das Golfen kann verbessert werden, ich poste meistens, um die Methode zu teilen. Eine Sprache mit nativem regulären Ausdruck sollte eine kurze Lösung ermöglichen.

Eine alternative Aussage der Funktion ist

• Ersetzen Sie in n jede Ziffer durch eine 5, mit der Ausnahme, dass 0 0 bleibt
• Wenn sich dadurch n ändert (es hatte eine andere Ziffer als 0 oder 5), multiplizieren Sie das Ergebnis mit 4

Python 2, 63 Bytes

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

Es wird erwartet, dass das Eingabeargument eine Zeichenfolge ist.

CJam, 16 Bytes

Verwenden Sie den gleichen Algorithmus wie alle anderen:

r_50s-{:~2fe&0}&

Testsuite. (Erzeugt alle Ergebnisse von 1 bis zur Eingabe.)

Erläuterung

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

Mit der Methode von xnor :

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

3 Bytes gespart dank @charlie !

Erläuterung

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

Prüfung

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

Naive Methode, 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 Zeichen

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

Es ist eine Weiterentwicklung der user81655 ‚s Lösung, den alternativen Ansatz von beschriebenen xnor .

Erläuterung

Die Summe einer Ziffer ungleich Null im 4-Zyklus ist immer 20, da die Ziffer entweder durch 1 → 7 → 9 → 3 oder 2 → 4 → 8 → 6 oder 5 → 5 → 5 → 5 wechselt. Das Ersetzen jeder solchen Ziffer durch 5 ändert also nichts an der Summe.

Diese Ersetzungsaktion wird erneut verwendet, um den 4-Zyklus von dem 1-Zyklus zu unterscheiden. Wenn sich das Ersetzungsergebnis vom Eingang unterscheidet, handelt es sich um einen 4-Zyklus, andernfalls um einen 1-Zyklus.

NB: Der Template-String `${n}`dient nur der Lesbarkeit und (n+'')hat die gleiche Länge.

sed, 26 bytes

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

(Ein weiterer Ansatz zum "Ersetzen durch 2".)

Beispiele

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

Dies ist definitiv der falsche Weg, wenn die Zahl nur aus 5s und 0s besteht, wird ein Match-Objekt zurückgegeben, andernfalls wird alles außer 0durch a ersetzt 2und ein 0an das Ende angefügt .
(Das Match-Objekt verhält sich wie eine Zahl, wenn Sie es als eine Zahl verwenden.)

Da es falsch gemacht wird, ist es einfach, durch Aufrufen der gistMethode auf die seltenen Zahlen hinzuweisen .

Verwendung:

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