Dato un numero decimale k, trova il numero intero più piccolo in modo ntale che la radice quadrata di nsia all'interno kdi un numero intero. Tuttavia, la distanza dovrebbe essere diversa da zero - nnon può essere un quadrato perfetto.

Dato kun numero decimale o una frazione (a seconda di quale sia la più facile per te), in modo tale 0 < k < 1, emetta il numero intero positivo più piccolo in modo ntale che la differenza tra la radice quadrata di ne il numero intero più vicino alla radice quadrata di nsia minore o uguale a kma diverso da zero .

Se iè il numero intero più vicino alla radice quadrata di n, stai cercando il primo ndove 0 < |i - sqrt(n)| <= k.

Regole

• Non è possibile utilizzare l'implementazione insufficiente di una lingua di numeri non interi per banalizzare il problema.
• Altrimenti, si può presumere che kciò non causerà problemi, ad esempio con arrotondamenti a virgola mobile.

Casi test

.9         > 2
.5         > 2
.4         > 3
.3         > 3
.25        > 5
.2         > 8
.1         > 26
.05        > 101
.03        > 288
.01        > 2501
.005       > 10001
.003       > 27888
.001       > 250001
.0005      > 1000001
.0003      > 2778888
.0001      > 25000001
.0314159   > 255
.00314159  > 25599
.000314159 > 2534463

Ingressi del test case separati da virgola:

0.9, 0.5, 0.4, 0.3, 0.25, 0.2, 0.1, 0.05, 0.03, 0.01, 0.005, 0.003, 0.001, 0.0005, 0.0003, 0.0001, 0.0314159, 0.00314159, 0.000314159

Questo è code-golf , quindi vince la risposta più breve in byte.

Wolfram Language (Mathematica) , 34 byte

Min[⌈.5/#+{-#,#}/2⌉^2+{1,-1}]&

Provalo online!

Spiegazione

Il risultato deve essere della forma $m^2 \pm 1$ per qualche $m \in \mathbb{N}$ . Risolvere le disequazioni $\sqrt{m^2+1} - m \le k$e$m - \sqrt{m^2-1} \le k$, otteniamo$m \ge \frac{1-k^2}{2k}$ e$m \ge \frac{1+k^2}{2k}$ rispettivamente. Quindi il risultato è$\operatorname{min}\left({\left\lceil \frac{1-k^2}{2k} \right\rceil}^2+1, {\left\lceil \frac{1+k^2}{2k} \right\rceil}^2-1\right)$.

Python , 42 byte

lambda k:((k-1/k)//2)**2+1-2*(k<1/k%2<2-k)

Provalo online!

Basato sulla formula di alephalpha , controllando esplicitamente se siamo nel caso $m^2-1$ o $m^2+1$ tramite la condizione k<1/k%2<2-k.

Python 3.8 può salvare un byte con un'assegnazione in linea.

Python 3.8 , 41 byte

lambda k:((a:=k-1/k)//2)**2-1+2*(a/2%1<k)

Provalo online!

Questi hanno battuto la mia soluzione ricorsiva:

50 byte

f=lambda k,x=1:k>.5-abs(x**.5%1-.5)>0 or-~f(k,x+1)

Provalo online!

05AB1E , 16 byte

nD(‚>I·/înTS·<-ß

Porto di @alephalpha 's Mathematica risposta , con ispirazione da @Sok ' s Pyth risposta , quindi assicuratevi di upvote due!

Provalo online o verifica tutti i casi di test .

Spiegazione:

n                 # Take the square of the (implicit) input
                  #  i.e. 0.05 → 0.0025
 D(‚              # Pair it with its negative
                  #  i.e. 0.0025 → [0.0025,-0.0025]
    >             # Increment both by 1
                  #  i.e. [0.0025,-0.0025] → [1.0025,0.9975]
     I·           # Push the input doubled
                  #  i.e. 0.05 → 0.1
       /          # Divide both numbers with this doubled input
                  #  i.e. [1.0025,0.9975] / 0.1 → [10.025,9.975]
        î         # Round both up
                  #  i.e. [10.025,9.975] → [11.0,10.0]
         n        # Take the square of those
                  #  i.e. [11.0,10.0] → [121.0,100.0]
          TS      # Push [1,0]
            ·     # Double both to [2,0]
             <    # Decrease both by 1 to [1,-1]
              -   # Decrease the earlier numbers by this
                  #  i.e. [121.0,100.0] - [1,-1] → [120.0,101.0]
               ß  # Pop and push the minimum of the two
                  #  i.e. [120.0,101.0] → 101.0
                  # (which is output implicitly)

JavaScript (ES7),  51  50 byte

f=(k,n)=>!(d=(s=n**.5)+~(s-.5))|d*d>k*k?f(k,-~n):n

Provalo online!

(fallisce per i casi di test che richiedono troppa ricorsione)

Versione non ricorsiva,  57  56 byte

k=>{for(n=1;!(d=(s=++n**.5)+~(s-.5))|d*d>k*k;);return n}

Provalo online!

O per 55 byte :

k=>eval(`for(n=1;!(d=(s=++n**.5)+~(s-.5))|d*d>k*k;);n`)

Provalo online!

(ma questo è significativamente più lento)

J , 39 29 byte

[:<./_1 1++:*:@>.@%~1+(,-)@*:

NB. Questa versione più breve usa semplicemente la formula di @ alephalpha.

Provalo online!

39 byte, originale, forza bruta

2(>:@])^:((<+.0=])(<.-.)@(-<.)@%:)^:_~]

Provalo online!

Gestisce tutti i casi di test

Japt , 18 16 byte

-2 byte da Shaggy

_=¬u1)©U>½-½aZ}a

Provalo online!

Pyth, 22 21 byte

hSm-^.Ech*d^Q2yQ2d_B1

Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

Un altro porto dell'eccellente risposta di alephalpha , assicurati di dare loro un voto!

hSm-^.Ech*d^Q2yQ2d_B1   Implicit: Q=eval(input())
                  _B1   [1,-1]
  m                     Map each element of the above, as d, using:
           ^Q2            Q^2
         *d               Multiply by d
        h                 Increment
       c      yQ          Divide by (2 * Q)
     .E                   Round up
    ^           2         Square
   -             d        Subtract d
 S                      Sort
h                       Take first element, implicit print

Modifica: salvato un byte, grazie a Kevin Cruijssen

Perl 6 , 34 33 29 byte

-1 byte grazie a Grimy

{+(1...$_>*.sqrt*(1|-1)%1>0)}

Provalo online!

APL (Dyalog Unicode) , 27 byte ^SBCS

⌊/0~⍨¯1 1+2*⍨∘⌈+⍨÷⍨1(+,-)×⍨

Provalo online!

Treno monadico prendendo una discussione. Questa è una porta della risposta di alephalpha .

Come:

⌊/0~⍨¯1 1+2*⍨∘⌈+⍨÷⍨1(+,-)×⍨ ⍝ Monadic train

                         ×⍨ ⍝ Square of the argument
                   1(+,-)   ⍝ 1 ± that (returns 1+k^2, 1-k^2)
                 ÷⍨         ⍝ divided by
               +⍨           ⍝ twice the argument
             ∘⌈             ⍝ Ceiling
          2*⍨               ⍝ Squared
     ¯1 1+                  ⍝ -1 to the first, +1 to the second
  0~⍨                       ⍝ Removing the zeroes
⌊/                          ⍝ Return the smallest

C # (compilatore interattivo Visual C #) , 89 85 71 byte

k=>{double n=2,p;for(;!((p=Math.Sqrt(n)%1)>0&p<k|1-p<k);n++);return n;}

Provalo online!

-4 byte grazie a Kevin Cruijssen!

Java (JDK) , 73 70 byte

k->{double i=1,j;for(;(j=Math.sqrt(++i)%1)==0|j>=k&1-j>=k;);return i;}

Provalo online!

-3 bytes grazie a @ceilingcat

Java 8, 85 byte

n->{double i=1,p;for(;Math.abs(Math.round(p=Math.sqrt(i))-p)>n|p%1==0;i++);return i;}

La risposta C # .NET di Port of EmbodimentOfIgnorance .

Provalo online.

In Math.roundalternativa, può essere questo, ma sfortunatamente è lo stesso conteggio byte:

n->{double i=1,p;for(;Math.abs((int)((p=Math.sqrt(i))+.5)-p)>n|p%1==0;i++);return i;}

Provalo online.

MathGolf , 16 byte

²_b*α)½╠ü²1bαm,╓

Provalo online!

Non è un grande fan di questa soluzione. È una porta della soluzione 05AB1E, che si basa sulla stessa formula utilizzata dalla maggior parte delle risposte.

Spiegazione

²                  pop a : push(a*a)
 _                 duplicate TOS
  b                push -1
   *               pop a, b : push(a*b)
    α              wrap last two elements in array
     )             increment
      ½            halve
       ╠           pop a, b, push b/a
        ü          ceiling with implicit map
         ²         pop a : push(a*a)
          1        push 1
           b       push -1
            α      wrap last two elements in array
             m     explicit map
              ,    pop a, b, push b-a
               ╓   min of list

Forth (gforth) , 76 byte

: f 1 begin 1+ dup s>f fsqrt fdup fround f- fabs fdup f0> fover f< * until ;

Provalo online!

Spiegazione

Inizia un segnalino a 1 e lo incrementa in un ciclo. Ogni iterazione controlla se il valore assoluto della radice quadrata del contatore - il numero intero più vicino è inferiore a k

Spiegazione del codice

: f                   \ start a new word definition
  1                   \ place a counter on the stack, start it at 1
  begin               \ start and indefinite loop
    1+                \ add 1 to the counter
    dup s>f           \ convert a copy of the counter to a float
    fsqrt             \ get the square root of the counter
    fdup fround f-    \ get the difference between the square root and the next closes integer
    fabs fdup         \ get the absolute value of the result and duplicate
    f0>               \ check if the result is greater than 0 (not perfect square)
    fover f<          \ bring k to the top of the float stack and check if the sqrt is less than k
    *                 \ multiply the two results (shorter "and" in this case)
  until               \ end loop if result ("and" of both conditions) is true
;                     \ end word definition

Gelatina , 13 byte

Non sono riuscito a ottenere qualcosa di più teso dello stesso approccio di alephalpha
- vota la sua risposta Mathematica !

²;N$‘÷ḤĊ²_Ø+Ṃ

Provalo online!

Come?

²;N$‘÷ḤĊ²_Ø+Ṃ - Link: number, n (in (0,1))
²             - square n        -> n²
   $          - last two links as a monad:
  N           -   negate        -> -(n²)
 ;            -   concatenate   -> [n², -(n²)]
    ‘         - increment       -> [1+n², 1-(n²)]
      Ḥ       - double n        -> 2n
     ÷        - divide          -> [(1+n²)/n/2, (1-(n²))/n/2]
       Ċ      - ceiling         -> [⌈(1+n²)/n/2⌉, ⌈(1-(n²))/n/2⌉]
        ²     - square          -> [⌈(1+n²)/n/2⌉², ⌈(1-(n²))/n/2⌉²]
          Ø+  - literal         -> [1,-1]
         _    - subtract        -> [⌈(1+n²)/n/2⌉²-1, ⌈(1-(n²))/n/2⌉²+1]
            Ṃ - minimum         -> min(⌈(1+n²)/n/2⌉²-1, ⌈(1-(n²))/n/2⌉²+1) 

Japt , 14 byte

_=¬aZ¬r¹©U¨Z}a

Provalo

_=¬aZ¬r¹©U¨Z}a     :Implicit input of integer U
_                  :Function taking an integer Z as an argument
 =                 :  Reassign to Z
  ¬                :    Square root of Z
   a               :    Absolute difference with
    Z¬             :      Square root of Z
      r            :      Round to the nearest integer
       ¹           :  End reassignment
        ©          :  Logical AND with
         U¨Z       :  U greater than or equal to Z
            }      :End function
             a     :Return the first integer that returns true when passed through that function

Perl 5 -p , 42 byte

$t=sqrt++$\while($p=abs$t-int$t)>$_||!$p}{

Provalo online!