Étant donné, tout entier x> 0 et toute base y> 3.

1. Additionnez tous les chiffres de x (s'ils sont écrits dans la base définie).
2. Multipliez cela par le chiffre le plus élevé possible (est toujours base -1).
3. Répétez jusqu'à ce que cette valeur soit (y - 1) ^ 2

La recherche est le nombre d'itérations et les étapes.

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

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

Spécial:
Dans certains cas (certaines combinaisons avec une base de 3), vous ne pourrez pas (y - 1) ^ 2aimer x = 53et pour y = 3. Pour cette raison, il ydoit être supérieur à 3 et vous pouvez l'ignorer.

Le nombre d'itérations doit être la première ou la dernière valeur

Il s'agit du nombre de octets le plus bas de code-golf .

Gelée , 14 13 octets

-1 octet en imprimant en boucle ( Ṅremplacement d'une séparation de chaîne µet concaténation ;)

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

TryItOnline!

Comment?

Ṅ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

L'alternative de 13 octets imprime chaque entrée de la boucle plus un saut de ligne ( Ṅ), et imprime finalement implicitement le nombre décrémenté des résultats collectés, supprimant le besoin d'une séparation de chaîne monadique ( µ) et d'une concaténation ( ;).

Perl 6 , 60 octets

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

Étendu:

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

Usage:

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

-3 octets pour recalculer le carré à chaque fois

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

Non golfé et utilisation:

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 octets

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

Cas de test

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

Gelée , 16 octets

Je suppose que je posterai tout de même, même s'il a été battu pendant que j'écrivais, car c'est un algorithme notablement différent et c'était intéressant à écrire. (Je n'ai pas pu comprendre comment ÐĿanalysé à partir des documents et j'ai dû y renoncer, même si je savais que cela conduirait probablement à une solution plus courte que celle-ci.)

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

Essayez-le en ligne!

Explication:

Ṅ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

L'utilisation de <’¥est essentiellement un moyen court d'écrire une dyade (lien avec deux arguments) qui renvoie toujours -1 (car nous savons que la réponse ne sera jamais plus petite que la base). Choisir entre l'exécution récursive et l'ensemble du programme de manière récursive nous permet de déterminer quand arrêter la boucle. Ensuite, lorsque la pile se déroule à la fin de la récursivité, nous continuons à incrémenter le -1 pour déterminer le nombre d'étapes.

MATL, 25 21 octets

4 octets enregistrés grâce à @Luis

XJx`tJYA!UsJq*tJqU-}@

Essayez-le en ligne!

Explication

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 octets

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

est le caractère à usage privé U+F4A1utilisé pour représenter \[Function]. Si le nombre d'étapes n'était pas requis dans la réponse, cela pourrait être fait en 60 octets:

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