Suma dígitos hasta el cuadrado

11

Dado es cualquier número entero x> 0 y cualquier base y> 3.

  1. Suma todos los dígitos de x (si está escrito en la base establecida).
  2. Multiplique esto por el dígito más alto posible (siempre es base -1).
  3. Repita hasta que este valor sea (y - 1) ^ 2

Se busca el recuento de iteraciones y los pasos.

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

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

Especial:
en algunos casos (algunas combinaciones con una base de 3) no podrá obtener me (y - 1) ^ 2gusta para x = 53y y = 3. Por esta razón, ydebe ser mayor que 3 y puede ignorar esto.

El recuento de iteraciones debe ser el primer o el último valor

Este es el más bajo de conteo de bytes gana.

Dirk Reichel
fuente
Requerir el número de pasos en la respuesta parece una adición innecesaria al problema . Mi solución tuvo que agregar 21 bytes para hacer lo que equivalía a encontrar la longitud de una lista y restar 1.
ngenisis
@ngenisis va solo con un orden de salida, pero ignora el método (array, stack, delim. string, multiple strings ....). Hacer un seguimiento de 2 cosas diferentes (valor final y conteo) evita la recolección "ciega" de valores (más o menos) y es una buena adición a mi ojo. Quizás un enfoque diferente necesitará 5 bytes más en el cálculo, pero ahorra 8 en la parte de conteo (solo números aleatorios aquí).
Dirk Reichel

Respuestas:

4

Jalea , 14 13 bytes

-1 byte imprimiendo a medida que se repite ( reemplazando una separación de cadena µy concatenación ;)

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

TryItOnline!

¿Cómo?

Ṅ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

El 13 byter alternativo imprime cada entrada al bucle más un avance de línea ( ), y finalmente imprime implícitamente el recuento disminuido de los resultados recopilados, eliminando la necesidad de una separación de cadena monádica ( µ) y concatenación ( ;).

Jonathan Allan
fuente
1
Como no hay un conjunto de "formato de salida" solicitado. Las salidas múltiples contarán siempre que el pedido esté bien. De esta manera, la respuesta de 13 bytes es válida.
Dirk Reichel
Genial, no estaba seguro, ¡gracias por hacérmelo saber!
Jonathan Allan
4

Perl 6 , 60 bytes

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

Expandido:

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

Uso:

# 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)
Brad Gilbert b2gills
fuente
4

C, 116 113 bytes

-3 bytes para recalcular el cuadrado cada vez

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

Sin golf y uso:

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("");
}
Karl Napf
fuente
4

JavaScript (ES6), 97 91 84 82 bytes

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

Casos de prueba

Arnauld
fuente
4

Jalea , 16 bytes

Supongo que publicaré esto de todos modos, a pesar de que fue golpeado mientras lo escribía, porque es un algoritmo notablemente diferente y fue interesante escribirlo. (No pude entender cómo se ÐĿanalizó a partir de los documentos y tuve que renunciar a él, a pesar de saber que probablemente conduciría a una solución más corta que esta).

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

Pruébalo en línea!

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

El uso de <’¥es básicamente una forma corta de escribir una diada (enlace con dos argumentos) que siempre devuelve -1 (porque sabemos que la respuesta nunca será más pequeña que la base). Elegir entre ejecutar recursivamente y todo el programa recursivamente, nos permite determinar cuándo detener el bucle. Luego, cuando la pila se desenrolla al final de la recursión, seguimos incrementando el -1 para determinar cuántos pasos hubo.


fuente
2

MATL, 25 21 bytes

4 bytes guardados gracias a @Luis

XJx`tJYA!UsJq*tJqU-}@

Pruébalo en línea!

Explicación

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
Suever
fuente
@LuisMendo solucionado!
Suever
1

Mathematica, 80 bytes

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

es el carácter de uso privado que se U+F4A1usa para representar \[Function]. Si el número de pasos no fuera requerido en la respuesta, esto podría hacerse en 60 bytes:

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