Hola chicos, para mi clase necesito hacer una raíz cuadrada de números, ¡pero no funciona! ¡HELLPP!

El reto:

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

Nota: Esto es código curricular. ¡Dé una respuesta "útil" para guiar a este nuevo programador en su camino hacia el éxito de la programación! ¡Ser creativo!

Java

Wow, este es un problema complicado. Nunca he hecho una raíz cuadrada antes. He tomado raíces cuadradas, pero no he hecho una. No olvide hacer que su código se vea bonito para obtener crédito adicional en sus clases. Aquí está el código que hace una raíz cuadrada de un número ingresado:

       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, el código está ofuscado.
  • ¿Recibo puntos de bonificación por el arte en el código?
• Los System.out.prints no imprimen a java.lang.System.out.print. Imprimen a una clase interna. Los dos primeros (que se supone que imprimen cadenas) no hacen nada; el segundo:
• Salidas a una ventana. Salida de muestra: ¿ve la raíz cuadrada (la entrada es 100) ?:
• La ventana no hace nada al cerrar. Ni ALT-F4, haciendo clic en el botón de cierre o haciendo algo que normalmente cerraría, falla.
• La ventana siempre está encima de otras ventanas. Combinado con el hecho de que está maximizado, esto requiere un poco de pensamiento para cerrarlo.
• encuentra el sqrt por entero ADICIÓN desde el número hasta llegar al número correcto. Esto lleva mucho tiempo ya que esperamos un ajuste entero. Debido a esto, en realidad lleva menos tiempo para números más grandes. Para la salida de muestra, tardó 20 segundos.
• No funciona correctamente para cuando la entrada es 0. Falla por bucle infinito cuando la entrada es negativa por la misma razón que falla por bucle infinito cuando la entrada es negativa 0.
• Me trolleé y pasé ~ 2 horas codificando esto y alineándolo.

C ++

Bueno, si no tienes una ruta mejor, siempre existe la solución de fuerza 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;
}

Esto itera a través de todos los valores posibles de a double( unionhaciéndolo con un long longque es del mismo tamaño de bit, ya que no hay una buena manera de iterar a través de ellos usando dobles como dobles reales) hasta que encuentre uno cuyo cuadrado sea n.

Python 3

Este código simple dará una respuesta exacta :

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

Simplemente imprime un √carácter delante del número ingresado.

En Python 3 puedes hacer lo siguiente:

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

Corrigiendo esta respuesta ,

Usando C, porque C es más rápido

Eso es simplemente incorrecto. Todos saben que el más rápido es ASM.

Puro x86_64 ASM!

.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

¡A diferencia de otras respuestas retardadas, esta tiene una complejidad de O (1)!
Y también, a diferencia de otras respuestas, ¡esto es 101% preciso, porque sqrt(0.5)da 0.70710678118655!

Trolls:
* Escritura en conjunto. Nadie escribe en ensamblado
* Ser O (1) no lo hace rápido. Mi sistema tarda aproximadamente 90 segundos en realizar sqrt en cualquier número.
* Ubicaciones de salto codificadas.
* Sin marco de pila
* Sintaxis de AT&T. Algunas personas ya lo consideran un troll.

Explicación: Si observa la especificación de flotantes IEEE, puede notar que las representaciones binarias de dobles están ordenadas, es decir, si es a > basí *(long long *)&a > *(long long *)&b.
Usamos este truco e iteramos sobre la palabra alta de la respuesta, cada vez que FPU la cuadra y realiza una comparación de CPU con el argumento.
Luego iteramos sobre el dword inferior también.
Esto nos encuentra una respuesta exactamente precisa en un número casi constante de cálculos.

Pitón

Escriba una función o programa que "haga una raíz cuadrada de números".

Si está permitido en su clase, puede usar una biblioteca matemática compleja como ayuda aquí, instálela ejecutando el comando:

pip install num2words

Entonces simplemente ejecutarías algo como este script de 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')

(Asegúrese de ejecutar eso con privilegios de administrador)

do

Obviamente esta es la mejor manera. Es tan rápido como te puedas imaginar mirando el código. Usando C, porque C es más rápido, y este problema requiere una solución rápida. He probado esto para mis números favoritos, como 7, 13 y 42, y 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];
}

do

Los trucos y la magia lo harán 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;
}

Es una raíz cuadrada inversa rápida .

Python 3

Ustedes están haciendo todo mal. Cualquiera puede ver que la raíz cuadrada de 20 no es 4.47213595499958, ni siquiera √20. Esta solución mueve la difícil tarea de calcular la raíz cuadrada al módulo destinado para este propósito.

Uno de esos módulos es sympy, que proporciona matemáticas de raíces cuadradas. A diferencia de otras soluciones aquí, en realidad hace todo correctamente. Incluso supone que sqrt (-1) es I, ninguna de las soluciones aquí puede resolver eso.

Y aquí está el código modular, que es cómo se ven los buenos programas. Las funciones deben ser lo más pequeñas posible, si no lo son, eso significa que escribe programas horribles. Además, los programas deben tener muchos comentarios.

#!/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

Y aquí hay un ejemplo de este programa funcionando.

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

JavaScript

Desafortunadamente, JavaScript no admite el símbolo de raíz cuadrada para los nombres de funciones. En cambio, podemos usar algún otro carácter del alfabeto Unicode para representar una función de raíz cuadrada.

En este ejemplo lo usaré ᕂ.

Una vez que tenemos un símbolo válido para usar, podemos usar el objeto Math para generar una función de raíz cuadrada.

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

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

¡Es simple! :)

Por supuesto, sería más fácil usar var ᕂ = Math.sqrt;

Julia

Obviamente, la mejor manera de hacerlo es usar la serie Taylor de raíz cuadrada:

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

Eso realmente genera valores muy 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

Pero, por supuesto, como es una aproximación (y también para ser una serie convergente) es inútil para valores no cercanos a 1:

julia> sqroot(0)  #what?
9.659961241569848

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

Látex

La solución para esto es bastante difícil y muy compleja, así que toma tu café. El problema es que, dependiendo del tipo de número que desee, la raíz cuadrada del código cambia significativamente. Te mostraré el problema. Digamos que ese 9es tu número. Entonces el código se vería así:

\sqrt{9}

Ahora digamos que ese 1234321es tu número, mira el código:

\sqrt{1234321}

Por último, pero no menos importante, digamos que su número es 0.

\sqrt{0}

Una buena manera de resolver esto es escribir un programa en Ook!o Piet, que quiere su número y lo genera LaTeX-sqrt-code. Aquí hay un ejemplo muy simple para Ook!, ya que solo puede leer un byte y no comprueba si este byte es un número legal o no, pero creo que llegará al punto.

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! 

Lo mismo para Piet:

Esta sería la forma más eficiente. También sugeriría usarlo, Pietya que cada vez es una hermosa obra de arte, para que las cosas no se aburran rápidamente.

Haskell

Dejé de confiar en las computadoras cuando escuché por primera vez sobre errores de punto flotante. Quiero decir, en serio, si incluso Google no puede controlarlos , ¿quién puede?

Entonces, nuestra mejor apuesta es encontrar una solución que involucre solo enteros. Afortunadamente, eso es fácil ya que solo podemos verificar todos los números, porque cada intervalo [1..n] contiene solo una cantidad finita de ellos, no como los reales de basura aleph-1. Aquí hay una implementación de muestra en Haskell:

import Prelude hiding (sqrt)
import Data.List

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

Funciona como un encanto, échale un vistazo:

λ> sqrt 8
2

La precisión debería ser suficiente para la mayoría de las aplicaciones.

Java

La forma más precisa de hacer esto es iterar. Primero, integerpase por s hasta que pase por encima del objetivo, luego cambie a doubles. Este método tiene la ventaja de ser exacto , a diferencia de otros métodos de "estimación" que puede ver. Sacrificas un poco de velocidad, pero para la mayoría de las aplicaciones, esto es exactamente lo que necesitas.

Puede modificar esta respuesta según la precisión que necesite ser, pero esto debería funcionar al menos hasta la milmillonésima parte:

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

Esto toma alrededor de 3 segundos sqrt(99.9999998);para mí. Supongo que recorrer (hasta) mil millones de dobles lleva algún tiempo.

Javascript

Estas constantes mágicas se pueden usar para calcular la raíz cuadrada de un número usando el 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+'';
}

Pruebas:

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

Parece funcionar bastante bien. Me pregunto si hay un camino más corto.

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

JavaScript

¡Un problema muy difícil!
No hay una función incorporada para eso en JavaScript ...
Parece un trabajo para el solucionador 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;
}

Ahora puedes usar Math.sqrt

JavaScript / ActionScript

No hay forma de calcular directamente una raíz cuadrada en ActionScript o JavaScript, sin embargo, hay una solución alternativa. Puedes obtener la raíz cuadrada de un número elevándolo a la 1/2potencia.

Así es como se vería en JavaScript y ActionScript 2:

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

Y aunque la función funciona igual de bien en ActionScript 3, recomendaría usar variables escritas y valores de retorno para mayor claridad y fiabilidad:

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

El troll:

Aunque lo que dije sobre el num^(1/2)resultado de una raíz cuadrada es correcto en matemáticas, lo que el ^operador realmente hace en JavaScript y ActionScript es Bitwise XOR .

Python 2.7

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

Explicación

Citando

Wikipedia - Raíz cuadrada

En matemáticas, una raíz cuadrada de un número a es un número y tal que y ² = a

En otras palabras, cada número es una raíz cuadrada de algún otro número.

Nota

Esta pregunta para mí es similar a un rompecabezas bien conocido Cómo hacer una línea más corta sin frotarla o cortarla

PHP (y otros):

Como la forma en que se describió la pregunta no significaba que realmente necesitáramos calcularla, aquí está mi solución:

<?
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);
?>

Proporciona una manera de calcular con precisión la raíz cuadrada en varios idiomas.

La lista de idiomas se puede ampliar.

El valor puede enviarse por POST, GET, una cookie o incluso guardarse en la sesión.

Si solo proporciona el número, se confunde y da el resultado calculado, ¡eso es válido para (casi) CADA idioma!

do

Esto es mejor que las otras 27 respuestas porque todas son inexactas. Así es, solo dan una respuesta cuando debería haber 2. Esta ni siquiera intenta responder si va a estar mal, simplemente se rinde y se redondea.

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

Código de trolling:

• Nombres muy extraños
• forabuso de bucle
• Poner punto y coma al comienzo de la línea, donde debían estar
• #defineutilizar para aumentar disminuir la legibilidad
• mensaje de uso inútil
• menos o más en lugar de más o menos
• devuelve una cadena
• devuelve una variable local
• 4 advertencias del compilador (2 resultados de expresión no utilizados, que devuelve la dirección de la variable local, no un literal de cadena en printf)
• solo funciona para cuadrados perfectos no negativos <100 (también conocido como 0, 4, 9, 16, 25, 36, 49, 64 y 81) ya que la respuesta solo puede ser de 1 dígito (pulsa un retroceso después de que la respuesta se imprime sin ninguna razón , por ejemplo , √1024devuelve 3√1024 = ∓32, lo cual es simplemente incorrecto)

C ++

basado en http://en.wikipedia.org/wiki/Fast_inverse_square_root y la respuesta de @ snack.

Excepto en lugar de atornillar una forma de convertir x ^ (- 0.5) en x ^ (0.5) modifiqué el algoritmo para hacerlo directamente.

ALGORITMO

Convierta un número de coma flotante (en este caso, un doble) en un entero (en este caso, largo y largo).

Los primeros bits del número de coma flotante son el exponente: es decir, el número se almacena como 2 ^ AAA * 1.BBBBBBB. Entonces haga un cambio de derechos y este exponente se reduce a la mitad.

En la raíz cuadrada inversa original , este número se restaba de una constante para dar el recíproco. Solo lo agrego a la constante, porque quiero la raíz cuadrada directamente. El valor de la constante se elige para dar una respuesta que es la mejor aproximación al valor deseado.

Devuelve el número al punto flotante.

Opcionalmente, se pueden usar una o dos iteraciones del método de Newton para mejorar el resultado, pero no me molesté, porque quería ver qué tan cerca podría estar sin él.

Las constantes utilizadas parecen muy misteriosas, pero más allá de los primeros dígitos, los valores no son críticos. Encontré la constante por prueba y error. Me detuve tan pronto como obtuve un valor que a veces se subestima y a veces se sobreestima.

#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

La conversión solo es necesaria porque C no le permitirá realizar operaciones de desplazamiento de bits en un flotador, por lo que las únicas operaciones reales son el desplazamiento de bits y la suma. No he usado una sola iteración del método de Newton para mejorar el resultado, por lo que la precisión es notable. ¡El maestro del OP estará impresionado con la velocidad del método que (francamente) es lo suficientemente preciso para muchos propósitos!

mi

Nota: esto solo funciona en mi computadora, ya que el hardware subyacente no almacena números en binario sino en base e, de modo que lo que aparece como 10representa e, 100representa e ^e , etc. De esta manera, lo que podría llamar una máquina binaria a un desplazamiento de bits a la izquierda realiza x => e ^x , y lo que podría llamar a una máquina binaria a un desplazamiento de bits a la derecha realiza x => ln x. Claramente, es difícil representar sus números subyacentes en este medio de Internet muy limitado y centrado en binarios, pero hago lo mejor que puedo.

La sintaxis de E es notablemente similar a la de C / C ++, por lo que debería ser fácil de entender para la mayoría de las personas.

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

JavaScript / HTML / CSS

Pensé en usar jQuery y ids para troll un poco más, pero prefiero vanilla js.

El resultado no es perfectamente preciso, ¡pero 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]

Lea el valor de su respuesta desde el eje de coordenadas.

100% puro bash (entero)

Con presentación ascii-art:

Este cuadrado raíz perfecto debe obtenerse en bash utilizando el 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}",$'!     !',+-----+};}

Antiguo (esta versión podría simplemente pegarse en cualquier terminal de consola)

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!
                                   !     !
                                   +-----+

Tenga en cuenta: ¡La raíz es cuadrada!

Java

Gracias a ggmx por el código para generar n dígitos de pi en 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);
    }
}

No tenía ganas de implementar la entrada. Para probar el cambio de código sqrtThisy expectedPercision.

Así es como funciona el código. En primer lugar, obtener la raíz sqrt para integer es trivial, así que no tuve ganas de implementar eso y en su lugar utilicé javas integradas en sqrt fcn. Sin embargo, el resto del código es 100% legítimo.

La idea basica, dado que pi es un número decimal infinito largo que no se repite, todas las secuencias numéricas deben ocurrir dentro de él (leer editar). Por lo tanto, su respuesta está dentro de pi !! Como tal, podemos aplicar una búsqueda de expresiones regulares en pi buscando su respuesta. Si no podemos encontrar una buena respuesta, ¡duplicaremos el tamaño de pi que estamos buscando!

Es realmente fácil, de hecho se podría decir que es tan fácil como pi :)

No se ha demostrado que Edit Pi contenga todas las secuencias de números finitos dentro de él. El hecho de que pi es infinito y no repetitivo no es prueba suficiente de tal afirmación como lo demuestra Exelian. Sin embargo, muchos matemáticos creen que pi contiene todas las secuencias de números finitos.

JQuery

este es el más preciso (bonificación: ¡también funciona para letras!)

Please enter the number : 

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

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

Aquí hay un violín

C ++

Esto eventualmente te dará una raíz cuadrada.

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

Corregí el código para reflejar mejor la pregunta. Gracias por sus sugerencias ... el código está actualizado.

Pitón

Esta solución:

1. no es determinista y produce respuestas aproximadas
2. es O (N) y bastante lento, incluso para niveles bajos de N
3. se basa en una oscura relación matemática

Spoiler

Suma N variables uniformes independientes [-.5, .5] al azar. Estime la desviación estándar tomando la media de los valores absolutos. Como sucede, la desviación estándar es proporcional a sqrt (N) como N -> \ infty. 139 y 2.71828 son solo factores de escala que controlan la precisión y fueron elegidos 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 ++

Tu pregunta no se compila porque pones un! al final. C ++ no me gusta!
Aquí la pregunta correcta para el compilador:

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

Ah ... y el archivo 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

y 26317.def. Esto ya debería estar presente en su 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 

Sí, alguien puede usar -E para generar la respuesta correcta de preproceso, pero si sabe -E también sabe cómo cuadrar. : P Aquí algunos preprocesados. Muy poca solución mínima, sin verificación encuadernada, sin aviso. TIL que los trigrafos son preprocesados.

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