受到tecmath 这段视频的启发。

x通过取整数平方根s（即使得的最大整数s * s ≤ x）然后计算，可以找到任意数量的平方根的近似值s + (x - s^2) / (2 * s)。让我们称之为近似值S(x)。（注意：这等效于应用牛顿-拉夫森方法的一个步骤）。

尽管这确实有些古怪，但S（n ^ 2-1-）始终为√（n ^ 2），但通常它是非常准确的。在某些较大的情况下，这可以具有> 99.99％的精度。

输入输出

您将采用任何方便的格式输入一个数字。

例子

格式：输入->输出

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

技术指标

• 您的输出必须四舍五入到至少最接近的百分位数（即，如果答案为47.2851，则您可以输出47.29）

• 如果答案是整数，则输出不必带有零和小数点（例如125.00也可以输出为125和125.0）

• 您不必支持1以下的任何数字。

• 您不必支持非整数输入。（即1.52等...）

规则

禁止使用标准漏洞。

这是一个代码高尔夫球，因此最短答案以字节为单位。

果冻， 8  7 字节

感谢OlivierGrégoire简化的数学公式，获得-1个字节-请参见其Java答案。

÷ƽ+ƽH

在线尝试！

怎么样？

÷ƽ+ƽ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个字节

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

在线尝试！

命令式伪代码的说明：

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

Java（OpenJDK 8），32字节

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

在线尝试！

说明

该代码等效于此：

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

背后的数学：

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个字节

感谢@JungHwanMin -3个字节感谢@HyperNeutrino
-1个字节-感谢@JonathanFrech
感谢-2个
字节感谢@OlivierGrégoire感谢-3个字节

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

在线尝试！

MATL，12 9字节

X^kGy/+2/

在线尝试！

R，43字节 29字节

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

感谢@Giuseppe提供了新的等式，并使用整数除法解决方案帮助高尔夫球了12个字节。通过换出函数调用进行扫描，我又打了几个字节。

在线尝试！

APL（Dyalog），20 16字节

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

在线尝试！

JavaScript（ES7），22个字节

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

我们实际上不需要中间变量，因此实际上可以将其重写为：

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

测试用例

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个字节

感谢@OlivierGrégoire！

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

仅适用于float输入。

在线尝试！

C， 41   39  37字节

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

在线尝试！

C， 49   47   45  43字节

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

在线尝试！

感谢@JungHwan Min节省了两个字节！

Haskell，40个字节

还要感谢H.PWiz。

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

在线尝试！

AWK，47 44 38字节

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

在线尝试！

注意：TIO像有2个额外的字节 \n以使输出更漂亮。:)

感觉有点像使用sqrt来查找平方根，所以这里有一个更多字节的版本。

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

在线尝试！

球拍，92字节

感谢@JungHwan Min在评论部分的提示

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

在线尝试！

不打高尔夫球

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

PowerShell，54个字节

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

在线尝试！或验证一些测试用例

接受输入$x，然后完全按照要求进行操作。该|?部分找到最大整数，该整数在平方时-l等于e输入等于或小于等于$x，然后我们执行所需的计算。输出是隐式的。

外壳，9个字节

½Ṡ§+K/(⌊√

在线尝试！

这个答案仍然有些丑陋，但我似乎找不到更短的解决方案。

说明

我正在实现牛顿算法的一个步骤（实际上等效于此问题中提出的步骤）

½Ṡ§+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字节

←Đ√⌊Đ↔⇹/+₂

说明

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

银河系，17 14字节

使用OlivierGrégoire的公式-3个字节

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

在线尝试！

说明

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个字节

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

在线尝试！

OlivierGrégoire的Java答案的 AC＃版本。