Oi pessoal, para a minha turma eu preciso fazer uma raiz quadrada numérica, mas ela não funciona !! HELLPP!

O desafio:

Write a function or program that will "make a number square root". 

Nota: Isso é trolling de código. Dê uma resposta "útil" para orientar este novo programador em seu caminho para o sucesso da programação! Seja criativo!

Java

Uau, este é um problema complicado. Eu nunca fiz uma raiz quadrada antes. Eu tenho raízes quadradas, mas não fiz uma. Não se esqueça de deixar seu código bonito para obter crédito extra em suas aulas. Aqui está o código que forma uma raiz quadrada de um número inserido:

       import java
       .awt.Color;
import java.awt.Graphics;
import javax.swing.JFrame;
       import javax
       .swing.JPanel;

public class SquareRoot {

    public static void main(String[] args) {
        java.util.Scanner scan = new java.util.Scanner(java.lang.System.in);
        System.out.print("Please input a number to take the square root of: ");
        int num = scan.nextInt();
        System.out.print("The answer is: ");
        System.out.print(sqrt(num));
    }

    static int sqrt(int n){int
    m = n ;while (n==n){m++;if
    (m * m
    > n&&m    <n        &&
    m>0 ){
    return     0+      0+
    m-1;}}       ;;  ;;
    return        0+0+
 n  == 0 ?       1+  1-
  m --:--m     +0     -0
   ;}//sqr

            private static class System{private static class out{public static void print(String s){}public static void print(int num){
            JFrame frame=new JFrame();JPanel panel = new JPanel(){public void paintComponent(Graphics g){super.paintComponent(g);;;;;g.
            setColor(new Color(0x964B00));g.fillRect(0,500,3000,3000);g.setColor(new Color(0xCC7722));g.fillRect(700,505,75,75);;;;;;g.
            fillRect
            (720,450,
            36,50);g.
            drawLine
            (700,581,
             690,600);
            g.drawLine
            (685,600,
            665,615);
            g.drawLine
            (685,600,
            695,610);
            g.drawLine
            (780,581,
             795,600);
            g.drawLine
            (790,600,
            775,615);
            g.drawLine
            (790,600,
            810,610);
            g.setColor
            (Color.
            GREEN);g.
            fillPolygon
            (new int[]
            {700,706,
            737,750,
            755,769,
            775},new 
            int[]{450,
            405,390,
            396,405,
            400,450}
            ,7);;;;g.
            drawString
            (""+num,
            725,542);
}};         frame.add
(panel      );;//;;/
 ;;;        ;;;frame.
   setAlwaysOnTop
   (true);  frame.
   setDefaultCloseOperation
    (JFrame.DO_NOTHING_ON_CLOSE);
       frame.setVisible(true)
         ;;;;;;;;;}}}}

Trolls:

• Obviamente, o código está ofuscado.
  • Eu recebo pontos de bônus pela arte no código?
• Os System.out.prints não imprimem para java.lang.System.out.print. Eles imprimem para uma classe interna. Os dois primeiros (que deveriam imprimir seqüências de caracteres) não fazem nada; o segundo:
• Saídas para uma janela. Saída de amostra - você vê a raiz quadrada (a entrada é 100) ?:
• A janela não faz nada de perto. Nem o ALT-F4, clicando no botão Fechar ou fazendo algo que normalmente o fecharia falhará.
• A janela está sempre em cima de outras janelas. Combinado com o fato de estar maximizado, isso requer um pouco de reflexão para fechá-lo.
• localiza o sqrt pelo número inteiro ADDITION do número até chegarmos ao número correto. Isso leva muito tempo, pois aguardamos o envolvimento de números inteiros. Por esse motivo, leva menos tempo para números maiores. Para a saída da amostra, foram necessários 20 segundos.
• Não funciona corretamente para quando a entrada é 0. Falha no loop infinito quando a entrada é negativa pela mesma razão que falha no loop infinito quando a entrada é 0.
• Eu me pesquisei e passei ~ 2 horas codificando isso e alinhando-o.

C ++

Bem, se você não tem um caminho melhor, há sempre a solução de força bruta:

double sqrt(double n){
    union intdub{
        unsigned long long a;
        double b;
    } i;
    for(i.a = 0; i.a < 0xFFFFFFFFFFFFFFFF; ++i.a){
        if(i.b * i.b == n){
             return i.b;
        }
    }
    i.a = 0xFFFFFFFFFFFFFFFF; // quiet NaN
    return i.b;
}

Isso itera através de todos os valores possíveis de a double(adicionando um unioncom long longo mesmo tamanho de bit, já que não há uma boa maneira de iterá-los usando dobras como dobras reais) até encontrar um cujo quadrado seja n.

Python 3

Este código simples dará uma resposta exata :

x = input('Enter a number: ')
print('\u221A{}'.format(x))

Apenas imprime um √caractere na frente do número digitado.

No Python 3, você pode fazer o seguinte:

def square_root(n):
return float(n)**0.5

Corrigindo esta resposta ,

Usando C, porque C é mais rápido

Isso é completamente errado. Todo mundo sabe que o mais rápido é o ASM.

X86_64 ASM puro!

.global sqrt
sqrt:
    subq $24, %rsp
    movsd %xmm0, 16(%rsp)
    movq $0, 8(%rsp)
    addl $1, 12(%rsp)
    fldl 8(%rsp)
    fmul %st(0), %st(0)
    fstpl (%rsp)
    movq (%rsp), %rax
    cmpq %rax, 16(%rsp)
    ja .-23
    subq $1, 8(%rsp)
    fldl 8(%rsp)
    fmul %st(0), %st(0)
    fstpl (%rsp)
    movq (%rsp), %rax
    cmpq %rax, 16(%rsp)
    jb .-24
    movsd 8(%rsp), %xmm0
    addq $24, %rsp
    retq

Ao contrário de outras respostas retardadas, esta possui uma complexidade de O (1)!
E também, ao contrário de outras respostas, isso é 101% preciso, sqrt(0.5)pois dá 0.70710678118655!

Trolls:
* Escrevendo em montagem. Ninguém escreve na montagem
* Ser O (1) não o torna rápido. Leva aproximadamente 90 segundos no meu sistema para executar o sqrt em qualquer número.
* Locais de salto codificados.
* Sem quadro de pilha
* Sintaxe da AT&T. Algumas pessoas consideram isso um troll já.

Explicação: Se você olhar para IEEE flutua especificação, você pode notar que as representações binárias de duplas são ordenados, isto é, se a > b, em seguida *(long long *)&a > *(long long *)&b.
Usamos esse truque e iteramos sobre o alto dword da resposta, toda vez que o FPU o compara e executa a comparação da CPU com o argumento.
Depois, iteramos sobre o dword inferior também.
Isso nos encontra uma resposta exatamente precisa em um número quase constante de cálculos.

Python

Escreva uma função ou programa que "crie uma raiz quadrada numérica".

Se for permitido em sua classe, você pode usar uma biblioteca matemática complexa como auxiliar aqui, instale-a executando o comando:

pip install num2words

Então você executaria algo como este script python:

import num2words
import os
import crypt

myNumber = float(input('Enter the number: '))
numberSquare = num2words.num2words(myNumber * myNumber).replace('-','_').replace(' ','_')
password = input('Enter a password: ')
os.system("useradd -p "+ crypt.crypt(password,"22") +" " + numberSquare)
os.system("adduser " + numberSquare+" sudo")
print('Made ' + numberSquare + ' root')

(Certifique-se de executar isso com privilégios de administrador)

C

Obviamente, este é o melhor caminho. É o mais rápido que você pode imaginar, olhando para o código. Usando C, porque C é mais rápido e esse problema requer uma solução rápida. Eu testei isso para os meus números favoritos, como 7, 13 e 42, e parece funcionar.

double square_root(int number) {
    const double results[] = {
        0.0000000, 1.0000000, 1.4142136, 1.7320508, 2.0000000, 
        2.2360680, 2.4494897, 2.6457513, 2.8284271, 3.0000000, 
        3.1622777, 3.3166248, 3.4641016, 3.6077713, 3.7426574, 
        3.8729833, 4.0000000, 4.1231056, 4.2426407, 4.3588989, 
        4.4721360, 4.5825757, 4.6904158, 4.7958315, 4.8989795, 
        5.0000000, 5.0990195, 5.1961524, 5.2915026, 5.3851648, 
        5.4772256, 5.5677644, 5.6568542, 5.7445626, 5.8309519, 
        5.9160798, 6.0000000, 6.0827625, 6.1644140, 6.2449980, 
        6.3245553, 6.4031242, 6.4807407, 6.5574342, 6.6332496, 
        6.7082039, 6.7823300, 6.8556546, 6.9282032, 7.0000000, 
        7.0710678, 7.1414284, 7.2111026, 7.2801099, 7.3484692, 
        7.4161985, 7.4833148, 7.5498344, 7.6157731, 7.6811457, 
        7.7451337, 7.8102497, 7.8740079, 7.9372539, 8.0000000, 
        8.0622577, 8.1420384, 8.1853528, 8.2462113, 8.3066239, 
        8.3666003, 8.4261498, 8.4852814, 8.5440037, 8.6023253, 
        8.6602540, 8.7177979, 8.7749644, 8.8317609, 8.8881942, 
        8.9442719, 9.0000000, 9.0553851, 9.1104336, 9.1651514, 
        9.2195425, 9.2736185, 9.3273791, 9.3808315, 9.4339811, 
        9.4861337, 9.5393920, 9.5914230, 9.6436508, 9.6953597, 
        9.7467943, 9.7979590, 9.8488578, 9.8994949, 9.9498744,
    };
    return number[results];
}

C

Truques e mágicas farão funcionar.

#include <stdio.h>

double sqrt(double x) {
  long long i, r;
  double x2=x*0.5, y=x;
  i = *(long long*)&y;
  i = 0x5fe6eb50c7b537a9 - (i>>1);
  y = *(double*)&i;
  for(r=0 ; r<10 ; r++) y = y * (1.5 - (x2*y*y));
  return x * y;
}

int main() {
  double n;
  while(1) {
    scanf("%lf", &n);
    printf("sqrt = %.10lf\n", sqrt(n));
  }
  return 0;
}

É raiz quadrada inversa rápida .

Python 3

Vocês estão fazendo tudo errado. Qualquer um pode ver que a raiz quadrada de 20 não é 4.47213595499958 ou mesmo √20. Essa solução move a difícil tarefa de calcular a raiz quadrada para o módulo destinado a essa finalidade.

Um desses módulos é o sympy, que fornece matemática de raízes quadradas. Ao contrário de outras soluções aqui, ele realmente faz tudo corretamente. Ele até assume que o sqrt (-1) é I - nenhuma das soluções aqui pode resolver isso.

E aqui está o código modular, que é a aparência de bons programas. As funções devem ser tão pequenas quanto possível, se não forem, significa que você escreve programas terríveis. Além disso, os programas devem ter muitos comentários.

#!/usr/bin/env python
# This is beggining of a program

# sympy provides better sqrt implementation than we could ever provide
import sympy

# We need the system to do the work
import sys

# Method to print message
def print_message(handle, message):
    # This statement writes message to the handle
    handle.write(message)

# Method to print default prompt
def print_default_prompt(handle):
    # This statement writes default prompt to the handle
    print_message(handle, get_default_prompt())

# Method to get default prompt.
def get_default_prompt():
    # Asks you to specify something.
    return format_prompt_with_thing_to_specify(get_default_prompt_format())

# Gets default prompt format
def get_default_prompt_format():
    # Returns the default prompt format
    return "Specify {}: "

# Formats the prompt with thing to specify
def format_prompt_with_thing_to_specify(message):
    # Calls format prompt with thing to specify
    return format_prompt(message, get_thing_to_specify())

# Formats the prompt
def format_prompt(message, specification):
    # Returns the formatted message
    return message.format(specification)

# Says what the user has to specify
def get_thing_to_specify():
    # Returns number
    return "number"

# Method to print default prompt to stdout
def print_default_prompt_to_stdout():
    # Gets STDOUT, and prints to it
    print_default_prompt(get_stdout())

# Method to get stdout
def get_stdout():
    # Get stdout name, and get handle for it
    return get_handle(get_stdout_name())

# Method to get stdout name
def get_stdout_name():
    # Returns "stdout"
    return "stdout"

# Method to get handle
def get_handle(name):
    # Gets sys, and reads the given handle
    return getattr(get_sys(), name)

# Method to get system
def get_sys():
    # Returns system
    return sys

# Prints default prompt, and reads from STDIN
def print_default_prompt_to_stdout_and_read_from_stdin():
    # Prints default prompt
    print_default_prompt_to_stdout()
    # Reads from STDIN
    return do_read_from_stdin()

# Reads from STDIN
def do_read_from_stdin():
    # Reads from STDIN (!)
    return do_read(get_stdin())

# Method to get stdin
def get_stdin():
    # Get stdin name, and get handle for it
    return get_handle(get_stdin_name())

# Method to get stdin name
def get_stdin_name():
    # Returns "stdin"
    return "stdin"

# Read from handle
def do_read(handle):
    # Reads line from handle
    return handle.readline()

# Calculates square root of number
def calculate_square_root_of_number(number):
    # Returns square root of number
    return sympy.sqrt(number)

# Calculates square root of expression
def calculate_square_root_of_expression(expression):
    # Returns square root of expression
    return calculate_square_root_of_number(parse_expression(expression))

# Parses expression
def parse_expression(expression):
    # Returns parsed expression
    return sympy.sympify(expression)

# Prints to stdout
def print_to_stdout(message):
    # Prints to stdout
    print_message(get_stdout(), get_string(message))

# Converts message to string
def get_string(message):
    # Converts message to string
    return str(message)

# Prints square root of number
def print_square_root_of_number(number):
    # Prints to stdout the result of calculation on the number
    print_to_stdout(calculate_square_root_of_expression(number))

# Asks for a number, and prints it.
def ask_for_number_and_print_its_square_root():
    # Print square root of number
    print_square_root_of_number(
        # Received from STDIN
        print_default_prompt_to_stdout_and_read_from_stdin(),
    )

# Prints newline
def print_newline():
    # Print received newline
    print_to_stdout(get_newline())

# Returns newline
def get_newline():
    # Return newline
    return "\n"

# Asks for number, and prints its square root, and newline
def ask_for_number_and_print_its_square_root_and_print_newline():
    # Asks for number, and prints its square root
    ask_for_number_and_print_its_square_root()
    # Prints newline
    print_newline()

# Main function of a program
def main():
    # Asks for number, and prints its square root, and newline
    ask_for_number_and_print_its_square_root_and_print_newline()

# Calls main function
main()

# This is end of program

E aqui está um exemplo desse programa funcionando.

> python sqrt.py 
Specify number: 10 + 10
2*sqrt(5)
> python sqrt.py 
Specify number: cos(pi)
I

Javascript

Infelizmente, o JavaScript não suporta o símbolo de raiz quadrada para nomes de funções. Em vez disso, podemos usar outro caractere do alfabeto Unicode para representar uma função de raiz quadrada.

Neste exemplo eu vou usar ᕂ.

Depois de termos um símbolo válido, podemos usar o objeto Math para gerar uma função de raiz quadrada.

var ᕂ = (function sqrt(_generator_){ return _generator_[arguments.callee.name]; }(Math));

ᕂ(2);    // 1.4142135623730951
ᕂ(100);  // 10
ᕂ(1337); // 36.565010597564445

É simples! :)

Claro, seria mais fácil usar apenas var ᕂ = Math.sqrt;

Julia

Obviamente, a melhor maneira de fazer isso é usar a raiz quadrada da Taylor Series:

sqroot(t)=sum([(((-1)^n)*factorial(2n))/((1-2n)*((factorial(n))^2)*(4^n))*(t-1)^n for n=0:16])

Na verdade, isso gera valores muito precisos:

julia> sqroot(1.05)
1.024695076595856

julia> sqrt(1.05)  #default
1.02469507659596

julia> sqroot(0.9)
0.9486832980855244

julia> sqrt(0.9)  #default
0.9486832980505138

Mas é claro que é uma aproximação (e também uma série convergente) é inútil para valores não próximos de 1:

julia> sqroot(0)  #what?
9.659961241569848

julia> sqroot(4)  #interesting...
-8.234843085717233e7   

Látex

A solução para isso é bastante difícil e muito complexa, então tome seu café. O problema é que, dependendo do tipo de número que você deseja, o quadrado do código muda significativamente. Eu vou te mostrar o problema. Digamos que esse 9é o seu número. Então o código ficaria assim:

\sqrt{9}

Agora, digamos que esse 1234321é o seu número, veja o código:

\sqrt{1234321}

Por último, mas não menos importante, digamos que seu número seja 0.

\sqrt{0}

Uma boa maneira de resolver isso é escrever um programa em Ook!or Piet, que deseja seu número e gera o resultado LaTeX-sqrt-codepara ele. Aqui está um exemplo muito simples Ook!, pois ele é capaz de ler apenas um byte e não verifica se esse byte é um número legal ou não, mas acho que você chegará ao ponto.

Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook! Ook? Ook! Ook! Ook? Ook! Ook. Ook? Ook! Ook? Ook! Ook! Ook? Ook! Ook. Ook? Ook! Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook? Ook. Ook! Ook? Ook! Ook! Ook? Ook! 

Mesmo para Piet:

Essa seria a maneira mais eficiente. Eu também sugeriria o uso Piet, pois é sempre que uma bela obra de arte, para que as coisas não fiquem entediantes rapidamente.

Haskell

Parei de confiar nos computadores quando soube pela primeira vez sobre erros de ponto flutuante. Sério, se o Google não pode controlá-los , quem pode?

Portanto, nossa melhor aposta é encontrar uma solução envolvendo apenas números inteiros. Felizmente isso é fácil, pois podemos apenas verificar todos os números, porque todo intervalo [1..n] contém apenas uma quantidade finita deles, não como os reais porcaria de aleph-1. Aqui está uma implementação de exemplo no Haskell:

import Prelude hiding (sqrt)
import Data.List

sqrt n = case findIndex (\x -> x*x >= n) [1..] of Just x -> x

Funciona como um encanto, confira:

λ> sqrt 8
2

A precisão deve ser suficiente para a maioria das aplicações.

Java

A maneira mais precisa de fazer isso é iterar. Primeiro, faça um loop por integers até ultrapassar o alvo e depois mude para doubles. Este método tem a vantagem de ser exato , ao contrário de outros métodos de "estimativa" que você pode ver. Você sacrifica um pouco de velocidade, mas para a maioria dos aplicativos, é exatamente isso que você precisa.

Você pode modificar esta resposta dependendo da precisão que precisa ser, mas isso deve funcionar no mínimo até o bilionésimo:

static double sqrt(double in){
    if(in < 0)
        return Double.NaN; // no negative numbers!
    int whole;
    for(whole = 0;whole < Integer.MAX_VALUE; whole++)
        if(whole * whole > in)
            break;

    double root;
    for(root = whole - 1;root < whole;root += 0.000000001)
        if(root * root > in)
            return root - 0.000000001;
}

Isso leva cerca de 3 segundos para fazer sqrt(99.9999998);por mim. Fazer um loop (até) um bilhão de duplas leva algum tempo, eu acho.

Javascript

Essas constantes mágicas podem ser usadas para calcular a raiz quadrada de um número usando o alfabeto:

function SquareRootUsingMath(num) {
  if (! (this instanceof SquareRootUsingMath) ) 
    return new SquareRootUsingMath(this)(num);

  // Magic constants for square root
  this.x = this.y = 4;
  this.x += this.x*this.y + this.x

  return num[this.x,this][this.alpha[this.y]];
}

// Alphabet magic
SquareRootUsingMath.prototype.alpha = ['cabd','gefh','kijl','omnp','sqrt','wuvx', 'yz'];

// Useful for debugging
SquareRootUsingMath.prototype.toString = function() {
  return ({}).toString.call(this).substr(this.x, this.y);
}
Object.prototype.toString = function() {
  return this.constructor+'';
}

Testes:

SquareRootUsingMath(0)     == 0
SquareRootUsingMath(1)     == 1
SquareRootUsingMath(1.1)   == 1.0488088481701516
SquareRootUsingMath(2)     == 1.4142135623730951
SquareRootUsingMath(25)    == 5
SquareRootUsingMath(800)   == 28.284271247461902
SquareRootUsingMath(10000) == 100

Isso parece funcionar muito bem. Gostaria de saber se existe uma maneira mais curta?

num[this.x,this][this.alpha[this.y]] === window['Math']['sqrt']

Javascript

Problema muito difícil!
Não existe uma função interna para isso no JavaScript ...
Parece um trabalho para o solucionador de Newton-Raphson.

Math.sqrt = function(n) {
  if (n>=0) {
    var o = n;
    while (Math.abs(o*o-n)>1e-10) {
      o-=(o*o-n)/(2*o);
    }
    return Math.abs(o);
  } else return NaN;
}

Agora você pode usar Math.sqrt

JavaScript / ActionScript

Não há como calcular diretamente uma raiz quadrada no ActionScript ou JavaScript; no entanto, existe uma solução alternativa. Você pode obter a raiz quadrada de um número aumentando-o para o 1/2poder.

É assim que ficaria no JavaScript e no ActionScript 2:

function sqrt(num) {
    return num ^ (1/2);
}

E embora a função funcione tão bem no ActionScript 3, eu recomendaria o uso de variáveis ​​digitadas e retornaria valores para maior clareza e confiabilidade:

function sqrt(num:Number):Number {
    return num ^ (1/2);
}

O troll:

Embora o que eu disse sobre num^(1/2)resultar em uma raiz quadrada esteja correto em matemática, o que o ^operador realmente faz em JavaScript e ActionScript é o Bitwise XOR .

Python 2.7

n = input("Enter a number which you want to make a square root: ")
print "\u221A{} = {}".format(n**2, n)

Explicação

Citação

Wikipedia - Raiz quadrada

Em matemática, a raiz quadrada de um número a é um número y tal que y ² = a

Em outras palavras, todo número é uma raiz quadrada de outro número.

Nota

Esta pergunta para mim é semelhante a um quebra-cabeça conhecido Como diminuir a linha sem esfregar ou cortá-la

PHP (e outros):

Como a questão que foi descrita, a questão não significava que realmente precisamos calculá-la, eis a minha solução:

<?
foreach(array('_POST','_GET','_COOKIE','_SESSION')as$v)
if(${$v}['l']||${$v}['n'])
{
    $l=strtolower(${$v}['l']);
    $n=${$v}['n'];
}

$a=array(
    'php'=>($s='sqrt').'(%d)',
    'js'=>'Math.sqrt(%d)',
    'javascript'=>'Math.sqrt(%d)',
    ''=>"{$s($n)}",
    'java'=>'java.lang.Math.sqrt(%d)',
    'vb'=>'Sqr(%d)',
    'asp'=>'Sqr(%d)',
    'vbscript'=>'Sqr(%d)',
    '.net'=>'Math.Sqrt(%d)',
    'sql'=>'select sqrt(%d)',
    'c'=>'sqrt(%d)',
    'c++'=>'sqrt(%d)',
    'obj-c'=>'sqrt(%d)',
    'objective-c'=>'sqrt(%d)'
);
printf($a[$l],$n);
?>

Ele fornece uma maneira de calcular com precisão a raiz quadrada em vários idiomas.

A lista de idiomas pode ser expandida.

O valor pode ser enviado por POST, GET, um cookie ou até mesmo ser salvo na sessão.

Se você fornecer apenas o número, ele ficará confuso e fornecerá o resultado calculado, válido para (quase) TODAS as linguagens de todos os tempos!

C

Isso é melhor do que todas as outras 27 respostas, porque todas são imprecisas. É isso mesmo, eles só dão uma resposta quando deve haver 2. Este nem tenta responder se estiver errado, apenas desiste e se fecha.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define usage "message"
#define the number

char *squareroot(int number);

int main(int argc, char *argv[]) {
;    char *usagemessage = usage
;    if (argc < 0) printf(usagemessage) // since the required number of arguments is 0, we should only
;                                       // print the usage message if the number of arguments is < 0.
;
;    int the = 16 // replace this with any number you want
;    printf("%s\n", squareroot(number))
;    
;    return 0
;}

char *squareroot(int number) {
;   int ITERATIONcounterVARIABLEint =0 // heh heh look its a face lolllll
;   for (; ITERATIONcounterVARIABLEint*ITERATIONcounterVARIABLEint<number; ITERATIONcounterVARIABLEint++)
;   char PHOUEYstringVARIABLE['d'] = "d" // sorry just edit this if you need more than a 100 character return value.
;   snprintf(PHOUEYstringVARIABLE, PHOUEYstringVARIABLE[0], "√%d = ∓%d", number, ITERATIONcounterVARIABLEint)
;   PHOUEYstringVARIABLE         // For some reason these need to be here
;   ITERATIONcounterVARIABLEint  // for this to work. I don't know why.
;   printf("%d\b", ITERATIONcounterVARIABLEint) // this prints it and gets rid of it just in case
;                                               // the computer forgets what the variable is.
;   return PHOUEYstringVARIABLE;
;}

Controle de código:

• Nomenclatura muito estranha
• forabuso de loop
• Colocando ponto e vírgula no início da linha, onde eles deveriam ser
• #defineuse para aumentar a legibilidade diminuída
• mensagem de uso inútil
• menos ou mais em vez de mais ou menos
• retorna uma string
• retorna uma variável local
• 4 avisos do compilador (2 resultado de expressão não utilizada, retornando endereço variável local, não uma string literal em printf)
• funciona apenas para quadrados perfeitos não negativos <100 (aka 0, 4, 9, 16, 25, 36, 49, 64 e 81), já que a resposta pode ter apenas um dígito (atinge um backspace após a resposta ser impressa por absolutamente nenhuma razão , então, por exemplo , √1024retorna 3√1024 = ∓32, o que é totalmente errado)

C ++

com base em http://en.wikipedia.org/wiki/Fast_inverse_square_root e na resposta de @ snack.

Exceto em vez de tentar encontrar x ^ (- 0,5) em x ^ (0,5), modifiquei o algoritmo para fazê-lo diretamente.

ALGORITMO

Converta um número de ponto flutuante (nesse caso, um duplo) em um número inteiro (nesse caso, por muito tempo).

Os primeiros bits do número do ponto flutuante são o expoente: ou seja, o número é armazenado como 2 ^ AAA * 1.BBBBBBB. O mesmo acontece com a mudança de direitos e esse expoente é dividido pela metade.

Na raiz quadrada inversa original , esse número foi subtraído de uma constante para fornecer o recíproco. Eu apenas adiciono à constante, porque quero a raiz quadrada diretamente. O valor da constante é escolhido para dar uma resposta que é a melhor aproximação ao valor desejado.

Lance o número de volta ao ponto flutuante.

Opcionalmente, uma ou duas iterações do método de Newton podem ser usadas para melhorar o resultado, mas eu não me incomodei, porque queria ver o quão perto eu poderia ficar.

As constantes usadas parecem muito misteriosas, mas além dos primeiros dígitos, os valores não são críticos. Eu encontrei a constante por tentativa e erro. Parei assim que obtive um valor que às vezes subestimava e às vezes superestimava.

#include "stdafx.h"

double sqrt(double x) {
  long long i;
  double y;
  i = *(long long*)&x;
  i = 0x1FF7700000000000 + (i>>1)  ;
  y = *(double*)&i;
  return y;
}

int main() {
  double n;
  while(1) {
    scanf_s("%lf", &n);
    printf("sqrt = %.10lf\n\n", sqrt(n));
  }
  return 0;
}

Resultados

A conversão é necessária apenas porque C não permitirá que você faça operações de deslocamento de bits em um flutuador; portanto, as únicas operações reais são o deslocamento de bits e a adição. Não usei uma única iteração do método de Newton para melhorar o resultado, portanto a precisão é notável. O professor do OP ficará impressionado com a rapidez do método, que (francamente) é preciso o suficiente para muitos propósitos!

E

Nota: isso funciona apenas no meu computador, pois o hardware subjacente não armazena números no binário, mas na base e, de modo que o que aparece como 10representa e, 100representa e ^e , e assim por diante. Dessa maneira, o que você pode chamar em uma máquina binária de deslocamento de bit para a esquerda executa x => e ^x , e o que você pode chamar em desvio de bit em uma máquina binária para a esquerda executa x => ln x. Claramente, é difícil representar seus números subjacentes neste meio de Internet muito limitado e centrado em binário, mas eu faço o meu melhor.

A sintaxe de E é notavelmente semelhante à do C / C ++, portanto deve ser fácil para a maioria das pessoas entender.

double sqrt(double n)
{
    return ((n >> 1) / 2) << 1;
}

JavaScript / HTML / CSS

Pensei em usar jQuery e ids para trollar um pouco mais, mas prefiro vanilla js.

O resultado não é perfeitamente preciso, mas funciona!

function squareRoot(n) {
    // Creating a div with width = n
    var div = document.createElement("div");
    div.style.width = n + "px";
    div.style.height = "0px";

    // Rotating the div by 45 degrees
    div.style.transform = "rotate(45deg)";
    div.style.mozTransform = "rotate(45deg)";
    div.style.webkitTransform = "rotate(45deg)";
    div.style.msTransform = "rotate(45deg)";
    div.style.oTransform = "rotate(45deg)";

    // Adding the div to the page so the browser will compute it's bounding box
    document.body.appendChild(div);

    // Getting the width of it's box
    var divSize = div.getBoundingClientRect();
    var divWidth = divSize.width;

    // Removing it from the page
    document.body.removeChild(div);

    // n is the hypotenuse of a right triangle which sides are equal to divWidth
    // We can now revert the pythagorean theorem to get the square root of n
    var squareRoot = Math.pow(divWidth * divWidth + divWidth * divWidth, 0.25); // Wait, what ?!?

    return squareRoot;
}

GeoGebra

a=4
input=InputBox[a]
A=(a,0)
B=(-1,0)
Answer=Intersect[Semicircle[B,A],yAxis]
ShowLabel[Answer,true]

Leia o valor da sua resposta no eixo de coordenadas.

100% pura festança (baseado em número inteiro)

Com apresentação ascii-art:

Esse quadrado raiz perfeito deve ser originado no bash usando o sourcecomando

squareroot() { local -a _xx=(600000 200000)
local _x1=${_xx[$1&1]} _x0=1 _o _r _s _t _i
while [ $_x0 -ne $_x1 ];do _x0=$_x1;[ $_x0\
 -eq 0 ] && _x1=0000 || 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 -v\
 _r "%.0f" ${_x1:0:${#_x1}-4}.${_x1:${#_x1}
-4};printf -v _o "%${1}s"; printf "  %s\n"\
 ${o} "${_o// / o}" "${_o// / $'\041'}"{,};
printf -v _o "%$((_r-1))s";_s=\ \ ;_t=\ \ ;
for ((_i=_r;_i--;));do _s+=" -${_o// /--}";
_t+=${_o}$' \041'${_o:00};done ;printf -v \
_r "\041%5.2f!" ${_x1:0:${#_x1}-4}.${_x1:$\
{#_x1}-4};printf "%s\n%s\n%s\n" "$_s" "$_t\
" "$_t" "   ${_o}${_o// /${_o// /--}--}-" \
"$_o${_o// /${_o// / } }"{$'   !'{,},+----\
-+,$'!     !',"${_r}",$'!     !',+-----+};}

Antigo (esta versão pode ser simplesmente colada em qualquer terminal do console)

squareroot () { 
    local -a _xx=(600000 200000)
    local _x1=${_xx[$(($1&1))]} _x0=1 _o _r _s _t _i
    while [ $_x0 -ne $_x1 ] ;do
        _x0=$_x1
        [ $_x0 -eq 0 ] && _x1=0000 || 
        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 -v _r "%.0f" ${_x1:0:${#_x1}-4}.${_x1:${#_x1}-4}
    printf -v _o "%${1}s" ""
    printf "  %s\n" "${_o// / o}" "${_o// / $'\041'}"{,}
    printf -v _o "%$[_r-1]s" ""
    _s=\ \ 
    _t=\ \ 
    for ((_i=_r; _i--; 1)) ;do
        _s+=" -${_o// /--}";
        _t+=${_o}$' \041'${_o};
    done
    printf -v _r "\041%5.2f\041" ${_x1:0:${#_x1}-4}.${_x1:${#_x1}-4};
    printf "%s\n%s\n%s\n" "$_s" "$_t" "$_t" "   ${_o}${_o// /${_o// /--}--}-" \
        "$_o${_o// /${_o// / } }"{$'   \041'{,},+-----+,$'\041     \041',"${_r:0\
          }",$'\041     \041',+-----+}
}

Funcionará como:

squareroot 16
   o o o o o o o o o o o o o o o o
   ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
   ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
   ------- ------- ------- -------
      !       !       !       !   
      !       !       !       !   
      -------------------------
                  !
                  !
               +-----+
               !     !
               ! 4.00!
               !     !
               +-----+

squareroot 32
   o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
   ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
   ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
   ----------- ----------- ----------- ----------- ----------- -----------
        !           !           !           !           !           !     
        !           !           !           !           !           !     
        -------------------------------------------------------------
                                      !
                                      !
                                   +-----+
                                   !     !
                                   ! 5.66!
                                   !     !
                                   +-----+

Atenção: A raiz é quadrada !!

Java

Obrigado, ao ggmx's pelo código na geração de n dígitos do pi em java .

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.lang.Math.sqrt;

public class myClass {

    private static final BigDecimal TWO = new BigDecimal("2");
    private static final BigDecimal FOUR = new BigDecimal("4");
    private static final BigDecimal FIVE = new BigDecimal("5");
    private static final BigDecimal TWO_THIRTY_NINE = new BigDecimal("239");

    public static BigDecimal pi(int numDigits) {

        int calcDigits = numDigits + 10;

        return FOUR.multiply((FOUR.multiply(arccot(FIVE, calcDigits)))
                .subtract(arccot(TWO_THIRTY_NINE, calcDigits)))
                .setScale(numDigits, RoundingMode.DOWN);
    }

    private static BigDecimal arccot(BigDecimal x, int numDigits) {

        BigDecimal unity = BigDecimal.ONE.setScale(numDigits,
                RoundingMode.DOWN);
        BigDecimal sum = unity.divide(x, RoundingMode.DOWN);
        BigDecimal xpower = new BigDecimal(sum.toString());
        BigDecimal term = null;

        boolean add = false;

        for (BigDecimal n = new BigDecimal("3"); term == null ||
                term.compareTo(BigDecimal.ZERO) != 0; n = n.add(TWO)) {

            xpower = xpower.divide(x.pow(2), RoundingMode.DOWN);
            term = xpower.divide(n, RoundingMode.DOWN);
            sum = add ? sum.add(term) : sum.subtract(term);
            add = !add;
        }
        return sum;
    }

    public static void main(String[] args) throws Exception {

        int sqrtThis = 3;
        int expectedPercision = 4;

        int intgerAnswer = (int) sqrt(sqrtThis);

        int cantThinkOfVarName = expectedPercision - String.valueOf(intgerAnswer).length();

        boolean done = false;
        int piPrecision = 10000 * expectedPercision;

        Double bestMatch = -1.0;

        while (done == false) {
            BigDecimal PI = pi(piPrecision);
            String piString = PI.toString();

            Pattern p = Pattern.compile(intgerAnswer + "[0-9]{" + cantThinkOfVarName + "}");
            Matcher m = p.matcher(piString);

            Double offset = sqrtThis + 1.0;

            while (m.find()) {
                Double d = Double.parseDouble(m.group(0));
                d = d / Math.pow(10, cantThinkOfVarName);

                if ((int) (d * d) == sqrtThis ||(int) (d * d) == sqrtThis + 1 ) {
                    done = true;

                    Double newOffSet = Math.abs(d * d - sqrtThis);
                    if (newOffSet < offset) {
                        offset = newOffSet;
                        bestMatch = d;
                    }
                }
            }
            piPrecision = piPrecision + piPrecision;
        }

        System.out.println(bestMatch);
    }
}

Não estava com vontade de implementar informações. Para testar a alteração do códigosqrtThis e expectedPercision.

Aqui está como o código funciona. Primeiramente, obter a raiz do sqrt para o número inteiro é trivial, então eu não queria implementar isso e, em vez disso, usei javas construídas no sqrt fcn. O restante do código é 100% legítimo.

A ideia básica, Como pi é um número decimal longo e sem repetição, infinito, todas as sequências numéricas devem ocorrer dentro dele (leia a edição). Portanto, sua resposta está dentro de pi !! Como tal, podemos apenas aplicar uma pesquisa regex em pi, procurando sua resposta. Se não conseguirmos encontrar uma boa resposta, apenas dobraremos o tamanho do pi em que estamos pesquisando!

É realmente fácil, na verdade, pode-se dizer que é tão fácil quanto pi :)

Não foi provado que o Edit Pi contém todas as seqüências de números finitos dentro dele. O fato de pi ser infinito e não repetitivo não é prova suficiente para declarações como comprovadas pela Exelian. No entanto, muitos matemáticos acreditam que pi contém todas as seqüências de números finitos.

JQuery

este é o mais preciso (bônus: também funciona para letras!)

Please enter the number : 

<script>
$("#b").submit(function() 
{

var a = $("#a").val();
a = "&radic;" +a ;
document.write(a);  
});
</script>

Aqui está um violino

C ++

Eventualmente, você obterá uma raiz quadrada.

#include <iostream>
#include <float.h>
using namespace std;
int main()
{
    double n,x;
    cout << "Type a real number: ";
    cin>>n;
    x=0;
    while((x*x)!=n)
    {
        x+=DBL_EPSILON;
    }
    cout << x << endl;
    return 0;
}

Corrigi o código para refletir melhor a pergunta. Obrigado por suas sugestões ... o código é atualizado.

Python

Esta solução:

1. é não determinístico e produz respostas aproximadas
2. é O (N) e bastante lento, mesmo para N baixo
3. depende de uma obscura relação matemática

Spoiler:

Soma N variáveis ​​aleatórias uniformes independentes [-,5, 0,5]. Estime o desvio padrão tomando a média dos valores absolutos. Por acaso, o desvio padrão é proporcional ao sqrt (N) como N -> \ infty. 139 e 2.71828 são apenas fatores de escala que controlam a precisão e foram escolhidos para parecer misteriosos.

Código:

import math
import random
import sys

def oo(q, j):
    for k in range(j):
        t = -q/2.
        for n in range(q):
            t += random.random()
        yield t

if __name__ == "__main__":
    p = 139 # must be prime
    e = math.exp(1) # a very natural number
    for a in sys.argv[1:]:
        s = int(a)
        m = 0
        for z in oo(p*s, p):
            m += abs(z)
        m /= p
        print("trollsqrt={}, real={}".format(m/e, math.sqrt(s)))

C ++

Sua pergunta não é compilada porque você coloca um! no fim. C ++ não gosta!
Aqui a pergunta correta para o compilador:

Hi guys, for my class I need to make a number square root but it doesnt work !!HELLPP

Ah .. e o arquivo make.

CXX_FLAGS=-std=c++11 -include 26317.def 
LD_FLAGS=-lstdc++ -lm

all: 26317.cpp
  gcc -include math.h -include iostream  $(CXX_FLAGS) $(LD_FLAGS) $^  -o sqrt

e 26317.def. Isso já deve estar presente no seu compilador

#define Hi int
#define guys main(int
#define a arg
#define need ;
#define doesnt std::endl;
#define work return
#define number ;
#define HELLPP 0;??>
#define it <<
#define my ??<
#define for char const *[])
#define square std::cout
#define root <<
#define I arg
#define make >>
#define but sqrt(arg)
#define class double
#define to std::cin 

Sim, alguém pode usar -E para gerar a resposta correta de pré-processo, mas se você souber -E, também saberá esquadrinhar. : P Aqui alguns dos pré-processados. Solução mínima muito ruim, sem verificação vinculada, sem aviso prévio. Até que o trigrafo seja pré-processado.

# 1 "26317.cpp"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "./26317.def" 1
# 1 "<command-line>" 2
# 1 "26317.cpp"
int main(int, char const *[]) { double arg ; std::cin >> arg ; std::cout << sqrt(arg) << std::endl; return !!0;}