Взгляните на таблицу умножения семерок от 7 × 0 до 7 × 9:

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

Если мы просто посмотрим на цифры на месте, мы получим перестановку цифр от 0 до 9:

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

Подумайте о том, чтобы взять некоторое положительное десятичное целое число N и заменить каждую цифру D в N цифрой вместо 7 × D.

Например, 15209становится 75403потому , что 1сопоставляет 7, 5сопоставляет 5, 2сопоставляет 4, 0сопоставляет 0и 9сопоставляет 3.

Теперь давайте повторим этот процесс с этим новым десятичным целым числом, пока мы не увидим цикл, т.е. пока не появится целое число, которое мы уже видели.

Например, с 15209мы получаем цикл

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

В качестве другого примера, 505имеет короткий цикл

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

Оказывается, что для любого N эти циклы всегда будут содержать ровно 1 или 4 различных целых числа. (Я оставлю это вам, чтобы выяснить, почему это так.) Интересно то, что если вы суммируете все различные целые числа в цикле, вы почти всегда получаете десятичное целое число, которое состоит только из 2«и 0» и «s».

Например, 15209 + 75403 + 95801 + 35607 = 222020.

N = 505 является одним из исключений. Единственное целое число в цикле - 505, поэтому общая сумма равна 505.

Вот суммы циклов для 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

Мы назовем это Последовательностью Циклов Семи.

Вызов

Напишите программу или функцию, которая принимает положительное десятичное целое число N и печатает или возвращает, в десятичном виде, соответствующий член последовательности семнадцати циклов.

Например, если вход есть 95801, выход должен быть 222020. Если вход есть 505, выход должен быть 505. Если вход есть 54, выход должен быть 220.

Самый короткий код в байтах побеждает.

Pyth, 14 байт

s.uieM*R7jNTTQ

Не уверен, почему все определяют результат, глядя на шаблоны в числах. Простой процесс, вычисление всех чисел круга и их суммирование короче. По крайней мере, в Pyth ;-)

Попробуйте онлайн: демонстрация или тестовый набор

Кстати, это мой 200-й код-гольф-ответ. Таким образом, этот пост приносит мне золотой значок гольф-кода.

Объяснение:

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 байт

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

Функция проста для описания:

• Если n состоит только из 0 и 5, выведите его без изменений.
• В противном случае замените каждую цифру n на 2, за исключением того, что 0 остается 0, и нажмите 0 до конца.

Гольф может быть улучшен, я в основном выкладываю, чтобы поделиться методом. Язык с нативным регулярным выражением должен дать краткое решение.

Альтернативное утверждение функции

• В n замените каждую цифру цифрой 5, за исключением того, что 0 остается 0
• Если это изменило n (у него была цифра, отличная от 0 или 5), умножьте результат на 4

Python 2, 63 байта

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

Предполагается, что входным аргументом будет строка.

CJam, 16 байтов

Используя тот же алгоритм, что и все остальные:

r_50s-{:~2fe&0}&

Тестирование. (Генерирует все результаты от 1 до ввода.)

объяснение

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 байт

Используя метод xnor :

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

Сохранено 3 байта благодаря @charlie !

объяснение

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

Тестовое задание

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

Наивный метод, 102 байта

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 знаков

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

Ungolfed

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

JavaScript (ES5), 40 байт

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

Это эволюция решения user81655 с использованием альтернативного подхода, описанного xnor .

объяснение

Сумма ненулевой цифры в 4-цикле всегда равна 20, поскольку цифра циклично либо через 1 → 7 → 9 → 3, либо 2 → 4 → 8 → 6, либо 5 → 5 → 5 → 5. Таким образом, замена каждой такой цифры на 5 не меняет сумму.

Это действие замены используется повторно, чтобы отличить 4-тактный от 1-тактного - если результат замены отличается от входного, то это 4-тактный, в противном случае это 1-тактный.

Примечание: строка шаблона `${n}`предназначена только для удобства чтения, (n+'')имеет одинаковую длину.

sed, 26 байт

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

(Еще один подход «заменить на 2».)

Примеры

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 байта

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

Это определенно неправильный способ сделать это, если число состоит только из 5 s и 0s, он вернет объект Match, в противном случае он заменит все, кроме 0a 2, и добавит a 0в конец.
(Объект Match будет вести себя как число, если вы используете его как единое целое)

Хотя, поскольку он делает это неправильно, он позволяет легко указать редкие числа, вызывая gistметод.

использование:

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