Lấy cảm hứng từ video này bởi tecmath .

Một xấp xỉ của căn bậc hai của bất kỳ số nào xcó thể được tìm thấy bằng cách lấy căn bậc hai số nguyên s(nghĩa là số nguyên lớn nhất như vậy s * s ≤ x) và sau đó tính toán s + (x - s^2) / (2 * s). Hãy để chúng tôi gọi gần đúng này S(x). (Lưu ý: điều này tương đương với việc áp dụng một bước của phương pháp Newton-Raphson).

Mặc dù điều này không có gì khó hiểu, trong đó S (n ^ 2 - 1) sẽ luôn là √ (n ^ 2), nhưng nhìn chung nó sẽ rất chính xác. Trong một số trường hợp lớn hơn, điều này có thể có độ chính xác> 99,99%.

Đầu vào và đầu ra

Bạn sẽ lấy một số ở bất kỳ định dạng liên tục nào.

Ví dụ

Định dạng: Đầu vào -> Đầu ra

2 -> 1.50
5 -> 2.25
15 -> 4.00
19 -> 4.37               // actually 4.37       + 1/200
27 -> 5.20
39 -> 6.25
47 -> 6.91               // actually 6.91       + 1/300
57 -> 7.57               // actually 7.57       + 1/700
2612 -> 51.10            // actually 51.10      + 2/255
643545345 -> 25368.19    // actually 25,368.19  + 250,000,000/45,113,102,859
35235234236 -> 187710.50 // actually 187,710.50 + 500,000,000/77,374,278,481

Thông số kỹ thuật

• Đầu ra của bạn phải được làm tròn đến ít nhất là một phần trăm gần nhất (nghĩa là nếu câu trả lời là 47.2851, bạn có thể xuất 47,29)

• Đầu ra của bạn không cần phải có các số 0 và dấu thập phân nếu câu trả lời là một số nguyên (ví dụ: 125.00 cũng có thể được xuất ra là 125 và 125.0)

• Bạn không phải hỗ trợ bất kỳ số nào dưới 1.

• Bạn không phải hỗ trợ đầu vào không nguyên. (ví dụ: 1,52, v.v ...)

Quy tắc

Lỗ hổng tiêu chuẩn bị cấm.

Đây là một môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.

Thạch ,  8  7 byte

-1 byte nhờ vào công thức toán học đơn giản hóa của Olivier Grégoire - xem câu trả lời Java của họ .

÷ƽ+ƽH

Hãy thử trực tuyến!

Làm sao?

÷ƽ+ƽH - Link: number, n
 ƽ     - integer square root of n  -> s
÷       - divide                    -> n / s
    ƽ  - integer square root of n  -> s
   +    - add                       -> n / s + s
      H - halve                     -> (n / s + s) / 2

Haskell , 34 byte

f x=last[s+x/s|s<-[1..x],s*s<=x]/2

Hãy thử trực tuyến!

Giải thích về mã giả bắt buộc:

results=[]
foreach s in [1..x]:
 if s*s<=x:
  results.append(s+x/s)
return results[end]/2

Java (OpenJDK 8) , 32 byte

n->(n/(n=(int)Math.sqrt(n))+n)/2

Hãy thử trực tuyến!

Giải thích

Mã này tương đương với điều này:

double approx_sqrt(double x) {
  double s = (int)Math.sqrt(x);  // assign the root integer to s
  return (x / s + s) / 2
}

Các toán học đằng sau:

s + (x - s²) / (2 * s)  =  (2 * s² + x - s²) / (2 * s)
                        =  (x + s²) / (2 * s)
                        =  (x + s²) / s / 2
                        =  ((x + s²) / s) / 2
                        =  (x / s + s² / s) / 2
                        =  (x / s + s) / 2

Python 2 , 47 ... 36 byte

-3 byte nhờ @JungHwanMin
-1 byte nhờ @HyperNeutrino
-2 byte nhờ @JonathanFrech
-3 byte nhờ @ OlivierGrégoire

def f(x):s=int(x**.5);print(x/s+s)/2

Hãy thử trực tuyến!

MATL , 12 9 byte

X^kGy/+2/

Hãy thử trực tuyến!

R, 43 byte 29 byte

x=scan()
(x/(s=x^.5%/%1)+s)/2

Cảm ơn @Giuseppe về phương trình mới và trợ giúp chơi golf 12 byte với giải pháp chia số nguyên. Bằng cách hoán đổi chức năng gọi để quét, tôi đánh gôn thêm một vài byte.

Hãy thử trực tuyến!

APL (Dyalog) , 20 16 byte

{.5×s+⍵÷s←⌊⍵*.5}

Hãy thử trực tuyến!

JavaScript (ES7), 22 byte

x=>(s=x**.5|0)/2+x/s/2

Chúng tôi không thực sự cần một biến trung gian, vì vậy điều này thực sự có thể được viết lại thành:

x=>x/(x=x**.5|0)/2+x/2

Các trường hợp thử nghiệm

let f =

x=>x/(x=x**.5|0)/2+x/2

console.log(f(2))           // 1.50
console.log(f(5))           // 2.25
console.log(f(15))          // 4.00
console.log(f(19))          // 4.37
console.log(f(27))          // 5.20
console.log(f(39))          // 6.25
console.log(f(47))          // 6.91
console.log(f(57))          // 7.57
console.log(f(2612))        // 51.10
console.log(f(643545345))   // 25368.19
console.log(f(35235234236)) // 187710.50

C, 34 byte

Cảm ơn @Olivier Grégoire!

s;
#define f(x)(x/(s=sqrt(x))+s)/2

Chỉ hoạt động với floatđầu vào.

Hãy thử trực tuyến!

C,  41   39  37 byte

s;
#define f(x).5/(s=sqrt(x))*(x+s*s)

Hãy thử trực tuyến!

C,  49   47   45  43 byte

s;float f(x){return.5/(s=sqrt(x))*(x+s*s);}

Hãy thử trực tuyến!

Cảm ơn @JungHwan Min đã lưu hai byte!

Haskell , 40 byte

Một số khác bụi nhờ có H.PWiz.

f n|s<-realToFrac$floor$sqrt n=s/2+n/s/2

Hãy thử trực tuyến!

AWK , 47 44 38 byte

{s=int($1^.5);printf"%.2f",$1/2/s+s/2}

Hãy thử trực tuyến!

LƯU Ý: TIO like có thêm 2 byte \nđể làm cho đầu ra đẹp hơn. :)

Cảm giác như gian lận một chút khi sử dụng sqrt để tìm căn bậc hai, vì vậy đây là một phiên bản có thêm một vài byte không.

{for(;++s*s<=$1;);s--;printf("%.3f\n",s+($1-s*s)/(2*s))}

Hãy thử trực tuyến!

Vợt , 92 byte

Cảm ơn @JungHwan Min về mẹo trong phần bình luận

(λ(x)(let([s(integer-sqrt x)])(~r(exact->inexact(/(+ x(* s s))(* 2 s)))#:precision'(= 2))))

Hãy thử trực tuyến!

Ung dung

(define(fun x)
  (let ([square (integer-sqrt x)])
    (~r (exact->inexact (/ (+ x (* square square)) (* 2 square)))
        #:precision'(= 2))))

PowerShell , 54 byte

param($x)($x+($s=(1..$x|?{$_*$_-le$x})[-1])*$s)/(2*$s)

Hãy thử trực tuyến! hoặc Xác minh một số trường hợp thử nghiệm

Đưa đầu vào $xvà sau đó thực hiện chính xác những gì được yêu cầu. Phần |?tìm thấy số nguyên tối đa, khi bình phương, là yếu tố -lcơ bản so với eđầu vào $x, sau đó chúng tôi thực hiện các phép tính cần thiết. Đầu ra là ẩn.

Husk , 9 byte

½Ṡ§+K/(⌊√

Hãy thử trực tuyến!

Vẫn còn một cái gì đó xấu xí trong câu trả lời này, nhưng tôi dường như không thể tìm thấy một giải pháp ngắn hơn.

Giải trình

Tôi đang thực hiện một bước của thuật toán Newton (điều này thực sự tương đương với bước được đề xuất trong câu hỏi này)

½Ṡ§+K/(⌊√
  §+K/       A function which takes two numbers s and x, and returns s+x/s
 Ṡ           Call this function with the input as second argument and
      (⌊√    the floor of the square-root of the input as first argument
½            Halve the final result

Pyt , 11 10 byte

←Đ√⌊Đ↔⇹/+₂

Giải trình

code                explanation                        stack
←                   get input                          [input]
 Đ                  duplicate ToS                      [input,input]
  √⌊                calculate s                        [input,s]
    Đ               duplicate ToS                      [input,s,s]
     ↔              reverse stack                      [s,s,input]
      ⇹             swap ToS and SoS                   [s,input,s]
       /            divide                             [s,input/s]
        +           add                                [s+input/s]
         ₂          halve                              [(s+input/s)/2]
                    implicit print

Dải ngân hà , 17 14 byte

-3 byte bằng cách sử dụng công thức của Olivier Grégoire

^^':2;g:>/+2/!

Hãy thử trực tuyến!

Giải trình

code              explanation                   stack layout

^^                clear preinitialized stack    []
  ':              push input and duplicate it   [input, input]
    2;            push 2 and swap ToS and SoS   [input, 2, input]
      g           nth root                      [input, s=floor(sqrt(input))]
       :          duplicate ToS                 [input, s, s]
        >         rotate stack right            [s, input, s]
         /        divide                        [s, input/s]
          +       add                           [s+input/s]
           2/     divide by 2                   [(s+input/s)/2]
             !    output                        => (s+input/s)/2

C # (.NET Core) , 39 byte

v=>(v/(v=(int)System.Math.Sqrt(v))+v)/2

Hãy thử trực tuyến!

Phiên bản AC # của câu trả lời Java của Olivier Grégoire .