Étant donné un nombre décimal k, recherchez le plus petit entier ntel que la racine carrée de nsoit à l'intérieur kd'un entier. Cependant, la distance doit être non nulle - nne peut pas être un carré parfait.

Étant donné k, un nombre décimal ou une fraction (selon ce qui est plus facile pour vous), tel que 0 < k < 1, affichez le plus petit entier positif de ntelle sorte que la différence entre la racine carrée de net l'entier le plus proche de la racine carrée de nsoit inférieure ou égale à kmais non nulle .

Si iest l'entier le plus proche de la racine carrée de n, vous recherchez le premier noù 0 < |i - sqrt(n)| <= k.

Règles

• Vous ne pouvez pas utiliser l'implémentation insuffisante d'un langage de nombres non entiers pour banaliser le problème.
• Sinon, vous pouvez supposer que kcela ne causera pas de problèmes avec, par exemple, l'arrondi à virgule flottante.

Cas de 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

Entrées de cas de test séparées par des virgules:

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

C'est le code-golf , donc la réponse la plus courte en octets l'emporte.

Wolfram Language (Mathematica) , 34 octets

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

Essayez-le en ligne!

Explication

Le résultat doit être de la forme pour certains . Résoudre les inéquations et , on obtient et respectivement. Le résultat est donc .$m^2 \pm 1$$m \in \mathbb{N}$$\sqrt{m^2+1} - m \le k$$m - \sqrt{m^2-1} \le k$$m \ge \frac{1-k^2}{2k}$$m \ge \frac{1+k^2}{2k}$$\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 octets

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

Essayez-le en ligne!

Basé sur la formule d'alephalpha , vérifiant explicitement si nous sommes dans le cas $m^2-1$ ou $m^2+1$ via la condition k<1/k%2<2-k.

Python 3.8 peut enregistrer un octet avec une affectation en ligne.

Python 3.8 , 41 octets

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

Essayez-le en ligne!

Ceux-ci ont battu ma solution récursive:

50 octets

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

Essayez-le en ligne!

05AB1E , 16 octets

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

Port de @alephalpha « réponse Mathematica , avec l' inspiration de @Sok » réponse Pyth s , alors assurez - vous upvote les deux!

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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 octets

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

Essayez-le en ligne!

(échoue pour les cas de test qui nécessitent trop de récursivité)

Version non récursive,  57  56 octets

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

Essayez-le en ligne!

Ou pour 55 octets :

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

Essayez-le en ligne!

(mais celui-ci est beaucoup plus lent)

J , 39 29 octets

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

NB. Cette version plus courte utilise simplement la formule de @ alephalpha.

Essayez-le en ligne!

39 octets, original, force brute

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

Essayez-le en ligne!

Gère tous les cas de test

Japt , 18 16 octets

-2 octets de Shaggy

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

Essayez-le en ligne!

Pyth, 22 21 octets

hSm-^.Ech*d^Q2yQ2d_B1

Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

Un autre port de l'excellente réponse d' alephalpha , assurez-vous de leur donner une note positive!

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

Edit: enregistré un octet, grâce à Kevin Cruijssen

Perl 6 , 34 33 29 octets

-1 octet grâce à Grimy

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 27 octets ^SBCS

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

Essayez-le en ligne!

Train monadique prenant un argument. Ceci est un port de réponse d' Alephalpha .

Comment:

⌊/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 # (Visual C # Interactive Compiler) , 89 85 71 octets

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

Essayez-le en ligne!

-4 octets grâce à Kevin Cruijssen!

Java (JDK) , 73 70 octets

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

Essayez-le en ligne!

-3 bytes merci à @ceilingcat

Java 8, 85 octets

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

Réponse C # .NET de Port of EmbodimentOfIgnorance .

Essayez-le en ligne.

Le Math.roundpeut également être ceci, mais malheureusement c'est le même nombre d'octets:

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

Essayez-le en ligne.

MathGolf , 16 octets

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

Essayez-le en ligne!

Pas un grand fan de cette solution. Il s'agit d'un portage de la solution 05AB1E, qui est basé sur la même formule que la plupart des réponses utilisent.

Explication

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

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

Essayez-le en ligne!

Explication

Démarre un compteur à 1 et l'incrémente en boucle. À chaque itération, il vérifie si la valeur absolue de la racine carrée du compteur - l'entier le plus proche est inférieur à k

Explication du code

: 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

Gelée , 13 octets

Je n'ai pas réussi à obtenir quelque chose de plus tordu que la même approche que l'alephalphe
- allez voter pour sa réponse Mathematica !

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

Essayez-le en ligne!

Comment?

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

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

Essayez-le

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

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

Essayez-le en ligne!