text:
Reimplementing square root
Define a function, s, which takes a number and returns the square root.
No use of library functions, such as Java's Math.sqrt() or PHP's built in sqrt(), allowed.

I think all solutions will be based on Newton approximation such as http://www.codemaestro.com/reviews/9

That doesn't prevent it being golfed, nor does it dictate how to handle any unusual cases, such as negative numbers.

How do you feel about exp(0.5*log(x))?

The problem with this puzzle is that it lacks specifications for input range and tolerated error, it's kinda boring if "keep on adding a small number until result is reached" method is allowed, it's the shortest in any language.

btw. It's reimplementing

@dmckee - It does not break the spirit of the rules, but it doesn't give you a square root.

@jtjacques: Er...yes it does. Try a couple of cases. Make sure that you use the same base for exponentiation and logarithm.

@eBusiness I thought "as accurate as possible" would be implied and I think we've established that x^0.5 is probably going to be the best solution.

@dcmckee, showing my ignorance I did, using Google. What should I be doing to get 2? http://www.google.com/search?q=exp(0.5*log(4))

That really kills the task, if this is to be fun you got to set the restrictions tight enough.

@jtjacques: Base agreement is key, many languages use log for the base 10 logarithm, so you might try exp(0.5*ln(x)) to get the natural log or pow10(0.5*log(x)) or similar.

@dcmckee Thanks. I apologise for discrediting/besmirching your solution.

@jtjacques: Actually I haven't made a answer of it because I don't like it. The reason you wouldn't have a sqrt available it that you don't have support for transcendental functions, which makes using exp and log a little silly to my mind.

@dmckee Are you sure?

@Alexandru That was exactly the algorithm that came to mind when I first saw the brief... Great minds think alike, so I gave you +1

How is this a duplicate? Can you check the date it was asked before closing? (nominated for re-opening)

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ An old question can be closed as a duplicate of a new one.

Voting to reopen because the duplicate was closed as unclear.

@pppery The unclarity of that question is present in this one as well.  If this were to be reopened it should be closed again as unclear for the exact reason that its dupe target was unclear.

there is no square root general question open in here... if you have problem of clearity dont partecipate

Python - 11 chars
Technically not a library function :)
input()**.5

As a function it's 16 chars
f=lambda x:x**.5

Smart, I like it.

It's questionable whether this falls under a built-in function (it calls __pow__). But then even * is a built-in.

Would have preferred it as a function, but I'll give you the accept for the ingenuity.

@jtjacques What ingenuity? IMHO, this is the one the most obvious ways around the rules.

I think the function has to be called 's', not 'f'.

Python (13 chars)
f=.5.__rpow__
This is equivalent to f=lambda x:x**.5, but 3 bytes shorter.

Python - 41 chars
Takes a while to run for large numbers :)
n=input()
i=0
while i*i<n:i+=1e-9
print i

For me, it takes a while even for 2.

Java (163)
Implementing a double precision square root calculator by making use of the fast invert square root stuff from quake and a new constant for the 64bit floats. In java. Yay for verbosity.
public double i(double a){double b=a/2;long c=0x5fe6ec85e7de30daL-(Double.doubleToRawLongBits(a)>>1);a=Double.longBitsToDouble(c);return a*(1.5-b*a*a);};s=1/i(x);

J, 6, 5
Using power:
^&0.5

Or, perhaps more mnemonically:
^&1r2

Using the slightly less "cheaty" method, exp(log(x)/2).
-:&.^.

Except since exp is the inverse of log, we simply "halve (-:) under (&.) log (^.)"
Not that normally a J programmer would not name a method this short; he'd simply embed in in a larger program.

Haskell, 9 characters
s=(**0.5)

Similar to @gnibbler's Python solution.

Naive solution, accepts only positive integer inputs.
s n=foldr (\x a->x*x==n||a) False [1..]

Haskell, 39 characters.

remove spaces? s n=foldr(\x a->x*x==n||a)False[1..]

LISP (66)
Using Babylonian method.
(defun s(A)
   (do((x 1(*(+ x(/ A x)).5))(n 100(1- n)))((zerop n)x)))

Python - 65
A simple solution using Newton's method.
def s(x):
 t=1.0
 while 1e-9<abs(x-t*t):t-=(t*t-x)/2/t
 return t

C with some bad form and deprecated features:
s(int n,int g){return g*g-n?s(n,random()%n):g;}

If your compiler is enough of a liberal hippie, it should be possible to call s(n) and (eventually) receive the desired value.

You can save 8 characters, and allow calling s(n) (at least in GCC), by changing s(int n,int g) to s(n,g).

Save 2 more chars by changing random() to rand().

def sqrt_newton(x):
 f,g,w,d=lambda a:a*a-x,lambda a:2.0*a,x/2.0,1e-4
 while abs(f(w))>d:w-=(f(w)/2.0/w)
 return w

reduced version of https://gist.github.com/713104

And the size is ...

return 1.f/InvSqrt(x);

InvSqrt of course courtesy of Quake.
What, you mean you wanted an accurate result?

Well to the limit of the return type, and also one which does not use a library.

C++ (61)
Uses Heron's Method:
f64 s(f64*x,u64 n=9){*x=(x[1]/*x+*x)/2;return n?s(x,--n):*x;}

Recursion, pointers, optional arguments, and ternary operators FTW!

Usage:
f64 x[2] = {12.0, 12.0};
std::cout << s(x);

C++ (35)
f64 s(f64 x){return exp(log(x)/2);}

I promise I didn't use sqrt()!

ActionScript3 (53)
Using Newton's method. (Hooray 4 IEEE 754)
function s(b,d=2){return b==d*d?d:s(b,d-(d*d-b)/2/d)}

I know I'm TOO late but I just wanted to write something I did :(

JavaScript, 121
No, it doesn't even come close, but it is more optimal than other solutions and doesn't use Math.pow with fractions.
s=n=>{for(var c=Math.pow(10,(''+Math.floor(n)).length),v=0,l;(l=v*v<n),c>1e-10;l!=v*v<n?c/=10:0)v*v<n?v+=c:v-=c;return v}

You're missing the function name there. Should be something like function s(n).

@nyuszika7h: It’s a function literal.

But you would need to assign that to a variable (which is the same "penalty" as using my previous suggestion). I don't see Python solutions like lambda x: ... either, I see solutions like f=lambda x: ....

@nyuszika7h: Their loss. This code is a function.

I'll let the meta "gods" decide, since I've never seen anyone else doing this, as far as my memory goes back. http://meta.codegolf.stackexchange.com/q/1501/344

@nyuszika7h: There, it’s a variable now

Heh, did you convert it to ES6 Harmony code? ;)

@nyuszika7h: =) Now if only Chrome would follow suit.

Also, sorry if it came off as being rude, I didn't mean to be.

GolfScript - 21
It uses the Babylonian method and works only with integers. According to my tests, it's good for up to 56 digits.
{1{.2$\/+2/}99*\;}:s;

Usage: 1000 s -> 31
I think this is the shortest solution so far that doesn't call some kind of power function or external library.

k (17 chars)
Iterative (implementation of Babylonian method):
{{.5*y+x%y}[x]/x}

Iterates until two successive values are equal
Example:
sqrt[1234] = {{0.5*y+x%y}[x]/x}1234
1b

Also the mandatory xexp[;0.5] for 10.

Python, 44
def s(x):t=1.;exec"t=(t+x/t)/2;"*99;return t

Tested with:
for x in [0, (3+5**0.5)/2, 1000, 10**5, 10**11]:
    print x, '->', s(x)

Output:
0 -> 1.57772181044e-30
2.61803398875 -> 1.61803398875
1000 -> 31.6227766017
100000 -> 316.227766017
100000000000 -> 316227.766017

Python, 50 49
In case you like recursion:
s=lambda x,t=1.,r=99:r and s(x,t/2+x/t/2,r-1)or t

Same testing code, same output.

Mathematica 27
f@x_:=Nest[(#+x/#)/2&,1.,9]

Golf-Basic 84, 9 characters
i`Ad`A^.5

As a function, 15 characters:
i`A:Return A^.5

JavaScript, 36 (or 14 without the function)
function s(n){return Math.pow(n,.5)}

AWK, 8
1,$0^=.5

Following solution can handle all values except 0
AWK, 6
$0^=.5

Befunge 98 - 18
&00pv
0*::<+1vj!`g0

This program takes an input number from the user, and ends by pushing the integer square root on the stack (note that you said square root, but didn't specify whether floating point was necessary). Here is a function (well, closest thing to one) (requiring free access to cell 00) (15 chars):
00p::*00g`!jv1+

In these I expect the byte to be squared is in the current cell. It needs 8 cells to the right empty and it will have answers in the 4 cells starting from where the number was. These are:

integer result
a alternative result (would be the same or one higher if those multiplied is closer to the argument)
remainder
flag for negative remainder

Extended BrainFuck: 310
>+4>15+4<[>>+<+<[->[->->>+<<]>[-<+>>]<+<<]>[-]>[-]3<[->+>>+3<]>[-<+>]4>[-<+3<+4>]<<[->-[>+>>]>[+[-<+>]>+>>]5<]3>[-3<+3>]<[->>+>+3<]<[->+4>+5<]>+[>>[-<]<[>]<-]3>+<[[-]>[-]>[-4<+4>]5<+<+4>]>[->[-]<[-3<+3>]]3<[->+<]<<[->>+4<->>]<+<[-[+3>[-]>>[-]4<-]>[-5>+4<]<]>[->]<<]<[-]5>[-4<+<+5>]>>[-6<+6>]<[-3<+3>]<<[-<<+>>]

It turns into the following:
BrainFuck: 390 (the same as above run through the compiler)
>+>>>>+++++++++++++++<<<<[>>+<+<[->[->->>+<<]>[-<+>>]<+<<]>[-]>[-]<<<[->+>>+<<<]>[-<+>]>>>>[-<+<<<+>>>>]<<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>>>[-<<<+>>>]<[->>+>+<<<]<[->+>>>>+<<<<<]>+[>>[-<]<[>]<-]>>>+<[[-]>[-]>[-<<<<+>>>>]<<<<<+<+>>>>]>[->[-]<[-<<<+>>>]]<<<[->+<]<<[->>+<<<<->>]<+<[-[+>>>[-]>>[-]<<<<-]>[->>>>>+<<<<]<]>[->]<<]<[-]>>>>>[-<<<<+<+>>>>>]>>[-<<<<<<+>>>>>>]<[-<<<+>>>]<<[-<<+>>]

It's Newtons method starting at guess 16 and goes downwards. It stops when the last iteration didn't make a different integer result. This is actualy from the sqrt macro of EBF since I use it to implement print-string operator |. Here's the part from EBF source ungolfed:
; sqrt ^0  uses  9 cells that need to be empty
; will be fuzzy after calling because of divmod
; returns ^0 result
;         ^1 same as ^0 or it increased by 1. typically will ^2*^3 be closerto the requested argument than ^2*^2
;         ^2 remainder
;         ^3 indicates if remainder is negative
{sqrt
  check for wrong usage !diff:diff
  :in:guess:temp:cur:div:mod:res:indicator
  @in
  $guess+     ;initial guess is 16, but
  $mod 15+    ; its in mod and incremented (rounded up)
  $guess(     ; worst case is 1 with 5 iterations
      $cur+$temp+
      $guess(-$temp[->-$mod+$cur]>[@cur-$temp+$div]$cur+)
      $temp(-)$cur(-)
      $in(-$guess+$cur+)
      $guess(-$in+)
      $mod(-$div+$guess+)
      $cur &roundivmod ; remainder wil now be in mod
      $mod(-$res+)
      $cur(-$mod+$guess-)
      $temp+
      $guess[-[+$div(-)$res(-)$temp-]>[-@temp$indicator+$cur]$temp]>[-@temp>]
  )
  $in(-)
  $mod(-$guess+$in+)
  $indicator(-$guess+)
  $res(-$cur+)
  $div(-$temp+)
  $in
  !indicator!res!mod!div!cur!temp!guess!in
}

;; helper macros
; roundivmod uses divmod and puts the rounded result in ^0 and indication of rounded in ^1
; and a remainder (which ^1 is an indication is either reduction or inrement) in ^2
{roundivmod
    &divmod @cur
    ; *0|n-rem|rem|res|
    >>>(-<<<+)
    <(->>+>+) make double copy of remainder
    ; res|n-rem|0|0|rem|rem
    <(->+>>>>+)
    ; res|0|n-rem|0|rem|rem|n-rem
    >+[>>[-<]<[>]<-]
    >>>+<(
       [-]>[-]
       >(-<<<<+)
       <<<<<+<+
      )
     >(-
        >[-]
        <(-<<<+)
      )
  end divide
}

; this does the divmod. compiler is fuzzy after so caller must fix position to calling
{divmod[->-[>+>>]>[+[-<+>]>+>>]<<<<<]}

Julia (9) characters
f(x) = x^.5

Java: 74 characters
I'm leaving the square root as an exact answer because I don't enjoy approximations :)
enum A{;public static void main(String[]a){System.out.println('√'+a[0]);}}

or
enum A {

    ;public static void main(String[] a) {
        System.out.println('√' + a[0]);
    }
}

Direct abuse of the Standard Loopholes.

F# (12)
It seems like cheating since other languages has similar solutions. But it works.
let s n=n**0.5

Scala 78 chars:
type D=Double
def q(x:D,g:D=9):D=if(math.abs(g*g-x)<.001)g else q(x,(g+x/g)/2)

invocation:
scala> q(12345)
res36: D = 111.10805572305925

Postscript 94 89
Babylonian method. Iterates until successive values are equal.
s{dup 2 div{2 copy div 1 index add .5 mul
2 copy eq{exit}if exch pop}loop pop exch pop}def

Commented:
/s{
    dup 2 div  % S x
    {  % S x
        2 copy div  % S x S/x
        1 index add .5 mul  % S x (S/x+x)/2
        2 copy eq { exit } if  % S x (S/x+x)/2
        exch pop  % S (S/x+x)/2:->x
    }loop
    pop exch pop
}def

bash 228 ( a lot but pure bash only! ;)
For the count:
x=(600000 200000);z=${x[$(($1&1))]} y=1;while [ $y -ne $z ] ;do y=$z;printf -v z "%u" $(((${y}000+${1}00000000000/${y})/2));printf -v z "%.0f" ${z:0:${#z}-3}.${z:${#z}-3};done;z=0000$z;printf "%.3f\n" ${z:0:${#z}-4}.${z:${#z}-4}

As a function:
sqrt() {
    local -a xx=(600000 200000)
    local x1=${xx[$(($1&1))]} x0=1
    while [ $x0 -ne $x1 ] ;do
    x0=$x1
    printf -v x1 "%u" $(( (${x0}000 + ${1}00000000000/${x0} )/2 ))
    printf -v x1 "%.0f" ${x1:0:${#x1}-3}.${x1:${#x1}-3}
    done
    x1=0000$x1
    printf "%.3f\n" ${x1:0:${#x1}-4}.${x1:${#x1}-4}
}

sqrt 2000000
1414.214

sqrt 1414214
1189.207

echo $((1189207000/1414214))
840

(Nota: 840 x 1189 is A0 paper size in milimeters ;-)
The same, but working under zsh, dash, ksh, bash and ash (busybox):
sqrt() {
    _val=$1
    set -- 6 2
    x1=$(eval echo \$$((1+(_val&1))))00000 x0=1
    while [ $x0 -ne $x1 ] ;do
    x0=$x1
    x1=000$(( (${x0}000 + ${_val}000000000/${x0} )/2 ))
    x1=$(printf "%.0f" $(echo $x1|sed 's/\(...\)$/.\1/'))
      done
    printf "%.3f\n" $(echo $x1|sed 's/\(...\)$/.\1/')
}

The portable version seems to work fine in zsh too.

@manatwork Thanks I'v forgot them!

dc, 46 chars
Babylonian method - iterative with given precision:
Fk?sp?sn1[ddstlnr/+2/pdlt-[0r-]sbd0>blp<a]dsax

Takes precision and N from stdin. Example invocation (first number is the precision, second number is N:
{ echo 0.0000001 ; echo 489 ; } | dc -e'Fk?sp?sn1[ddstlnr/+2/pdlt-[0r-]sbd0>blp<a]dsax'

It prints all the iterations, just for fun. Printing only last one is trivial change - just move the p behind /+2/ at the end of the program.
Explanation:

Fk sets precision to 15 (see the hexa trick here)
?sp and ?sn asks for input and stores it to the registers
1 is the original seed
the iteration is computed by ddstlnr/+2/. Then, dlt- computes difference from previous iteration. [0r-]sbd0>b performs absolute value of the difference, and if it is greater than the specified precision, loop continues - lp<a.

 /*Fast inverse square root*/
/* from http://en.wikipedia.org/wiki/Fast_inverse_square_root */
float rsqrt( float y,int iter)
{
    const unsigned int fpMagic = 0x5f3759de << 1;
    /*evil floating point bitlevel hacking*/
    unsigned int *i;
    if (sizeof(int) != sizeof(float))
    return -1.0;
    int j;
    const float threehalfs = 1.5F;
    float x2 = y * 0.5F;
    void *p = &y;
    i = p;
    *i = (fpMagic - *i) >> 1;
    /* Newton iterations */
    for (j=0; j < iter; j++)
    {
    y  *=  threehalfs - ( x2 * y * y ) ;
    }
    return 1.0 / y;
}

This needs to be community wiki.

Welcome to the site! This is a code-golf challenge, which means you should try to shorten the code as much as possible - use one-letter variable names and remove unneeded whitespace.

CoffeeScript (12)
s=(n)->n**.5

Thanks to gnibbler's post for the .5 idea, I wouldn't have remembered that by myself.

TI-BASIC, 3
2ˣ√Ans

If that's invalid:
4
Ans^.5

If that's also invalid:
5
e^(.5ln(Ans

If that's also invalid:
21
Babylonian method.
Ans→N
While Ans²≠N
mean({Ans,N/Ans
End
Ans

Thia challenge is too simple, broken, and four years old, but there's no harm in answering.

Seriously, 4 bytes
 This language is 4 years newer than this challenge
1½,^

This does the following Python code in Seriously:
n=input();n**.5

That's 4 characters, but is 5 bytes

@BradGilbertb2gills If you still cares about this, Seriously has its own code page.

Vitsy, 5 Bytes
This language is 4 years newer than the challenge. Go figure.
Not so hard...
12/^N
12/      Push 1/2.
   ^     Put the input to the power of 1/2.
    N    Output as number.

Might be worth noting that Vitsy was invented about 4 years after this challenge was posed.

@JohnE Excellent point, added.

Perl 6,  13  12 chars
sub s{$^a**½} # 13 chars / 14 bytes

my &s=* **½; # 12 chars / 13 bytes

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/2.5/