Дано будь-яке ціле число x> 0 і будь-яка база y> 3.

1. Підсумовуйте всі цифри x (якщо вони записані в заданій базі).
2. Помножте це на максимально можливу цифру (завжди base -1).
3. Повторюйте, поки це значення не буде (y - 1) ^ 2

Пошуком є ​​кількість повторень та кроків.

Приклад 1:

x= 739
y= 7
searched: (7 - 1) ^ 2 = 36

based: (b7)2104
sum: (dec)7
mul: (dec)42

based: (b7)60
sum: (dec)6
mul: (dec)36

2 steps needed -> answer is [2, 739, 42, 36] or [739, 42, 36, 2]

Приклад 2:

x = 1712
y = 19
s: 324

step1: 1712 -> 360
step2:  360 -> 648
step3:  648 -> 324

3 steps needed -> answer is [3, 1712, 360, 648, 324] or [1712, 360, 648, 324, 3]

Спеціальне:
У деяких випадках (деякі комбінації з базою 3) вам не вдасться (y - 1) ^ 2сподобатися за x = 53і y = 3. З цієї причини yпотрібно бути більше 3, і ви можете проігнорувати це.

Кількість ітерацій має бути першим або останнім значенням

Це кодовий гольф з найнижчою кількістю виграшів.

Желе , 14 13 байт

-1 байт, друкуючи в циклі ( Ṅзамінюючи поділ ланцюга µта конкатенацію ;)

Ṅb⁹S×⁹’¤µÐĿL’

СпробуйтеItOnline!

Як?

Ṅb⁹S×⁹’¤µÐĿL’ - Main link: x, y
        µÐĿ   - loop monadically until results are no longer unique and collect
Ṅ             - print z (initially x), then result of previous loop and return z
  ⁹           -     right argument (y, even though monadic)
 b            -     left to base right
   S          -     sum (the result was a list of base y digits)
       ¤      -     nilad followed by link(s) as a nilad
     ⁹’       -         y decremented
    ×         -     multiply
           L  - length(z)
            ’ - decrement
              - implicit print

Альтернативно 13 байт друкує кожен вхід до циклу плюс подачу рядка ( Ṅ) і, нарешті, неявно друкує зменшений кількість зібраних результатів, усуваючи необхідність монадичного розділення ланцюга ( µ) та конкатенації ( ;).

Perl 6 , 60 байт

{$/=[$^x,*.polymod($^y xx*).sum*($y-1)...($y-1)²];$/-1,|$/}

Розширено:

{    # bare block lambda with placeholder parameters ｢$x｣ ｢$y｣

  $/ = [          # store in ｢$/｣ ( so that we don't have to declare it )

    # generate a sequence

    $^x,          # declare first parameter, and seed sequence generator

    # Whatever lambda

    *\            # the parameter to this lambda

    .polymod(     # broken down with a list of moduli

      $^y         # declare second parameter of the outer block lambda
      xx *        # an infinite list of copies of it

    )
    .sum
    *
    ( $y - 1 )

    # end of Whatever lambda

    ...           # repeat until it reaches

    ( $y - 1 )²
  ];

  # returns
  $/ - 1,         # count of values minus one
  |$/             # Slip ｢|｣ the list into the result
}

Використання:

# store it in the lexical namespace so that it is easier to understand
my &code = {$/=[$^x,*.polymod($^y xx*).sum*($y-1)...($y-1)²];$/-1,|$/}

say code  739,  7; # (2 739 42 36)
say code 1712, 19; # (3 1712 360 648 324)

С, 116 113 байт

-3 байти для перерахунку квадрата кожного разу

s,t,i;f(x,y){s=y-(i=1);while(x-s*s){t=0;++i;printf("%d ",x);while(x)t+=x%y,x/=y;x=t*y-t;}printf("%d %d ",x,i-1);}

Безголівки та використання:

s,t,i;
f(x,y){
 s=y-(i=1);
 while(x-s*s){
  t=0;
  ++i;
  printf("%d ",x);
  while(x)
   t+=x%y,    //add the base y digit
   x/=y;      //shift x to the right by base y
  x=t*y-t;
 }
 printf("%d %d ",x,i-1);
}

main(){
 f(739,7);puts("");
 f(1712,19);puts("");
}

JavaScript (ES6), 97 91 84 82 байт

f=(n,b,k=1,c=b-1)=>[n,(s=(B=n=>n%b*c+(n>b&&B(n/b|0)))(n))-c*c?f(s,b,k+1):[s,k]]+''

Тестові справи

f=(n,b,k=1,c=b-1)=>[n,(s=(B=n=>n%b*c+(n>b&&B(n/b|0)))(n))-c*c?f(s,b,k+1):[s,k]]+''

console.log(f(1712, 19))
console.log(f(739, 7))

Желе , 16 байт

Я думаю, я все-таки опублікую це, хоч це було побито, поки я його писав, тому що це помітно інший алгоритм, і це було цікаво писати. (Я не міг зрозуміти, як ÐĿрозібратися з документами і довелося відмовитися від нього, незважаючи на те, що це, ймовірно, призведе до більш короткого рішення, ніж цей.)

ṄbS×⁹’¤ß<’¥n⁸$?‘

Спробуйте в Інтернеті!

Пояснення:

ṄbS×⁹’¤ß<’¥n⁸$?‘
Ṅ                 Output {the first argument} and a newline
 b                Convert to base {the second argument}
  S               Sum digits
    ⁹’¤           {the second argument} minus 1, parsed as a group
   ×              Multiply
           n⁸$    {the current value} ≠ {the first argument}, parsed as a group
              ?   If that's true:
       ß          then run the whole program recursively
        <’¥       else run (lambda a,b: (a<b)-1)
               ‘  Increment the result

Використання <’¥- це в основному короткий спосіб написати діаду (посилання з двома аргументами), яка завжди повертає -1 (тому що ми знаємо, що відповідь ніколи не буде меншою, ніж база). Вибираючи між рекурсивним виконанням та всією програмою рекурсивно, ми можемо визначити, коли припинити циклічне циклічне виконання. Потім, коли стек розкручується в кінці рекурсії, ми продовжуємо збільшувати -1, щоб визначити, скільки кроків було.

MATL, 25 21 байт

4 байти збережено завдяки @Luis

XJx`tJYA!UsJq*tJqU-}@

Спробуйте в Інтернеті!

Пояснення

XJ      % Implicitly grab the first input and store in clipboard J
x       % Delete this from the stack
`       % Do...while loop
  t     % Duplicate last element on stack (implicitly grabs second input)
  JYA   % Convert this number to the specified base
  !Us   % Sum the digits
  Jq*   % Multiply by the largest number in this base
  t     % Duplicate this value
  JqU   % Compute (base - 1) ^ 2
  -     % Subtract the two. Evaluates to TRUE if they are not equal
}       % When they are finally equal
@       % Push the number of iterations
        % Implicitly display the stack contents

Математика, 80 байт

(s=FixedPointList[x(#2-1)(Plus@@x~IntegerDigits~#2),#];s[[-1]]=Length@s-2;s)&

- символ приватного використання, який U+F4A1використовується для представлення \[Function]. Якщо у відповіді не було потрібно кількості кроків, це можна зробити в 60 байт:

Most@FixedPointList[x(#2-1)(Plus@@x~IntegerDigits~#2),#]&