¡¡Ayuda!! ¡Cómo hacer raíz cuadrada! [cerrado]

42

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!

qwr
fuente
63
@CloseVoters Deje de votar para cerrar [code-trolling] como fuera de tema debido a la falta de criterios ganadores. En este caso, obviamente es un [concurso de popularidad]. Edítala si quieres. El hecho de que no te guste [code-trolling] no significa que tengas que cerrar el desafío para todos los demás. Obviamente, a muchas personas les gusta este tipo de desafío, evidenciado por la cantidad de respuestas, por lo tanto, dado que SE es un sitio impulsado por la comunidad , déjelo abierto para estas personas.
Justin
12
@Quincunx Para el registro, mi voto fue por Too Broad. Literalmente, no hay nada que hacer excepto "hacer algo relacionado con las raíces cuadradas". (Como se evidencia por haber ya quince respuestas.)
Pomo de la puerta
77
Votantes cercanos: ¿Pueden ayudarme a comprender cómo esto es más "amplio" que otras preguntas no cerradas [de trolling de códigos]? Tal vez haya una razón válida aquí, pero la categoría de trolling de código será, naturalmente, un poco más amplia que la mayoría de los desafíos. De lo contrario, derrotaría un poco el propósito.
Geobits
66
@Geobits, al decir que la respuesta ni siquiera tiene que ser correcta, esto es tan amplio como "Escribir un código".
Peter Taylor
11
@Gareth Es una analogía interesante, pero no coincide con el comentario original. Eres bienvenido a estar fuera de McDonalds todo el día con una pancarta que dice a la gente que la comida es una mierda. Y usted es bienvenido a rechazar / poner comentarios negativos sobre esta pregunta. Sin embargo, si intenta evitar físicamente que las personas ingresen a McDonalds (el equivalente a la segunda ronda de votación cerrada, que acaba de comenzar), lo más probable es que lo arresten. Siento cierta simpatía por la causa de la lucha contra el código y no voy a votar (ni rechazar) esta pregunta. Pero quiero libertad para publicar una respuesta si tengo una.
Level River St

Respuestas:

121

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) ?:ingrese la descripción de la imagen aquí
  • 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.
Justin
fuente
11
Excelentemente trolleado, buen señor.
Code Whisperer
1
Creo que dejaste de lado JFrame.DO_NOTHING_ON_CLOSEen la lista de trolls ...
PlasmaPower
2
@PlasmaPower Estaba a punto de editar eso. Olvidaste mencionarlo setAlwaysOnTop(true)también.
Justin
44
"Me trolleé a mí mismo" Creo que tú también trolleaste a tu novia, jajaja
Herjan
15
@Herjan novia? Que novia
Justin
71

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.

Joe Z.
fuente
12
Ahora me pregunto, ¿con qué frecuencia (dado un tiempo ilimitado para correr) esto realmente funciona, y con qué frecuencia no puede encontrar una coincidencia exacta y devolver NaN? Estoy pensando que es aproximadamente 50/50, pero es demasiado tarde aquí para un buen pensamiento matemático.
hobbs
29
Dios mío, la unión de A doubley A long longes la cosa más aterradora que he visto.
Patrick Collins
10
Tal vez esto se quiera (parte del curricán), pero acceder a diferentes partes de un unioncomportamiento indefinido es posible e iterar a través de los dobles es posible con la funciónstd::nextafter
nadie el
66
No tenía idea de que std::nextafterexistía antes de que me lo mencionaras, así que sí, era querido.
Joe Z.
3
Algunos doublevalores no se pueden producir al multiplicar x*xdonde xestá double, también. Entonces, la búsqueda no tendrá éxito a veces (¿la mayoría de las veces?), Dando NaN en lugar de un resultado más correcto.
Sarge Borsch
64

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.

dan04
fuente
24
@JanDvorak por otro lado, este es el único programa aquí que siempre dará la respuesta exacta.
Level River St
1
@steveverrill: No, el mío también.
NaCl
1
@steveverrill: Desafío este programa entonces, escribí un programa que siempre da la respuesta correcta, y en realidad resuelve el problema (por cierto, es mi programa Python 3, no el programa C).
Konrad Borowski
16
@ JanDvorak esto es trolling de código
TheDoctor
45

En Python 3 puedes hacer lo siguiente:

def square_root(n):
return float(n)**0.5
jamierocks
fuente
38
Descubrí tu troll: esto no funciona. Parece que lo haría, pero la segunda línea necesitaría una sangría.
Justin
77
@DLeh, ¿es posible que se esté trolleando?
krs013
42

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.

mniip
fuente
55
Corregir su corrección: C es más rápido que el ensamblaje, porque el compilador puede optimizar mejor que el humano. A menos que conozca cada operación de ensamblaje x86, el compilador generalmente escribirá un código mejor.
Konrad Borowski
30
@xfix Corrección de su corrección: con un manual de Intel a mano, un humano puede producir un ensamblaje más eficiente que el CCG
mniip
66
@xfix Después de leer breves descripciones de cada mnemotécnico, cosas como PCMPEQQya no te parecen "basura mágica ilegible producida por un compilador"
mniip
1
Wow, desearía que fueras mi compañero de laboratorio, no tengo idea de lo que estoy haciendo en la asamblea. Hilarante respuesta / comentarios.
HC_
@mniip (corrigiendo su corrección) ^ 3: Un superoptimizador puede encontrar el código óptimo (probando todas las series posibles de instrucciones) y superar a un humano ^ _ ^ ¿Seguramente eso debería estar integrado en cualquier raíz cuadrada?
Navin
39

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)

nvuono
fuente
¿Puedes explicar cómo es esto trolling?
The Guy with The Hat
66
@TheGuywithTheHat: en lugar de dar la raíz cuadrada de un número, esta solución crea un usuario nombrado con el cuadrado del número y lo convierte en administrador ( rooten Unixland).
3Doubloons
33

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];
}
Konrad Borowski
fuente
3
Creo que quieres decir results[number];?
ace_HongKongIndependence
31
@ace: Ambos funcionan, solo prefiero poner más ofuscación aquí. Consulte stackoverflow.com/q/381542/736054 para obtener información sobre por qué esta sintaxis es válida en C.
Konrad Borowski,
8
@ArlaudPierre Esa es la belleza de las soluciones de trolling de código como estas. Están bien para un cierto rango, lo que puede hacerte creer que en realidad son utilizables.
Sr. Lister el
2
@ MrLister En realidad son utilizables. La pregunta no dice qué rango de valores se aceptan. Puede haber contextos donde este es absolutamente un valor aceptable.
Pierre Arlaud
99
@ArlaudPierre: Bueno, hay otro troll bien escondido en mi código. Algunos valores no son válidos, pero no es que nadie lo note (especialmente porque están en orden de todos modos). Y luego la gente se quejaría de otro error Pentium FDIV.
Konrad Borowski
30

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 .

Bocadillo
fuente
77
Sabía que alguien haría esto :) Así es como se ve la magia real
qwr
8
Pasé casi un minuto buscando el 1 / a para convertirlo de la raíz inversa a la raíz real. La alternativa de usar return x * y es correcta, pero más difícil de detectar.
Level River St
1
Creo que 10 iteraciones son demasiado. 2-3 son generalmente suficientes.
njzk2
1
@ njzk2 en realidad en el motor Quake 3 solo se usó una iteración. El segundo fue comentado con una nota adicional "esto se puede eliminar". codemaestro.com/reviews/9
No sé
29

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
Konrad Borowski
fuente
12
-1 comentarios no suficientes
alexwlchan
55
@alexwlchan: se agregaron más comentarios.
Konrad Borowski el
2
¡Son nombres de funciones descriptivos realmente cortos, fáciles de entender! +1! PD Agregó más comentarios.
AMK
2
-1 nombre de la función no lo suficientemente largo, debe ser print_format_prompt_with_thing_to_specify_get_default_prompt_format_to_getattr_get_sys_name_from_get_stdout_name_and_print_square_root_of_read_from_stdin_and_print_get_string_from_get_newline_to_getattr_get_sys_name_from_get_stdout_name.
The Guy with The Hat
1
@TheGuywithTheHat: preferiría que mis grandes nombres de funciones encajaran en el cuadro de código sin desplazamiento horizontal. Incluso si se trata de código trolling , odio el desplazamiento.
Konrad Borowski
28

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;

nderscore
fuente
16
Me gusta cómo su código rompe los compresores JS.
Konrad Borowski
2
@xfix Sí, si algo intenta cambiar el nombre de esa función de ejecución automática, el código se romperá :)
nderscore
25

Julia

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

ingrese la descripción de la imagen aquí

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   
PCC
fuente
2
El radio de convergencia de esta serie de potencia es 1, por lo que esto solo funcionará para t en (0,2) (o para t complejo en el disco abierto centrado en 1 del radio 1). Para otros valores, podría usar factorizaciones ...
gniourf_gniourf
Tienes razón, no especifiqué el intervalo de convergencia solo por simplicidad :)
CCP
2
Demasiado útil para mi gusto. Se puede dividir fácilmente en un 4 hasta que esté dentro de límites, y luego multiplicar el resultado con la potencia correspondiente de 2.
user19713
1
^ Creo que es seguro decir que el que hace preguntas perezosas promedio lo tomará tal como está.
Joe Z.
Creo que te estás perdiendo el hecho de que la serie Taylor está desplazada y centrada en 1, por lo que si divido por a^2(n veces) y multiplico por a(n veces) la respuesta ( sqrt(x)~a^n*sqroot(x/a^2n)) x-> 0 (si a> 0) no es 1 (dando grandes errores). Además, si x / a ^ 2n ~ 1 los números a!=xy ncambiarán de forma arbitraria xpara obtener la presición deseada (lo que resulta molesto y lleva mucho tiempo encontrarlos).
PCCh
20

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:

¡Hace lo mismo que el programa simple escrito en Ook!

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.

NaCl
fuente
3
Me gustaría este código Piet, pero es solo un compilador Brainfuck (que pude encontrar en Internet) que ejecuta el código Ook.
Konrad Borowski
11
¿Espera un segundo? ¿Es un programa esolang que ejecuta el compilador de otro idioma para analizar un tercer idioma? ¡Oh chico!
Kroltan
Ook es solo un brillo de símbolo por palabra en Brainfuck.
Ross Presser
20

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.

Flonk
fuente
2
+1.0 para los "crap aleph-1 reales"
wchargin
2
@ M.Mimpen Ackhhhchh: duckduckgo.com/…
AMK
1
@AMK Huh. Quizás Google está usando doublesy DDG está usando triples.
wchargin
16

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.

Geobits
fuente
1
El problema con el uso 0.000000001es que es propenso a errores de redondeo. He creado una solución más precisa en C ++.
Joe Z.
2
@JoeZ. Sí, eso obtuvo mi +1, pero este es lo suficientemente bueno para el trabajo del gobierno. Por supuesto, el tuyo devuelve NaN para cualquier respuesta que no pueda ser representada exactamente por un doble que parece, por lo que la precisión está un poco en el aire;)
Geobits
Cierto. ¿Debo poner detección de épsilon allí?
Joe Z.
3
¿Por qué no hacer en Math.nextUp(root)lugar de +0.000000001? Eso llevaría mucho más tiempo ... y se garantiza que tendrá éxito.
Justin
1
@Quincunx Pensé que había un método que lo hizo Doubley me sorprendió cuando no pude encontrarlo. No pensé en mirar Math, pero esto funciona bastante bien. No he tenido "falla" en nada todavía.
Geobits
11

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']

Paul
fuente
10

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

Michael M.
fuente
¿Cómo funciona este troll? ¿Es el hecho de que da una respuesta negativa?
Joe Z.
1
@JoeZ. Usar un solucionador Newton-Raphson para hacer una tarea para principiantes es el troll. No es la respuesta esperada, pero funciona, y pasará algún tiempo tratando de entender el código.
Michael M.
28
-1 no es suficiente jQuery.
Pierre Arlaud
55
@ArlaudPierre Espero que no hayas dado un -1 ...
tomsmeding
@tomsmeding No lo hizo.
Justin
10

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 .

IQAndreas
fuente
1
La mejor respuesta por ahí. me gustó el operador 'power'
Silviu Burcea
Tal respuesta sería más mala en C o Python2, donde además 1/2 == 0.
aland
9

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 2 = 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

Abhijit
fuente
9

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!

Ismael Miguel
fuente
8

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)
0942v8653
fuente
#define the number... ¡bonito! Me gustó su razonamiento sobre la condición para mostrar el mensaje de uso, en particular.
CompuChip
-1 porque el mensaje de uso se mostrará si ingreso más de 2 mil millones de parámetros de línea de comandos. O tal vez solo 32768 de ellos si lo estoy ejecutando en una máquina de 16 bits como un PDP-11. (Ahí, eso sale conmigo). Ninguno de los dos es realmente posible porque en cualquier caso la arquitectura prohibiría ingresar tantos parámetros a menos que falsifique la llamada a main y simplemente le haya mentido. Lo cual no es imposible: podría hacer eso. De hecho, ya podría haberte mentido.
ClickRick
8

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!

ingrese la descripción de la imagen aquí

Level River St
fuente
Punto flotante súper preciso
Cole Johnson
2
@ColeJohnson Bueno, no puede tener una salida precisa, eso es una restricción del mundo de la informática (no podemos tener memoria infinita). Entonces diría que esto es lo más preciso posible.
Pierre Arlaud
Bueno, el doble es claramente exagerado, y parte del troll. Esperaba obtener aproximadamente +/- 30% de este método. Tropezando, me sorprende lo preciso que es. Parte de la razón es esta: 4 = 2 ^ 10* 1. 000, sqrt (4) = 2 ^ 01* 1. 000= 2, sqrt (2) = 2 ^ 00* 1. 100= 1.5. Entonces, el 1bit desplazado del exponente da una mantisa de 1.5, que no está muy lejos del valor verdadero de sqrt (2), que es aproximadamente 1.4. Pero no tengo idea de cómo da respuestas consistentemente con una precisión mejor del 3%.
Level River St
7

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;
}
ClickRick
fuente
77
¿Es este un lenguaje real?
Joe Z.
¿Qué tipo de computadora estás usando?
Cole Johnson
@ClickRick ¿Hay alguna posibilidad de que pueda proporcionar un enlace para la sintaxis de programación E y el esquema de comando?
WallyWest
66
Lo sentimos, pero incluso en la base e, n >> 1no es lo mismo que log(n).
jwg
2
El lenguaje es bastante fácil de inferir. La existencia de hardware de soporte es la parte que debería cuestionar.
ClickRick
6

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;
}
sebcap26
fuente
6

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.


Pruébelo en línea aquí (requiere Java), o disfrute de algunas capturas de pantalla a continuación:

ingrese la descripción de la imagen aquí ingrese la descripción de la imagen aquí

ace_HongKongIndependence
fuente
6

100% puro (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!

F. Hauri
fuente
4

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.

Sahar Rabinoviz
fuente
Me gustaría señalar que ser infinito y no repetido no hace que todas las secuencias aparezcan en un número. Es bastante fácil construir un número que sea infinito y que no se repita, pero que no contenga todas las secuencias posibles, p. Ej. 0.1011001110001111 ... Sé que esto es puntilloso, pero la gente a menudo usa este argumento incorrectamente (pi probablemente contiene todos los posibles sin embargo, simplemente no lo sabemos con certeza)
Exelian
@Exelian hizo una corrección de acuerdo con su comentario, proporcionó un enlace para respaldar tanto su comentario como la razón por la cual mi solución aún es suficiente.
Sahar Rabinoviz
3

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

Mhmd
fuente
3
Tomar el desafío demasiado literalmente no es demasiado divertido. Aunque no creo que lo document.writecontrarreste lo suficiente.
John Dvorak
2
@ JanDvorak esto es un código de trolling, tales soluciones son válidas aquí.
Mhmd
3
@Mhmd: Aún así, esperamos que seas creativo aquí. Todo el mundo ya hizo eso, hacer otra cosa. No obtendrás muchos votos positivos de esta manera.
Konrad Borowski
1
@ JanDvorak / xfix: Si el problema es que la respuesta es de baja calidad y aún cumple con los criterios mínimos, ¿no es la solución dejar que la respuesta se hunda hasta el fondo por puntaje? (Dado que ya es una conclusión perdida, de acuerdo con su enlace.)
Andrew Coonce
1
@ JanDvorak: Buen punto. Considerando eso, ¡gracias por la explicación!
Andrew Coonce
3

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.

bacchusbeale
fuente
Dado que ya está limitado por la máquina epsilon, ¿por qué no usarlo x+=1e-16?
Kyle Kanos
1
@KyleKanos o más correctamente, DBL_EPSILON.
Cole Johnson
3

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)))
Emanuel Landeholm
fuente
3

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