Dado un número decimal k, encuentre el número entero más pequeño ntal que la raíz cuadrada de nesté dentro kde un número entero. Sin embargo, la distancia no debe ser cero, nno puede ser un cuadrado perfecto.

Dado k, un número decimal o una fracción (lo que sea más fácil para usted), de tal manera que 0 < k < 1genere el número entero positivo más pequeño de nmanera que la diferencia entre la raíz cuadrada de ny el número entero más cercano a la raíz cuadrada de nsea ​​menor o igual a kpero diferente de cero .

Si ies el entero más cercano a la raíz cuadrada de n, está buscando el primer nlugar 0 < |i - sqrt(n)| <= k.

Reglas

• No puede utilizar la implementación insuficiente de un idioma de números no enteros para trivializar el problema.
• De lo contrario, puede suponer que keso no causará problemas con, por ejemplo, el redondeo de coma flotante.

Casos de prueba

.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

Entradas de caso de prueba separadas por comas:

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

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

Wolfram Language (Mathematica) , 34 bytes

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

Pruébalo en línea!

Explicación

El resultado debe ser de la forma $m^2 \pm 1$ para algunos $m \in \mathbb{N}$ . Resolviendo las inecuaciones $\sqrt{m^2+1} - m \le k$y$m - \sqrt{m^2-1} \le k$, obtenemos$m \ge \frac{1-k^2}{2k}$ y$m \ge \frac{1+k^2}{2k}$ respectivamente. Entonces el resultado es$\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 bytes

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

Pruébalo en línea!

Basado en la fórmula de alephalpha , verificando explícitamente si estamos en el caso $m^2-1$ o $m^2+1$ través de la condiciónk<1/k%2<2-k .

Python 3.8 puede guardar un byte con una asignación en línea.

Python 3.8 , 41 bytes

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

Pruébalo en línea!

Estos superaron mi solución recursiva:

50 bytes

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

Pruébalo en línea!

05AB1E , 16 bytes

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

Puerto de la respuesta de Mathematica de @alephalpha , inspirada en la respuesta de Pyth de @Sok , ¡así que asegúrese de votar a ambos!

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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 bytes

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

Pruébalo en línea!

(falla para los casos de prueba que requieren demasiada recursividad)

Versión no recursiva,  57  56 bytes

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

Pruébalo en línea!

O para 55 bytes :

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

Pruébalo en línea!

(pero este es significativamente más lento)

J , 39 29 bytes

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

NÓTESE BIEN. Esta versión más corta simplemente usa la fórmula de @ alephalpha.

Pruébalo en línea!

39 bytes, fuerza bruta original

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

Pruébalo en línea!

Maneja todos los casos de prueba

Japt , 18 16 bytes

-2 bytes de Shaggy

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

Pruébalo en línea!

Pyth, 22 21 bytes

hSm-^.Ech*d^Q2yQ2d_B1

Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

Excelente respuesta de otro puerto de alephalpha , ¡asegúrate de darles un voto positivo!

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

Editar: guardado un byte, gracias a Kevin Cruijssen

Perl 6 , 34 33 29 bytes

-1 byte gracias a Grimy

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

Pruébalo en línea!

APL (Dyalog Unicode) , ^{SBCS de} 27 bytes

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

Pruébalo en línea!

Tren monádico tomando una discusión. Este es un puerto de la respuesta de alephalpha .

Cómo:

⌊/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 # (compilador interactivo de Visual C #) , 89 85 71 bytes

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

Pruébalo en línea!

-4 bytes gracias a Kevin Cruijssen!

Java (JDK) , 73 70 bytes

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

Pruébalo en línea!

-3 bytes gracias a @ceilingcat

Java 8, 85 bytes

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

Respuesta de C # .NET de Port of EmbodimentOfIgnorance .

Pruébalo en línea.

El Math.roundpuede ser alternativamente esto, pero por desgracia, es el mismo byte-count:

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

Pruébalo en línea.

MathGolf , 16 bytes

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

Pruébalo en línea!

No soy un gran fanático de esta solución. Es un puerto de la solución 05AB1E, que se basa en la misma fórmula que utilizan la mayoría de las respuestas.

Explicación

²                  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

Adelante (gforth) , 76 bytes

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

Pruébalo en línea!

Explicación

Inicia un contador en 1 y lo incrementa en un bucle. Cada iteración comprueba si el valor absoluto de la raíz cuadrada del contador: el entero más cercano es menor que k

Explicación del código

: 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

Jalea , 13 bytes

No he logrado obtener nada más terser que el mismo enfoque que alephalpha
: ¡ vota tu respuesta de Mathematica !

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

Pruébalo en línea!

¿Cómo?

²;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 bytes

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

Intentalo

_=¬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 bytes

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

Pruébalo en línea!