Gegeben ist eine ganze Zahl x> 0 und eine beliebige Basis y> 3.

1. Summiere alle Ziffern von x (falls in der eingestellten Basis geschrieben).
2. Multiplizieren Sie dies mit der höchstmöglichen Ziffer (ist immer base -1).
3. Wiederholen, bis dieser Wert ist (y - 1) ^ 2

Gesucht wird die Anzahl der Iterationen und die Schritte.

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

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

Special:
In einigen Fällen (einige Kombinationen mit einer Basis von 3) Sie werden nicht in der Lage sein zu bekommen (y - 1) ^ 2wie für x = 53und y = 3. Aus diesem Grund ymuss größer als 3 sein und Sie können dies ignorieren.

Die Anzahl der Iterationen muss der erste oder der letzte Wert sein

Dies ist Code-Golf mit der niedrigsten Anzahl an Bytes.

Gelee , 14 13 Bytes

-1 Byte durch Drucken während der Schleife ( ṄErsetzen einer Kettenseparation µund Verkettung ;)

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

TryItOnline!

Wie?

Ṅ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

Der alternative 13-Byter druckt jede Eingabe in die Schleife plus einen Zeilenvorschub ( Ṅ) und druckt schließlich implizit die dekrementierte Anzahl der gesammelten Ergebnisse, wodurch die Notwendigkeit einer monadischen Kettentrennung ( µ) und Verkettung ( ;) entfällt .

Perl 6 , 60 Bytes

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

Erweitert:

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

Verwendung:

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

-3 Bytes für die Neuberechnung des Quadrats jedes Mal

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 und Verwendung:

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

Testfälle

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

Gelee , 16 Bytes

Ich denke, ich werde das trotzdem posten, obwohl es während des Schreibens geschlagen wurde, weil es ein deutlich anderer Algorithmus ist und es interessant zu schreiben war. (Ich konnte nicht herausfinden, wie ÐĿaus den Dokumenten analysiert wurde, und musste darauf verzichten, obwohl ich wusste, dass dies wahrscheinlich zu einer kürzeren Lösung als dieser führen würde.)

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

Probieren Sie es online aus!

Erläuterung:

Ṅ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

Die Verwendung von <’¥ist im Grunde eine kurze Möglichkeit, eine Dyade (Verknüpfung mit zwei Argumenten) zu schreiben, die immer -1 zurückgibt (weil wir wissen, dass die Antwort niemals kleiner als die Basis sein wird). Wenn Sie zwischen einer rekursiven Ausführung und einer rekursiven Ausführung des gesamten Programms wählen, können Sie bestimmen, wann die Schleife beendet werden soll. Wenn sich der Stapel am Ende der Rekursion abwickelt, erhöhen wir die -1 weiter, um zu bestimmen, wie viele Schritte vorhanden waren.

MATL, 25 21 Bytes

4 Bytes dank @Luis gespeichert

XJx`tJYA!UsJq*tJqU-}@

Probieren Sie es online aus!

Erläuterung

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

Mathematica, 80 Bytes

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

ist das Zeichen U+F4A1für den privaten Gebrauch, das zur Darstellung verwendet wird \[Function]. Wenn die Anzahl der Schritte in der Antwort nicht erforderlich wäre, könnte dies in 60 Bytes erfolgen:

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