Dado un número entero n> 2 , imprime o devuelve el número entero no negativo más pequeño k tal que a (n, k) = 9 , donde a (n, k) se define por:

• a (n, 0) = n
• a (n, k + 1) =
  • a (n, k) / 2 + 1 si a (n, k) es par
  • la suma de los dígitos de a (n, k) ² (en base 10) si a (n, k) es impar

Ejemplos

Para n = 5 , la salida esperada es k = 4 :

a(5, 0) = 5
a(5, 1) = 7  (5² = 25 and 2 + 5 = 7)
a(5, 2) = 13 (7² = 49 and 4 + 9 = 13)
a(5, 3) = 16 (13² = 169 and 1 + 6 + 9 = 16)
a(5, 4) = 9  (16 / 2 + 1)

Para n = 40 , la salida esperada es k = 2 :

a(40, 0) = 40
a(40, 1) = 21 (40 / 2 + 1)
a(40, 2) = 9  (21² = 441 and 4 + 4 + 1 = 9)

Aclaraciones y reglas.

• Se garantiza que la entrada sea mayor que 2.
• Su programa teóricamente debería funcionar para cualquier valor de n . (En la práctica, puede estar limitado por el tamaño entero máximo admitido por su idioma).
• k puede estar indexado a 0 o indexado a 1. Por favor, indíquelo en su respuesta.
• Este es el código de golf , por lo que gana la respuesta más corta en bytes

Primeros valores

A continuación se muestran los primeros valores de n = 3 a n = 422 , con k 0 indexado. (Para la indexación 1, solo agregue 1a estos valores).

 1  2  4  3  3  5  0  4  3  4  2  6  1  1  6  5  5  4  1  5  2  3  3  7  6  2  3  2  2  7
 6  6  5  6  6  5  1  2  2  6  6  3  1  4  3  4  4  8  1  7  6  3  5  4  6  3  2  3  3  8
 7  7  3  7  4  6  6  7  5  7  6  6  6  2  4  3  3  3  6  7  3  7  2  4  7  2  6  5  6  4
 7  5  2  5  6  9  6  2  3  8  2  7  1  4  6  6  6  5  1  7  4  4  3  3  7  4  3  4  2  9
 6  8  6  8  6  4  6  8  2  5  3  7  6  7  3  8  2  6  7  8  6  7  5  7  6  7  4  3  3  5
 6  4  3  4  4  4  6  7  6  8  3  4  6  8  7  3  6  5  6  8  3  3  2  7  6  6  5  7  6  5
 7  8  2  6  3  3  6  6  6  7  4 10  6  7  3  3  6  4  1  9  2  3  3  8  7  2  6  5  2  7
 7  7  6  7  3  6  7  2  4  8  3  5  6  5  6  4  2  4  6  8  3  5  6  4  7  5  2  3  6 10
 7  7  3  9  2  7  1  9  5  7  6  5  6  7  4  9  6  3  6  6  3  4  2  8  7  7  6  8  6  4
 7  9  4  3  3  7  7  8  3  9  4  7  6  8  3  6  6  8  7  7  7  8  6  5  7  4  6  4  2  6
 7  7  6  5  3  4  7  5  4  5  3  5  7  7  6  8  2  7  1  9  6  4  6  5  7  7  2  9  6  8
 7  4  3  7  4  6  6  7  6  9  3  4  6  4  2  3  3  8  1  7  6  7  2  6  7  8  3  7  5  6
 7  8  2  9  3  3  6  7  6  4  4  4  6  7  6  7  6  7  6  8  7  5  6 11  7  7  3  8  4  4
 7  4  6  7  3  5  6  2  2 10  6  3  6  4  3  4  4  9  7  8  3  3  6  7  7  6  4  3  6  8

Casco , 13 bytes

€9¡?o→½ȯΣd□¦2

Esto es 1 indexado. Pruébalo en línea!

Explicación

Nada muy lujoso aquí.

€9¡?o→½ȯΣd□¦2  Implicit input, say n = 5
  ¡            Iterate the following function:
   ?       ¦2   If divisible by 2,
    o→½         then halve and increment,
       ȯΣd□     else square, take digits and get their sum.
               This gives an infinite sequence: [5,7,13,16,9,9,9,9,9..
€9             1-based index of 9; print implicitly.

Perl 6 , 41 bytes (40 caracteres)

{+($_,{$_%2??[+] $_².comb!!$_/2+1}...9)}

Pruébalo en línea!

Esto utiliza 1 indexación de k, por lo que da 1 respuestas más altas que los ejemplos en OP. Si esto no es lo que significa la indexación 1, tendré que agregar 1 byte más.

Explicación : es una función anónima. Simplemente utilizamos las instalaciones de Perl 6 para generar listas usando recursividad :—). Se ve así: (first element),(block that takes the previous element and gives the next)...(end condition). En este caso, el primer elemento es $_(argumento de la función principal) y la condición final es 9(cumplida cuando generamos un 9). En el bloque del medio, usamos $_para referirnos a su argumento (= el elemento anterior de la secuencia). El ?? !!es el antiguo operador ternario (mejor conocido como ? :). Finalmente, tomamos la longitud de esta lista forzando el contexto numérico por +(...).

La última cosa extraña aquí es la suma de dígitos. Los números son Cool(se comportan como cadenas y números), por lo que usamos un método de cadena .comben $_²(dar una lista de caracteres = dígitos), luego agregamos los caracteres (que los convierte de nuevo en números).

Jalea , 17 bytes

²DSµH‘$Ḃ?ßµ-n9$?‘

Pruébalo en línea!

Enfoque directo. Utiliza indexación basada en 0.

Explicación

²DSµH‘$Ḃ?ßµ-n9$?‘  Input: n
               ?   If
            n9$      n != 9
          µ        Then
        ?            If
       Ḃ               n % 2 == 1
   µ                 Then
²                      Square
 D                     Decimal digits
  S                    Sum
      $              Else
    H                  Halve
     ‘                 Increment
         ß           Call recursively
                   Else
           -         The constant -1
                ‘  Increment

Python 2 , 129 126 76 68 67 64 54 53 bytes

-3 bytes gracias a Jonathan Frech. -8 bytes gracias a Maltysen. -7 bytes gracias a Jonathan Allan. -1 byte gracias al Sr. Xcoder.

f=lambda n:n-9and-~f(n%2*sum(map(int,`n*n`))or 1+n/2)

Pruébalo en línea!

De alguien que probablemente no sabe suficientes matemáticas, esto parece completamente arbitrario. :PAGS

Mathematica, 58 bytes

1 indexado

If[#!=9,#0@If[OddQ@#,Total@IntegerDigits[#^2],#/2+1]+1,0]&

Pruébalo en línea! (para trabajar en matemáticas, Trse reemplaza con Total)

aquí hay una versión de -1 byte de @JungHwanMin (pero no funciona en matemáticas, así que guardé ambas)

Mathematica, 57 bytes

If[#!=9,#0@If[2∣#,#/2+1,Total@IntegerDigits[#^2]]+1,0]&

JavaScript (ES6), 59 50 bytes

0 indexado.

f=n=>n-9&&f(n%2?eval([...""+n*n].join`+`):n/2+1)+1

Intentalo

o.innerText=(
f=n=>n-9&&f(n%2?eval([...""+n*n].join`+`):n/2+1)+1
)(i.value=5);oninput=_=>o.innerText=f(+i.value)

<input id=i min=3 type=number><pre id=o>

Explicación

Lo primero que hacemos es calcular n-9. Si n==9entonces eso, obviamente, da 0y las cosas se detienen allí. Si n!=9entonces n-9dará un valor distinto de cero que, siendo sincero, significa que podemos continuar a través del AND lógico. Llamamos a la función nuevamente, pasándole una nueva n, calculada de la siguiente manera:

n%2?

Si el nmódulo 2es verdadero, nes decir, es extraño.

[...""+n*n]

Multiplique npor sí mismo, conviértalo en una cadena y desestructura esa cadena en una matriz de caracteres individuales (dígitos).

 .join`+`

Vuelva a unir los caracteres a una cadena usando +, dándonos una expresión matemática.

eval(                   )

Evalúa esa expresión, dándonos la suma de los dígitos de n*n.

:n/2+1

Si n%2es falsey (es decir, nes par), simplemente dividimos npor 2y sumamos 1.

Al resultado de llamar nuevamente a la función, agregamos 1. Entonces, usando una entrada inicial de 5, el proceso es el siguiente:

f(5)
= -4&&f(7)+1
= -2&&(f(13)+1)+1
=  4&&((f(16)+1)+1)+1
=  7&&(((f(9)+1)+1)+1)+1
=     (((0+1)+1)+1)+1
= 4

Jalea ,  16  15 bytes

-1 byte gracias a millas (uso de ternario si)

²DSµH‘µḂ?_9$пL

Un enlace monádico que toma y devuelve números.
1 indexado

Pruébalo en línea! o vea un conjunto de pruebas (obliga a que los resultados estén indexados a 0 y los formatos como el bloque de código OP)

¿Cómo?

²DSµH‘µḂ?_9$пL - Link: number, n
            п  - collect results in a list while:
           $    -   last two links as a monad:
         _9     -     subtract nine
        ?       -   if:
       Ḃ        -     bit - current loop input modulo by 2 (1 if odd, 0 if even)
   µ            -   ...then:
²               -     square the current loop input
 D              -     cast to a list of its decimal digits
  S             -     sum
      µ         -   ...else:
    H           -     halve current loop input
     ‘          -     increment
              L - length (get the number of results collected
                -         - this includes the 9, so is 1-indexed w.r.t. k)

Haskell, 62 59 bytes

f 9=0
f a=1+f(cycle[div a 2+1,sum[read[d]|d<-show$a^2]]!!a)

Pruébalo en línea!

Editar: -3 bytes gracias a @ Ørjan Johansen.

Perl 5 , 56 + 1 (-n) = 57 bytes

$|++,$_=$_%2?eval$_**2=~s/./+$&/gr:1+$_/2while$_-9;say$|

Pruébalo en línea!

05AB1E , 16 bytes

[Ð9Q#Èi2÷>ënSO]N

Pruébalo en línea!

Explicación

[                  # start a loop
 Ð                 # triplicate current number
  9Q#              # if it equals 9, break
     Èi            # if even
       2÷>         # divide by 2 and increment
          ë        # else
           n       # square
            SO     # sum digits
              ]    # end loop
               N   # push the iteration counter N

VB.NET (.NET 4.5.2), 107 + 20 (importaciones) = 117 bytes

Requiere Imports System.Linq

Function A(n)
While n<>9
n=If(n Mod 2=0,n/2+1,CStr(n^2).Sum(Function(c)Val(c)))
A+=1
End While
End Function

Función que toma ncomo entrada entera y devuelve un 0 k.

Sin golf:

Function A(n) ' input/output types are Object, but we will be casting to integer
    'A = 0 ' VB will create an implicit variable with the same name as the function

    ' loop until a(n, k) = 9
    ' using n as the variable to store a(n, k)
    While n <> 9

        n = If(n Mod 2 = 0, ' equivalent to c# ternary ?: operator

            n / 2 + 1, ' even case

            CStr(n ^ 2).Sum(Function(c) Val(c)))
            ' odd case
            ' cast number to string
            ' then convert each char to the number it represents
            ' and do a linq sum

        A += 1 ' Object + Integer will coerce to an integer
    End While

    ' Where's the return?
    ' That implicit variable with the matching name will get returned if there's no explicit return
End Function

Golfscript, 34 bytes

Pruébalo en línea!

Realmente necesito una mejor manera de sumar los dígitos de un número.

~{9-}{.2%{.*`{+48-}*48-}{2/)}if}/,

Pyth ,  23  22 bytes

Por ahora, esta es una función recursiva, pero intentaré cambiar a .W(funcional mientras) para guardar bytes .

L&-b9hy|*%b2sj^b2Th/b2

Pruébalo aquí! (con código adicional para llamar a la función - uso- sin espacios)y<your_number>

Java 8, 110 98 bytes

n->{int k=0,s;for(;n!=9;k++){s=0;for(int c:(n*n+"").getBytes())s+=c-48;n=n%2<1?n/2+1:s;}return k;}

0 indexado

Explicación:

Pruébalo aquí

 n->             // Method with integer as both input and return-type
   int k=0,      //  Result-integer `k` starting at 0
       s;        //  Sum-integer
   for(;n!=9;    //  Loop (1) as long as `n` is not 9
        k++){    //    And increase `k` by 1 after every iteration
     s=0;        //   Reset sum `s` to 0
     for(int c:(n*n+"").getBytes())
                 //   Do `n*n` and inner loop (2) over the digits as characters
       s+=c-48;  //    And increase the sum `s` with these digits
                 //   End of inner loop (2) (implicit / single-line body)
     n=n%2<1?    //   If `n` is even:
        n/2+1    //    Change `n` to `n/2+1`
       :         //   Else:
        s;       //    Change `n` to sum `s`
  }              //  End of loop (1)
  return k;      //  Return the result `k`
}                // End of separated method (2)

Clojure v1.8, 124 113 112 bytes

0 indexado

(fn[n](loop[a n k 0](if(= a 9)k(recur(if(even? a)(+(/ a 2)1)(apply +(map #(-(int %)48)(str(* a a)))))(inc k)))))

Pruébalo en línea!

Explicación

(loop[a n k 0](if(= a 9)...))  Loop until a=9
(if(even? a)(+(/ a 2)1)...)    If even, a(n, k) / 2 + 1 if a(n, k)
(if(even? a)...(apply +(map #(-(int %)48)(str(* a a)))))  If odd, calculate the sum of digits of a(n, k)²
#(-(int %)48)                  Convert character to number

Pyth, 18 bytes

tl.u?%N2sj*NNTh/N2

Pruébalo en línea: demostración

Explicación:

tl.u?%N2sj*NNTh/N2
  .u                 apply the following function to the input, 
                     until it runs into a fixed point
    ?%N2                if value % 2 == 1:
          *NN               value * value
         j   T              convert to digits
        s                   sum
                        else:
               /N2          value / 2
              h              + 1
 l                   get the length of all visited values
t                     - 1

Japt 22 21 bytes

0 indexado.

NcUÆ=v ?U/2Ä:U²ìxà b9

Intentalo

Explicación

Entrada implícita de entero U.

UÆ             Ã

Generar una matriz de enteros de 0a U-1y pasar cada uno a través de una función.

=

Establece el valor de U.

v ?

Si Ues divisible por 2.

U/2Ä

Udividido por 2, más 1 ( Ä).

:U²ìx

De lo contrario: Ua la potencia de 2 ( ²), dividido en una matriz de dígitos ( ì) y reducido por la suma ( x).

Nc

Agregue la matriz resultante a la matriz de entradas.

b9

Encuentre el índice de la primera aparición de 9en la matriz. Salida implícita del resultado.