问题：

在您选择的语言中，编写最短的函数以返回无符号64位整数的平方根的下限。

测试用例：

您的函数必须在所有输入中均能正常工作，但是这里有一些有助于说明这一点：

               INPUT ⟶ OUTPUT

                   0 ⟶  0
                   1 ⟶  1
                   2 ⟶  1
                   3 ⟶  1
                   4 ⟶  2
                   8 ⟶  2
                   9 ⟶  3
                  15 ⟶  3
                  16 ⟶  4
               65535 ⟶ 255
               65536 ⟶ 256
18446744073709551615 ⟶ 4294967295

规则：

1. 您可以随意命名函数。（未命名，匿名或lambda函数可以，只要可以调用即可。）
2. 字符计数是此挑战中最重要的，但是运行时也很重要。我敢肯定，您可以使用很少的字符数在O（√n）时间内迭代向上搜索答案，但是O（log（n））时间确实更好（也就是说，假设输入值为n，不是n的位长）。
3. 您可能会想使用纯整数和/或布尔算术来实现该功能。但是，如果您确实要使用浮点计算，那么只要您不调用任何库函数就可以了。因此，简单地说return (n>0)?(uint32_t)sqrtl(n):-1;C会超出范围，即使它会产生正确的结果。如果您使用浮点运算，您可以使用*，/，+，-，和幂（例如，**或者^如果它是一个内置在你选择的语言操作，但权力的唯一幂比1少）。此限制是为了防止通过调用sqrt()或变种或将值提高到1/2幂来“作弊” 。
4. 如果使用浮点运算（请参阅＃3），则不需要返回类型为整数；只是返回值是整数，例如floor（sqrt（n）），并且能够保存任何无符号的32位值。
5. 如果您使用的是C / C ++，则可以假定存在无符号的64位和32位整数类型，例如uint64_t和uint32_t所定义stdint.h。否则，只需确保您的整数类型能够容纳任何64位无符号整数。
6. 如果您的语言不支持64位整数（例如，Brainfuck显然仅支持8位整数），请尽力做到这一点，并在答案标题中注明限制。就是说，如果您能弄清楚如何对64位整数进行编码，并使用8位原始算术正确地获取它的平方根，那么将为您提供更多的功能！
7. 玩得开心，发挥创造力！

CJam，17（或10）个字节

{_1.5#\/i}

通过验证测试用例在线尝试：

[0 1 2 3 4 8 9 15 16 65535 65536 18446744073709551615]{_1.5#\/i}%N*

由于四舍五入问题，它不会通过最后一个测试用例，但是由于CJam中18446744073709551615不是Integer（这是Big Integer），所以我们还是不错的，对吗？

如果不是，则以下（且稍长一些）的代码将纠正这些错误：

{__1.5#\/i_2#@>-}

不再是最短的解决方案了，而是faaast。

怎么运行的

__    " Duplicate the integer twice. ";
1.5#  " Raise to power 1.5. Note that, since 1.5 > 1, this doesn't break the rules. ";
\     " Swap the result with the original integer. ";
/     " Divide. ";
i     " Cast to integer. ";
_2#   " Push square of a copy. ";
@     " Rotate the orginal integer on top of the stack. ";
>-    " If the square root has been rounded up, subtract 1. ";

哈斯克尔，28 26

我认为这是所有非高尔夫语言中最短的条目。

s a=[x-1|x<-[0..],x*x>a]!!0

它s使用参数命名一个函数，a并返回一个减去第一个大于2的平方的数字a。运行非常慢（可能是O（sqrt n）？）。

Golfscript，17个字符

{).,{.*1$<},,\;(}

我可以用自己喜欢的任何方式来命名函数，但是我决定完全不命名它。添加两个字符来命名，添加三个名称而不是将其保留在堆栈中，如果提供完整的程序是可以的，则减去一个字符。

这种可憎性不是以对数时间以输入值的形式运行，也不是以O（sqrt n）的时间运行，要花费大量的线性时间才能得出结果。它也占用那么多空间。绝对可怕。但是...这是代码高尔夫。

该算法是：

n => [0..n].filter(x => x*x < n+1).length - 1

Pyth，14个字符

DsbR;fgb*TTL'b

提供一个命名函数s，该函数通过从0到n过滤列表（大于输入的平方）来计算平方根，然后输出最后一个这样的数字。不使用幂运算或浮点运算。

Dsb       def s(b):
R;        return last element of
f         filter(lambda T:
gb*TT                     b>=T*T,
L'b                       range(b+1))

用法示例：

python3 pyth.py <<< "DsbR;fgb*TTL'b       \msd[0 1 2 3 4 8 9 15 16 65535 65536"
[0, 1, 1, 1, 2, 2, 3, 3, 4, 255, 256]

视网膜（非竞争-语言比挑战更新颖），43

在研究此答案时，我想到可以使用类似的方法使用视网膜计算整数平方根：

.+
$*
^
1:
+`(1+):(11\1)
1 $2:
1+:$|:1+

1+

这依赖于一个事实，即完美平方可以表示为1+3+5+7+...，并且推论该表达式中的项数是平方根。

在线尝试。（添加第一行以允许运行多个测试用例。）

显然由于十进制到一进制的转换，这仅适用于相对较小的输入。

Perl，133个字符

到目前为止，它不是最短的，但是使用数位算法来处理任何大小的输入，并且运行时间为O（log n）。在数字字符串和数字数字之间自由转换。由于最大的乘积是具有一位数平方的平方根，因此在64位系统上，它应该能够采用最大120位左右的数字的平方根。

sub{($_)=@_;$_="0$_"if(length)%2;$a=$r="";while(/(..)/g){
$a.=$1;$y=$d=0;$a<($z=$_*(20*$r+$_))or$y=$z,$d=$_ for 1..9;$r.=$d;$a-=$y}$r}

解压缩后，即：

sub {
  my ($n) = @_;
  $n = "0$n" if length($n) % 2; # Make an even number of digits
  my ($carry, $root);
  while ($n =~ /(..)/g) { # Take digits of $n two at a time
    $carry .= $1;         # Add them to the carry
    my ($product, $digit) = (0, 0);
    # Find the largest next digit that won't overflow, using the formula
    # (10x+y)^2 = 100x^2 + 20xy + y^2 or
    # (10x+y)^2 = 100x^2 + y(20x + y)
    for my $trial_digit (1..9) {
      my $trial_product = $trial_digit * (20 * $root + $trial_digit);
      if ($trial_product <= $carry) {
        ($product, $digit) = ($trial_product, $trial_digit);
      } 
    } 
    $root .= $digit;
    $carry -= $product;
  } 
  return $root;
}

Matlab（56）/八度（55）

它使用定点方法算出平方根。它以最大36步收敛（对于2 ^ 64-1作为参数），然后检查它是否是“可能的”整数根的下一个。由于它总是使用36次迭代，因此其运行时间为O（1）= P

假定参数为uint64。

Matlab：

function x=q(s)
x=1
for i = 1:36
    x = (x+s/x)/2
end
if x*x>s
    x=x-1
end

八度：

function x=q(s)
x=1
for i = 1:36
    x = (x+s/x)/2
end
if x*x>s
    x-=1
end

Ruby-36个字符

s=->n{g=n;g=(g+n/g)/2 while g*g>n;g}

巨蟒（39）

f=lambda n,k=0:k*k>n and k-1or f(n,k+1)

自然递归方法。计算潜在的平方根，直到其平方根过高，然后递减1。如果您担心超出堆栈深度，请使用Stackless Python。

该and/or习语等效于三元运算符，因为

f=lambda n,k=0:k-1 if k*k>n else f(n,k+1)

编辑：我可以改为获得25个字符通过利用规则“，你可以使用*，/，+，-，和幂（例如，**或者^如果它是权力的一个内置在你选择的语言操作，但只幂比1以下）。 ” （编辑：显然，丹尼斯已经发现并利用了这个技巧。）

lambda n:n**1.5//max(n,1)

我使用//Python 3 的整数除法运算符四舍五入。不幸的是，我花了很多字符，以免n=0错误不除以0。如果不是，我可以做18个字符

lambda n:n**1.5//n 

规则也没有说必须对函数进行命名（取决于您如何解释“您可以按自己的喜好命名函数”。），但是如果这样，那就是另外两个字符。

C99（58个字符）

这是一个我不认为是一个好答案的示例，尽管从代码高尔夫的角度来看，这对我很有趣，因为它是如此反常，我只是认为将其混入其中会很有趣：

原文：64个字符

uint64_t r(uint64_t n){uint64_t r=1;for(;n/r/r;r++);return r-1;}

该代码之所以糟糕，是因为它以O（√n）时间而不是O（log（n））时间运行。（其中n是输入值。）

编辑：63个字符

更改r-1为--r并将其邻接为return：

uint64_t r(uint64_t n){uint64_t r=1;for(;n/r/r;r++);return--r;}

编辑：62个字符

将循环增量移到循环的条件部分内部（注意：这具有无法保证的行为，因为相对于preincrement运算符的操作顺序是特定于编译器的）：

uint64_t r(uint64_t n){uint64_t r=0;for(;n/++r/r;);return--r;}

编辑：60个字符

添加一个typedef隐藏uint64_t（此建议归功于用户技术专家）。

typedef uint64_t Z;Z r(Z n){Z r=0;for(;n/++r/r;);return--r;}

编辑：58个字符

现在需要在调用函数时将第二个参数作为0传递，例如，r(n,0)而不是just r(n)。好吧，对于我的一生，现在我看不到如何进一步压缩它了……有人吗？

typedef uint64_t Z;Z r(Z n,Z r){for(;n/++r/r;);return--r;}

Golfscript-14个字元

{.,\{\.*<}+?(}

寻找最小数i小于输入n为此n < i*i。返回i - 1。

即 [0..n-1].first(i => n < i*i) - 1

对于那些也不了解Golfscript的人的解释，对于带有输入的示例调用5：

.        //Duplicate input.  Stack: 5 5
,        //Get array less than top of stack.  Stack: 5 [0 1 2 3 4]
\        //Switch top two elements of stack.  Stack: [0 1 2 3 4] 5
{\.*<}+  //Create a block (to be explained), and prepend the top of the stack.  
         //Stack: [0 1 2 3 4]{5\.*<}
?        //Find the first element of the array for which the block is true. 
         //So, find the first element of [0 1 2 3 4] for which {5\.*<} evaluates to true.
         //The inner block squares a number and returns true if it is greater than the input.
(        //Decrement by 1 

Haskell中，147个 138 134 128字节

这不是世界上最短的代码，但是它确实可以在O（log n）以及任意大小的数字上运行：

h x=div(x+1)2
n%(g,s)|g*g<n=(g+s,h s)|g*g>n=(g-s,h s)|0<1=(g,0)
f(x:r@(y:z:w))|x==z=min x y|0<1=f r
s n=fst$f$iterate(n%)(n,h n)

这将对范围[0..n]进行二进制搜索，以找到与sqrt（n）最佳的近似值。这是一个非高尔夫版本：

-- Perform integer division by 2, rounding up
half x = x `div` 2 + x `rem` 2

-- Given a guess and step size, refine the guess by adding 
-- or subtracting the step as needed.  Return the new guess
-- and step size; if we found the square root exactly, set
-- the new step size to 0.
refineGuess n (guess, step)
    | square < n  =  (guess + step, half step)
    | square > n  =  (guess - step, half step)
    | otherwise   =  (guess, 0)
    where square = guess * guess     

-- Begin with the guess sqrt(n) = n and step size (half n),
-- then generate the infinite sequence of refined guesses.
-- 
-- NOTE: The sequence of guesses will do one of two things:
--         - If n has an integral square root m, the guess 
--           sequence will eventually be m,m,m,...
--         - If n does not have an exact integral square root,
--           the guess sequence will eventually alternate
--           L,U,L,U,.. between the integral lower and upper
--           bounds of the true square root.
--        In either case, the sequence will reach periodic
--        behavior in O(log n) iterations.
guesses n = map fst $ iterate (refineGuess n) (n, half n)

-- Find the limiting behavior of the guess sequence and pick out
-- the lower bound (either L or m in the comments above)
isqrt n = min2Cycle (guesses n)
    where min2Cycle (x0:rest@(x1:x2:xs))
            | x0 == x2    =   min x0 x1
            | otherwise   =   min2Cycle rest

编辑：通过将“ otherwise”子句替换为“ True”的较短版本，将“ otherwise”子句替换为“ 0 <1”，从而节省了两个字节，并通过内联g * g节省了更多的字节。

另外，如果您对O（sqrt（n））感到满意，则只需

s n=(head$filter((>n).(^2))[0..])-1

35个字符，但这有什么乐趣？

编辑2：我只是意识到，由于对是按字典顺序排序的，而不是执行min2Cycle。映射fst，我可以做fst。min2Cycle。在高尔夫球代码中，这意味着将f $ map fst替换为fst $ f，从而节省了4个字节。

编辑3：多亏了hadhaskeller，又节省了六个字节！

JavaScript 91 88 86：针对速度进行了优化

function s(n){var a=1,b=n;while(Math.abs(a-b)>1){b=n/a;a=(a+b)/2}return Math.floor(a)}

JavaScript 46：未针对速度进行优化

function s(n){a=1;while(a*a<=n)a++;return a-1}

这是一个JSFiddle：http : //jsfiddle.net/rmadhuram/1Lnjuo4k/

C 95 97

编辑 Typedef，由@Michaelangelo建议

这或多或少是Heron算法的直接实现。唯一的怪癖是计算避免整数溢出的平均值：a =（m + n）/ 2对biiiig数不起作用。

typedef uint64_t Z;
Z q(Z x)
{
   Z n=1,a=x,m=0;
   for(;a-m&&a-n;) n=a,m=x/n,a=m/2+n/2+(m&n&1);
   return a;
}

C＃64 62 55

由于这是一个代码问题（并且我对数学很糟糕），并且运行时只是一个建议，因此我完成了在线性时间内运行的简单方法：

decimal f(ulong a){var i=0m;while(++i*i<=a);return--i;}

（在dotnetfiddle上测试）

当然，对于较大的输入，它的速度非常慢。

Clojure-51或55个字节

检查从n到0的所有数字，并为第一个数字提供x^2 <= n。运行时为O(n - sqrt n)

未命名：

(fn[x](first(filter #(<=(* % %)x)(range x -1 -1))))

命名：

(defn f[x](first(filter #(<=(* % %)x)(range x -1 -1))))

例：

(map (fn[x](first(filter #(<=(* % %)x)(range x -1 -1)))) (range 50))
=> (0 1 1 1 2 2 2 2 2 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 7)

Befunge 93-48字节或38个字符

101p&02p>02g01g:*`#v_01g1-.@
        ^  p10+1g10<        

在这里尝试。

眼镜蛇-62

do(n as uint64)as uint64
    o=n-n
    while o*o<n,o+=1
    return o

批次-74

set a=0
:1
set /ab=%a%*%a%
if %b% LSS %1 set /aa=%a%+1&goto 1
echo %a%

Haskell，53 50 49个字符，O（log n）

s n=until((<=n).(^2))(\g->g-1-div(g^2-n-1)(2*g))n

此解决方案实现了newton-raphson方法，尽管它搜索整数而不是浮点数。Wiki：http : //en.wikipedia.org/wiki/Newton%27s_method

复杂度似乎与O（log n）有关，但是有证明吗？请在评论中回答。

J（10）

@Dennis的答案非常非常启发：

<.@%~^&1.5

稍长一些，但性能更好（我怀疑）：

<.@(-:&.^.)

floor(halve under log)

要执行，需要输入缩进部分：

   f=:<.@%~^&1.5
   f 0 8 12 16
0 2 3 4
   g=:<.@(-:&.^.)
   g 0 8 12 16
0 2 3 4

APL-12个字符，19个字节

{⌊(⍵*1.5)÷⍵}

示例使用：

{⌊(⍵*1.5)÷⍵}17

返回4

测试向量

{⌊(⍵*1.5)÷⍵}¨0 1 2 3 4 8 9 15 16 65535 65536 18446744073709551615

退货

1 1 1 1 2 2 3 3 4 255 256 4294967296

在线尝试

非常感谢：用户“ ssdecontrol”的算法

C99（108个字符）

这是我自己在C99中的解决方案，该解决方案是根据Wikipedia上一篇文章中的算法改编而成的。我相信在其他语言中肯定有可能做得比这更好。

打高尔夫球：

uint64_t s(uint64_t n){uint64_t b=1,r=0;while(n/b/4)b*=4;for(;b;b/=4,r/=2)n>=r+b?r+=b,n-=r,r+=b:0;return r;}

部分打高尔夫球：

uint64 uint64_sqrt(uint64 n)
{
  uint64 b = 1, r = 0;
  while (b <= n / 4)
    b *= 4;
  for (; b; b /= 4, r /= 2)
    if (n >= r + b)
      { r += b; n -= r; r+= b; }
  return r;
}

取消高尔夫：

uint64_t uint64_sqrt(uint64_t const n)
{
  uint64_t a, b, r;

  for (b = 1; ((b << 2) != 0) && ((b << 2) <= n); b <<= 2)
    ;

  a = n;
  r = 0;
  for (; b != 0; b >>= 2)
  {
    if (a >= r + b)
    {
      a -= r + b;
      r = (r >> 1) + b;
    }
    else
    {
      r >>= 1;
    }
  }

  // Validate that r² <= n < (r+1)², being careful to avoid integer overflow,
  // which would occur in the case where n==2⁶⁴-1, r==2³²-1, and could also
  // occur in the event that r is incorrect.
  assert(n>0? r<=n/r : r==0);  // Safe way of saying r*r <= n
  assert(n/(r+1) < (r+1));     // Safe way of saying n < (r+1)*(r+1)

  return r;
}

JavaScript 73 81（符合64位数字要求）

n=prompt();g=n/3;do{G=g,g=(n/g+g)/2}while(1E-9<Math.abs(G-g))alert(Math.floor(g))

实现苍鹭的亚历山大算法...

Powershell（52）限于Int32（-2,147,483,648至2,147,483,647）

function f($n){($n/2)..0|%{if($_*$_-le$n){$_;exit}}}

我现在对Powershell尖叫，试图使最后一个测试用例正常工作，但是无论我做什么，Powershell都会使用管道变量$ _作为Int32结束工作，而我现在找不到解决方法。

因此，我现在只限制我的答案。如果我能找到更好的方法来处理uint64s，我将进行编辑。（顺便说一下，最后一个测试用例对于Powershell的普通Int64类型来说太大了！）

这是一些测试用例（我用来跟踪时间的一些额外输出）

f 17
4
Elapsed Time: 0.0060006 seconds

f 65
8
Elapsed Time: 0.0050005 seconds

f 65540
256
Elapsed Time: 1.7931793 seconds

f 256554
506
Elapsed Time: 14.7395391 seconds

我不知道我的O（），但这似乎是一个非常戏剧性的跳跃。

注意：自2011年以来，R并没有像我想象的那样内置支持64位整数。这些答案在技术上可能是无效的，但是在过去三年中R再次发生了很大变化。

R，85

使用牛顿法：

function(n){s=F
x=n
y=(1/2)*(x+n/x)
while(abs(x-y)>=1){x=y
y=(1/2)*(x+n/x)}
trunc(y)}

二次收敛。+2个字符可将函数分配给变量进行基准测试：

microbenchmark(q(113424534523616))
# Unit: microseconds
#                expr    min      lq median      uq    max neval
#  q(113424534523616) 24.489 25.9935 28.162 29.5755 46.192   100

R，37

蛮力：

function(n){t=0
while(t^2<n) t=t+1
t}

和相同的检查：

microbenchmark::microbenchmark(q(113424534523616),times=1)
# Unit: seconds
#                 expr      min       lq   median       uq      max neval
#   q(113424534523616) 4.578494 4.578494 4.578494 4.578494 4.578494     1

R，30

该廉价/辉煌幂绝招：

function(n) trunc(n^(1.5)/n)

这也碰巧非常快（尽管不如内置的那么快）：

microbenchmark(q(113424534523616),sqrt(113424534523616))
# Unit: nanoseconds
#                   expr min    lq median    uq  max neval
#     z(113424534523616) 468 622.5  676.5 714.5 4067   100
#  sqrt(113424534523616)  93 101.0  119.0 160.5 2863   100

C，38

f(n){int m;while(++m*m<=n);return--m;}

我提交的Forth译文。慢但正确。O（√n）在OS X（64位）上测试。

dc，50个字节

dc -e"?dsist[lt2/dstd*li<B]dsBx[lt1+dstd*li!<A]dsAxlt1-f"

隔开并解释：

               # The idea here is to start with the input and reduce it quickly until it is
               # less than what we want, then increment it until it's just right
?              # Take input from stdin
d si st        # Duplicate input, store in `i' and in `t'
[              # Begin macro definition (when I write in dc, "macro"=="function")
 lt            # Load t, our test term
 2/            # Divide t by two
 d st          # Store a copy of this new term in `t'
 d*            # Duplicate and multiply (square)
 li<B          # Load i; if i<(t^2), execute B
] d sB x       # Duplicate, store function as `B', and execute
               # Loop ends when t^2 is less than i
[              # Begin macro definition
 lt            # Load t, our test term
 1+            # Increment
 d st          # Store a copy of this new term in `t'
 d*            # Duplicate and multiply (square)
 li!<A         # Load i; if i>=(t^2), execute A
] d sA x       # Duplicate, store function as `A', and execute
               # Loop ends when t^2 == i+1
lt 1- f        # Load t, decrement, and dump stack

C，139个 137 136字节

我第一次尝试打高尔夫球。看起来它是C语言中满足“有效”要求的最短的程序，因为它运行O(log n)时仅使用加法和位移位。虽然我敢肯定它会更短...

只要将a=32零件更改为，它对于较大的整数值也应该可以正常工作a=NUMBITS/2。

typedef uint64_t x;x f(x o){x a=32,t=0,r=0,y=0,z;for(;a--+1;){z=(x)3<<2*a;y*=2;t++<r?y++,r-=t++:t--;t*=2;r*=4;r+=(o&z)>>2*a;}return y;}

C-50（不含全局值的61）

typedef uint64_t T;T n,i;f(){while(++i*i<=n);--i;}

它使用全局变量作为参数并返回值以节省空间。

没有全局版本：

typedef uint64_t T;T f(T n){T i=0;while(++i*i<=n);return--i;}

C ++ 125

int main()
{
uint64_t y;cin>>y;
double x=y/2,d,z;
while((d=(x*x-y))>0.5)
{
d<0?x+=0.5:x-=0.5;
}
cout<<(uint64_t)x;
}