Dato un numero intero n> 2 , stampa o restituisce il numero intero non negativo k più piccolo in modo che a (n, k) = 9 , dove a (n, k) è definito da:

• a (n, 0) = n
• a (n, k + 1) =
  • a (n, k) / 2 + 1 se a (n, k) è pari
  • la somma delle cifre di a (n, k) ² (in base 10) se a (n, k) è dispari

Esempi

Per n = 5 , l'output previsto è 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)

Per n = 40 , l'output previsto è k = 2 :

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

Chiarimenti e regole

• L'ingresso è garantito per essere maggiore di 2.
• Il tuo programma dovrebbe teoricamente funzionare per qualsiasi valore di n . (In pratica, potrebbe essere limitato dalla dimensione intera massima supportata dalla tua lingua.)
• k può essere 0-indicizzato o 1-indicizzato. Per favore dichiaralo nella tua risposta.
• Questo è code-golf , quindi vince la risposta più breve in byte!

Primi valori

Di seguito sono riportati i primi valori da n = 3 a n = 422 , con k 0 indicizzato. (Per l'indicizzazione 1, basta aggiungere 1a questi valori.)

 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

Buccia , 13 byte

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

Questo è 1-indicizzato. Provalo online!

Spiegazione

Niente di speciale qui.

€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 byte (40 caratteri)

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

Provalo online!

Questo utilizza 1-indicizzazione di k, quindi fornisce 1 risposte più alte rispetto agli esempi in OP. Se questo non è il significato dell'indicizzazione 1, dovrò aggiungere 1 byte in più.

Spiegazione : è una funzione anonima. Usiamo semplicemente la funzione del Perl 6 per generare liste usando la ricorsione :—). Ecco come si presenta: (first element),(block that takes the previous element and gives the next)...(end condition). In questo caso, il primo elemento è $_(argomento della funzione principale) e la condizione finale è 9(soddisfatta quando generiamo un 9). Nel blocco centrale, usiamo $_fare riferimento al suo argomento (= l'elemento precedente della sequenza). Il ?? !!è il vecchio operatore ternario (meglio noto come ? :). Infine, prendiamo la lunghezza di questo elenco forzando il contesto numerico di +(...).

L'ultima cosa strana qui è la somma delle cifre. I numeri sono Cool(si comportano sia come stringhe che come numeri), quindi usiamo un metodo stringa .combsu $_²(dare un elenco di caratteri = cifre), quindi sommando i caratteri (che li converte in numeri).

Gelatina , 17 byte

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

Provalo online!

Approccio diretto. Utilizza l'indicizzazione basata su 0.

Spiegazione

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

-3 byte grazie a Jonathan Frech. -8 byte grazie a Maltysen. -7 byte grazie a Jonathan Allan. -1 byte grazie a Mr. Xcoder.

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

Provalo online!

Da qualcuno che probabilmente non conosce abbastanza matematica, questo sembra del tutto arbitrario. : P

Mathematica, 58 byte

1-indicizzato

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

Provalo online! (per lavorare su Mathics, Trviene sostituito con Total)

ecco la versione -1 byte di @JungHwanMin (ma non funziona su matematica quindi ho tenuto entrambi)

Mathematica, 57 byte

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

JavaScript (ES6), 59 50 byte

0-indicizzati.

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

Provalo

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>

Spiegazione

La prima cosa che facciamo è calcolare n-9. Se n==9poi quello, ovviamente, dà 0e le cose si fermano qui. Se n!=9poi n-9darà un valore diverso da zero che, essendo sincero, significa che possiamo continuare attraverso l'AND logico. Chiamiamo di nuovo la funzione, passandone una nuova n, calcolata come segue:

n%2?

Se nmodulo 2è veritiero, ovvero nè dispari.

[...""+n*n]

Moltiplicare nper se stesso, convertirlo in una stringa e distruggere quella stringa in una matrice di singoli caratteri (cifre).

 .join`+`

Ricongiungi i caratteri a una stringa usando +, dandoci un'espressione matematica.

eval(                   )

Valuta quell'espressione, dandoci la somma delle cifre di n*n.

:n/2+1

Se n%2è falso (cioè nè pari), allora semplicemente dividiamo nper 2e aggiungiamo 1.

Al risultato di richiamare nuovamente la funzione, aggiungiamo 1. Quindi, usando un input iniziale di 5, il processo procede come segue:

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

Gelatina ,  16  15 byte

-1 byte grazie alle miglia (uso di ternario se)

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

Un collegamento monadico che prende e restituisce numeri.
1-indicizzato

Provalo online! o vedere una suite di test (costringe i risultati a essere indicizzati a 0 e i formati come blocco di codice OP)

Come?

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

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

Provalo online!

Modifica: -3 byte grazie a @ Ørjan Johansen.

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

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

Provalo online!

05AB1E , 16 byte

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

Provalo online!

Spiegazione

[                  # 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 (importazioni) = 117 byte

Richiede 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

Funzione che accetta nun input intero e restituisce uno 0 k.

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 byte

Provalo online!

Ho davvero bisogno di un modo migliore di quello che devo sommare le cifre di un numero.

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

Pyth ,  23  22 byte

Per ora, questa è una funzione ricorsiva, ma proverò a passare a .W(funzionale while) per salvare byte invece .

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

Provalo qui! (con codice aggiuntivo per chiamare la funzione - usa- senza spazi)y<your_number>

Java 8, 110 98 byte

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

Spiegazione:

Provalo qui.

 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 byte

0-indicizzato

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

Provalo online!

Spiegazione

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

tl.u?%N2sj*NNTh/N2

Provalo online: dimostrazione

Spiegazione:

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 byte

0-indicizzati.

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

Provalo

Spiegazione

Input implicito di numero intero U.

UÆ             Ã

Generare un array di numeri interi da 0a U-1e passare ogni attraverso una funzione.

=

Imposta il valore di U.

v ?

Se Uè divisibile per 2.

U/2Ä

Udiviso per 2, più 1 ( Ä).

:U²ìx

Altro: Ualla potenza di 2 ( ²), diviso in un array di cifre ( ì) e ridotto di addizione ( x).

Nc

Aggiungi la matrice risultante alla matrice di input.

b9

Trova l'indice della prima occorrenza di 9nell'array. Emette implicitamente il risultato.