문제:

선택한 언어에서 부호없는 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. 원하는대로 함수 이름을 지정할 수 있습니다. 이름이 없거나 익명이거나 람다 함수는 어떤 식 으로든 호출 할 수있는 한 괜찮습니다.
2. 문자 수는이 문제에서 가장 중요한 요소이지만 런타임도 중요합니다. 매우 작은 문자 수로 O (√n) 시간에 대한 답변을 반복적으로 위쪽으로 스캔 할 수 있다고 확신하지만 O (log (n)) 시간은 실제로 더 좋을 것입니다 (즉, 입력 값 n을 가정하면, n의 비트 길이가 아님).
3. 순수한 정수 및 / 또는 부울 artithmetic을 사용하여 함수를 구현하고 싶을 것입니다. 그러나 실제로 부동 소수점 계산을 사용하려면 라이브러리 함수를 호출하지 않는 한 괜찮습니다. 따라서 return (n>0)?(uint32_t)sqrtl(n):-1;C에서 말하는 것은 올바른 결과를 얻을지라도 한계를 벗어납니다. 당신 부동 소수점 연산을 사용하고, 당신이 사용할 수있는 경우 *, /, +, -, 및 지수 (예, **또는 ^그것은 선택의 여지가 귀하의 언어로 운영자 내장,하지만 만약 힘의 지수는 이하 1 이상 ). 이 제한은 전화 sqrt()또는 변형 을 호출 하거나 값을 ½ 제곱으로 "속임수"를 방지 하는 것입니다.
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의 정수 ( 큰 정수 ) 가 아니기 때문에 여전히 훌륭합니다.

그렇지 않은 경우 다음 (그리고 약간 더 긴) 코드가 이러한 오류를 수정합니다.

{__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제곱이보다 큰 첫 번째 숫자에서 1을 뺀 값을 반환합니다 a. 엄청나게 느리게 실행됩니다 (O (sqrt n), 아마도?).

골프 스크립트, 17 자

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

원하는 방식으로 함수 이름을 지정할 수 있지만 이름을 전혀 지정하지 않기로 결정했습니다. 이름을 지정하려면 두 문자를 추가하고 이름을 지정하려면 세 문자를 추가하고 스택에 두지 말고 전체 프로그램을 제공해도 문제가 없으면 한 문자를 빼십시오.

이 가증은 O (sqrt n) 시간이 아닌 입력 값에서 로그 시간이 아니라 결과를 생성하는 데 엄청난 선형 시간이 걸립니다. 또한 많은 공간이 필요합니다. 물론 끔찍합니다. 그러나 ... 이것은 코드 골프입니다.

알고리즘은 다음과 같습니다.

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

Pyth , 14 자

DsbR;fgb*TTL'b

입력 값보다 큰 제곱에 대해 0에서 n까지의 목록을 필터링하여 제곱근을 계산 한 다음 마지막 숫자를 인쇄하는 명명 된 함수 s를 제공합니다. 지수 나 부동 소수점을 사용하지 않습니다.

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+...,이 표현에서 항의 수는 제곱근이라는 결론에 의해 결정됩니다.

온라인으로 사용해보십시오. (여러 테스트 케이스를 실행할 수 있도록 첫 번째 행이 추가되었습니다.)

분명히 십진수에서 단항으로의 변환으로 인해 이것은 비교적 작은 입력에 대해서만 작동합니다.

펄, 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

루비 — 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 이상 인 경우). " (편집 : Dennis는 이미이 트릭을 찾아서 악용했습니다.)

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

//파이썬 3 의 정수 나누기 연산자 를 사용하여 반올림합니다. 불행히도 n=00으로 나누기 오류가 발생하지 않도록 많은 문자를 사용합니다 . 그렇지 않다면, 나는 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 (log (n)) 시간이 아니라 O (√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 자

루프 증분을 루프의 조건부 내부로 이동 (주의 : 사전 증분 연산자와 관련된 작업 순서는 컴파일러마다 다르기 때문에 이는 보증되지 않은 동작입니다) :

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

편집 : 60 자

typedef숨기기 추가 uint64_t( 이 제안 을 위해 사용자 technosaurus에 대한 신용 )

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

편집 : 58 자

이제 함수를 호출 할 때 예를 들어 r(n,0)just 대신 두 번째 매개 변수가 0으로 전달되어야 r(n)합니다. 좋아, 내 인생 에서이 시점에서 나는 이것을 더 이상 압축하는 법을 볼 수 없다.

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

골프 스크립트-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 

하스켈 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)

sqrt (n)에 가장 적합한 근사값을 찾기 위해 [0..n] 범위의 이진 검색을 수행합니다. ungolfed 버전은 다음과 같습니다.

-- 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"의 짧은 버전으로 "0 <1"으로 바꾸고 g * g를 인라인하여 몇 바이트를 절약하여 2 바이트를 절약했습니다.

또한 O (sqrt (n))에 만족하면 간단히 할 수 있습니다.

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

35자를 위해, 그러나 그것은 얼마나 재미 있습니까?

편집 2 : min2Cycle 대신 쌍이 사전 순서로 정렬되어 있기 때문에 방금 인식했습니다. fst 맵, 나는 fst 할 수 있습니다. min2Cycle. 골프 코드에서 f $ map fst를 fst $ f로 바꾸면 4 바이트가 더 절약됩니다.

편집 3 : proudhaskeller 덕분에 6 바이트를 더 절약했습니다!

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

@Michaelangelo가 제안한 Typedef 편집

이것은 Heron 알고리즘의 간단한 구현이어야합니다. 유일한 단점은 정수 오버플로를 피하는 평균을 계산하는 것입니다.

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에서 테스트 )

물론 더 큰 입력의 경우에는 너무 느립니다.

클로저-51 또는 55 바이트

n에서 0까지의 모든 숫자를 확인하고 첫 번째 숫자는 where 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%

하스켈, 53 50 49 자, O (log n)

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

이 솔루션은 부동 소수점 대신 정수를 검색하지만 newton-raphson 메서드를 구현합니다. 위키 : 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

보고

1111 34 34255256 4294967296

온라인 시도

큰 감사 : 알고리즘에 대한 사용자 "ssdecontrol"

C99 (108 자)

다음은 Wikipedia 기사 의 알고리즘에서 채택한 C99의 자체 솔루션입니다 . 나는 다른 언어로 이것보다 훨씬 더 잘 할 수있을 것이라고 확신한다.

골프 :

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로 사용하여 바람을 피우며 지금은 그 길을 찾을 수 없습니다.

따라서 지금은 답변을 제한하겠습니다. uint64를 처리하는 더 좋은 방법을 찾을 수 있다면 편집하겠습니다. (마지막 테스트 케이스는 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은 지난 3 년 동안 많은 변화를 거쳤습니다.

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;}

나의 포스 제출의 번역. 느리지 만 정확합니다. 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 바이트

코드 골프에 대한 첫 번째 시도. O(log n)추가 및 비트 시프트 만 사용하여 시간이 지남 에 따라 "효율적인"요구 사항에 맞는 C에서 가장 짧은 것 같습니다 . 나는 그것이 더 짧을 수 있다고 확신하지만 ...

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;
}