Dado um número inteiro n> 2 , imprima ou retorne o menor número inteiro não negativo k, de modo que a (n, k) = 9 , onde a (n, k) seja definido por:

• a (n, 0) = n
• a (n, k + 1) =
  • a (n, k) / 2 + 1 se a (n, k) for par
  • a soma dos dígitos de a (n, k) ² (na base 10) se a (n, k) for ímpar

Exemplos

Para n = 5 , a saída esperada é 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 , a saída esperada é k = 2 :

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

Esclarecimentos e regras

• A entrada é garantida como superior a 2.
• Seu programa deve, teoricamente, funcionar com qualquer valor de n . (Na prática, pode ser limitado pelo tamanho máximo inteiro suportado pelo seu idioma.)
• k pode ser indexado em 0 ou 1. Por favor, indique-o na sua resposta.
• Isso é código-golfe , então a resposta mais curta em bytes vence!

Primeiros valores

Estes são os primeiros valores de n = 3 para n = 422 , com k 0-indexado. (Para indexação 1, basta adicionar 1a esses 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

Casca , 13 bytes

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

Isso é indexado em 1. Experimente online!

Explicação

Nada muito chique aqui.

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

Experimente online!

Ele usa a indexação 1 de k, portanto fornece 1 respostas maiores que os exemplos no OP. Se não é isso que significa a indexação 1, terei que adicionar mais 1 byte.

Explicação : É uma função anônima. Nós apenas usamos o recurso do Perl 6 para gerar listas usando a recursão :—). Parece que este: (first element),(block that takes the previous element and gives the next)...(end condition). Nesse caso, o primeiro elemento é $_(argumento da função principal) e a condição final é 9(preenchida quando geramos um 9). No bloco do meio, usamos $_para nos referir a seu argumento (= o elemento anterior da sequência). o?? !! é o antigo operador ternário (mais conhecido como ? :). Finalmente, levamos o comprimento dessa lista forçando o contexto numérico por +(...).

A última coisa estranha aqui é a soma dos dígitos. Os números são Cool(se comportam como seqüências de caracteres e números); portanto, usamos um método de sequência .combem $_²(forneça uma lista de caracteres = dígitos) e, em seguida, adicione os caracteres (que os converte novamente em números).

Geléia , 17 bytes

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

Experimente online!

Abordagem direta. Usa indexação baseada em 0.

Explicação

²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 graças a Jonathan Frech. -8 bytes graças a Maltysen. -7 bytes graças a Jonathan Allan. -1 byte graças ao Sr. Xcoder.

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

Experimente online!

De alguém que provavelmente não conhece matemática o suficiente, isso parece completamente arbitrário. : P

Mathematica, 58 bytes

Indexado 1

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

Experimente online! (para trabalhar em matemática, Tré substituído por Total)

aqui está a versão de -1 byte por @JungHwanMin (mas não funciona em matemática, por isso guardei os dois)

Mathematica, 57 bytes

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

JavaScript (ES6), 59 50 bytes

Indexado a 0.

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

Tente

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>

Explicação

A primeira coisa que fazemos é calcular n-9. Se n==9então isso, obviamente, dá 0e as coisas param por aí. Se, n!=9então n-9, fornecer um valor diferente de zero, o que, sendo verdade, significa que podemos continuar com o AND lógico. Chamamos a função novamente, passando uma nova npara ela, calculada da seguinte forma:

n%2?

Se o nmódulo 2é verdadeiro - ou seja, né ímpar.

[...""+n*n]

Multiplique npor si só, converta-o em uma sequência e destrua-a em uma matriz de caracteres individuais (dígitos).

 .join`+`

Volte a juntar os caracteres a uma string usando +, dando-nos uma expressão matemática.

eval(                   )

Avalie essa expressão, dando-nos a soma dos dígitos de n*n.

:n/2+1

Se n%2for falsey (ou seja, nfor par), simplesmente dividimos npor 2e adicionamos 1.

Ao resultado da chamada da função novamente, adicionamos 1. Portanto, usando uma entrada inicial de 5, o processo é o seguinte:

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

Geléia ,  16  15 bytes

-1 byte graças a milhas (uso de ternário se)

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

Um link monádico que recebe e retorna números.
Indexado 1

Experimente online! ou veja uma suíte de testes (restringe os resultados a serem indexados a 0 e formatos como bloco de código OP)

Quão?

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

Experimente online!

Edit: -3 bytes graças a @ Ørjan Johansen.

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

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

Experimente online!

05AB1E , 16 bytes

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

Experimente online!

Explicação

[                  # 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 (importações) = 117 bytes

Requer 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

Função que recebe ncomo uma entrada inteira e retorna um valor baseado em 0k .

Ungolfed:

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

Experimente online!

Eu realmente preciso de uma maneira melhor do que a soma dos dígitos de um número.

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

Pitão ,  23  22 bytes

Por enquanto, essa é uma função recursiva, mas tentarei mudar para .W(funcional while) para salvar bytes .

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

Experimente aqui! (com código adicional para chamar a função - use- sem espaços)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;}

Indexado a 0

Explicação:

Experimente aqui.

 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

Indexado a 0

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

Experimente online!

Explicação

(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

Pitão, 18 bytes

tl.u?%N2sj*NNTh/N2

Experimente online: Demonstração

Explicação:

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

Indexado a 0.

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

Tente

Explicação

Entrada implícita de número inteiro U.

UÆ             Ã

Gere uma matriz de números inteiros de 0para U-1e passe cada um por uma função.

=

Defina o valor de U.

v ?

Se Ué divisível por 2.

U/2Ä

Udividido por 2, mais 1 ( Ä).

:U²ìx

Senão: Ucom a potência de 2 ( ²), divida em uma matriz de dígitos ( ì) e reduzida pela adição ( x).

Nc

Anexe a matriz resultante à matriz de entradas.

b9

Encontre o índice da primeira ocorrência de 9na matriz. Saída implícita do resultado.