Cho là bất kỳ số nguyên x> 0 và bất kỳ cơ sở y> 3.

1. Tổng tất cả các chữ số của x (nếu được viết trong cơ sở thiết lập).
2. Nhân số này với chữ số cao nhất có thể (luôn luôn base -1).
3. Lặp lại cho đến khi giá trị này là (y - 1) ^ 2

Tìm kiếm là số lần lặp và các bước.

Ví dụ 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]

Ví dụ 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]

Đặc biệt:
Trong một số trường hợp (một số kết hợp với cơ sở 3), bạn sẽ không thể nhận được (y - 1) ^ 2thích x = 53và y = 3. Vì lý do này ycần phải lớn hơn 3 và bạn có thể bỏ qua điều này.

Số lần lặp cần phải là giá trị đầu tiên hoặc giá trị cuối cùng

Đây là chiến thắng đếm byte thấp nhất của mã golf .

Thạch , 14 13 byte

-1 byte bằng cách in khi nó lặp ( Ṅthay thế một chuỗi tách µvà nối ;)

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

Dùng thử trực tuyến!

Làm sao?

Ṅ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

Byter 13 thay thế in từng đầu vào vào vòng lặp cộng với nguồn cấp dữ liệu ( Ṅ) và cuối cùng in ngầm số đếm giảm dần của các kết quả được thu thập, loại bỏ sự cần thiết phải tách chuỗi đơn ( µ) và nối chuỗi ( ;).

Perl 6 , 60 byte

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

Mở rộng:

{    # 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
}

Sử dụng:

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

C, 116 113 byte

-3 byte để tính toán lại hình vuông mỗi lần

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);}

Ungolfed và cách sử dụng:

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 byte

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

Các trường hợp thử nghiệm

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

Thạch , 16 byte

Tôi đoán dù sao tôi cũng sẽ đăng bài này, mặc dù nó đã bị đánh trong khi tôi đang viết nó, bởi vì đó là một thuật toán khác biệt đáng chú ý và thật thú vị khi viết. (Tôi không thể tìm ra cách ÐĿphân tích cú pháp từ các tài liệu và phải từ bỏ nó, mặc dù biết rằng nó có thể sẽ dẫn đến một giải pháp ngắn hơn giải pháp này.)

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

Hãy thử trực tuyến!

Giải trình:

Ṅ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

Việc sử dụng <’¥về cơ bản là một cách ngắn để viết một dyad (liên kết với hai đối số) luôn trả về -1 (vì chúng ta biết câu trả lời sẽ không bao giờ nhỏ hơn cơ sở). Lựa chọn giữa việc chạy đệ quy và toàn bộ chương trình một cách đệ quy, cho phép chúng tôi xác định khi nào nên dừng lặp. Sau đó, khi ngăn xếp thư giãn vào cuối đệ quy, chúng tôi tiếp tục tăng -1 để xác định có bao nhiêu bước.

MATL, 25 21 byte

4 byte được lưu nhờ @Luis

XJx`tJYA!UsJq*tJqU-}@

Hãy thử trực tuyến!

Giải trình

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

Toán học, 80 byte

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

là ký tự sử dụng riêng U+F4A1được sử dụng để đại diện \[Function]. Nếu số bước không yêu cầu trong câu trả lời, điều này có thể được thực hiện trong 60 byte:

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