Quando si arrotonda un numero, se >= 5si aggiunge la cifra successiva 1. Ad esempio:

3.1415926535 rounded to 1dp is 3.1
3.1415926535 rounded to 4dp is 3.1416    <-- Note the 5 changed to 6
3.1415926535 rounded to 5dp is 3.14159

3.1415926535 rounded to 9dp is 3.141592654  <-- Note the 3 changed to 4

La tua sfida è quella di ricevere un numero intero come input e di output il numero di posizioni decimali prima del quale dovresti arrotondare la radice quadrata del numero, ovvero il numero di posizioni decimali prima della cifra dell'anumber che si >= 5verifica.

L'intero sarà compreso tra 0 e 100.000 inclusi, quindi per il caso limite di 59752 è necessario supportare 17 punti decimali (per verificare il 17 °).

Se il linguaggio di programmazione non è in grado di modificare il numero di punti decimali, è possibile visualizzare un "?" messaggio per l'utente.

Esempio:

Input    Root                     Output

    5 -> 2.23 606797749979     -> 2
   41 -> 6.40312423 743284     -> 8      (Largest gap under 100)
  596 -> 24.4131112314 674     -> 10     (Largest gap under 1000)
59752 -> 244.44222221212112029 -> 16     (Largest gap under 100000)

Fai quello che vuoi su quadrati perfetti.

Questo è code-golf, quindi vince il codice più corto.

Per chiunque sia interessato, il numero 310.617 è il più grande sotto 1.000.000 e ha 18 prima di raggiungere una cifra >= 5.

CJam, 17 byte

rie40mQsJ~>'4f>1#

Provalo online.

Pyth, 13 byte

f<5e@=*QC\d2Z

Suite di test

Inizia con Quguale all'input. Ad ogni passaggio, moltiplicare Qper 100, calcolato come chr('d'). Prendi la sua radice quadrata. Prendi questa mod 10. Se il risultato è maggiore di 5, termina. Stampa il numero di iterazioni necessarie per terminare, indicizzato 0.

In dettaglio:

f<5e@=*QC\d2Z
                   Q = eval(input())
f           Z      Filter for the first truthy result over the infinite sequence
                   starting at Z (= 0)
     =*Q           Q *=
        C\d             chr('d') (= 100)
                   ---------------------
    @  Q   2          Q ^ (1/2)
   e                            % 10
 <5               5 <

CJam, 29 26 28 byte

rimqs_'.+'.#)>{'5<}%0#]W'?er

Provalo online.

Mette un "?" se non appare il numero che può essere arrotondato per eccesso (quadrato perfetto o troppo lungo).

Pyth, 22 byte

J`%@Q2 1x.e<\4@Jbr2lJ1

Spiegazione

                       - Autoassign Q to evaluated input
   @Q2                 - Get the square root of Q
J`%    1               - Get the stuff after the decimal point and put it in a string. Store in J
         .e      r2lJ  - Create a range between 2 and the length of the string (forget about the 0. bit) and enumerate over it
              @Jb      - Get the current decimal place
           <\4         - Is it bigger than 4
        x            1 - Find the position of the first True value

Sono assolutamente certo che questo può essere giocato a golf. Se l'input non ha una cifra superiore a 4, verrà stampato -1. Supporta 17dp.

Javascript, 59 byte

f=a=>(a=/\.(.*?)[5-9]/.exec(Math.sqrt(a)),a?a[1].length:'?')

Restituisce ?per 59752 perché JavaScript utilizza solo la doppia precisione.

Shell Linux, 52 byte

dc -e'34k?vp'|cut -d. -f2|sed 's/.[5-9\s].*//'|wc -m

Ho provato per puro dc soluzione , ma non ci sono riuscito. La precisione è regolabile (primo numero).

Poiché l'OP specifica gentilmente che "puoi fare ciò che vuoi su quadrati perfetti", in questo caso questa soluzione produce la precisione + 1, in questo caso 35.

Mathematica 60 byte

(Position[Drop@@RealDigits[N[Sqrt@#,99]],x_/;x>4][[1,1]]-1)&

Esempio

(Position[Drop@@RealDigits[N[Sqrt@#, 99]], x_ /; x > 4][[1, 1]] - 1) &[59752]

16

Rubino, 46 ​​byte

Questo potrebbe non essere valido, poiché può contenere solo 16 cifre.

p (gets.to_i**0.5).to_s.split('.')[1]=~/[5-9]/