Ciao ragazzi, per la mia classe ho bisogno di fare una radice quadrata ma non funziona !! HELLPP!

La sfida:

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

Nota: questo è il trolling del codice. Dai una risposta "utile" per guidare questo nuovo programmatore nel suo cammino verso il successo della programmazione! Essere creativo!

Giava

Caspita, questo è un problema complicato. Non ho mai fatto una radice quadrata prima. Ho preso le radici quadrate, ma non ne ho fatto uno. Non dimenticare di rendere bello il tuo codice per ottenere credito extra nelle tue lezioni. Ecco il codice che inserisce una radice quadrata di un numero:

       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:

• Ovviamente, il codice è offuscato.
  • Ricevo punti bonus per l'arte nel codice?
• Le System.out.prints non stampano su java.lang.System.out.print. Stampano su una classe interiore. I primi due (che dovrebbero stampare stringhe) non fanno nulla; il secondo:
• Emette una finestra. Esempio di output: vedi la radice quadrata (l'input è 100) ?:
• La finestra non fa nulla alla chiusura. Né ALT-F4, facendo clic sul pulsante Chiudi, o altrimenti facendo qualcosa che normalmente lo chiuderebbe non riesce.
• La finestra è sempre in primo piano rispetto alle altre finestre. In combinazione con il fatto che è massimizzato, questo richiede un piccolo pensiero per chiuderlo.
• trova il sqrt per intero AGGIUNTA dal numero fino a raggiungere il numero corretto. Questo richiede molto tempo poiché attendiamo il riavvolgimento dei numeri interi. Per questo motivo, in realtà ci vuole meno tempo per numeri più grandi. Per l'output del campione, ci sono voluti 20 secondi.
• Non funziona correttamente per quando l'input è 0. Fallisce per ciclo infinito quando l'ingresso è negativo per lo stesso motivo per cui fallisce per ciclo infinito quando l'ingresso è 0.
• Ho trollato me stesso e ho trascorso ~ 2 ore a codificare questo e ad allinearlo.

C ++

Bene, se non hai una strada migliore, c'è sempre la soluzione della forza 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;
}

Questo scorre attraverso ogni possibile valore di a double( unioninserendolo con un long longche ha le stesse dimensioni di bit, poiché non c'è un buon modo per scorrere effettivamente attraverso di loro usando i doppi come doppi effettivi) fino a quando non trova uno il cui quadrato è n.

Python 3

Questo semplice codice darà una risposta esatta :

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

Stampa solo un √carattere davanti al numero inserito.

In Python 3 puoi fare quanto segue:

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

Correggere questa risposta ,

Usando C, perché C è più veloce

Questo è semplicemente sbagliato. Tutti sanno che il più veloce è ASM.

ASM x86_64 puro!

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

A differenza di altre risposte ritardate, questa ha una complessità di O (1)!
E a differenza di altre risposte, questo è preciso al 101%, sqrt(0.5)perché dà 0.70710678118655!

Troll:
* Scrivere in assemblea. Nessuno scrive in assembly
* Essere O (1) non lo rende veloce. Il mio sistema impiega circa 90 secondi per eseguire sqrt su qualsiasi numero.
* Posizioni di salto hardcoded.
* Nessun frame dello stack
* Sintassi AT&T. Alcune persone lo considerano già un troll.

Spiegazione: Se si osserva la specifica dei float IEEE, è possibile notare che le rappresentazioni binarie dei doppi sono ordinate, ovvero in caso a > baffermativo *(long long *)&a > *(long long *)&b.
Usiamo questo trucco, e ripetiamo l'elevata parola della risposta, ogni volta che FPU lo squadra e esegue il confronto della CPU con l'argomento.
Quindi ripetiamo anche la parola inferiore.
Questo ci trova una risposta esattamente precisa in un numero quasi costante di calcoli.

Pitone

Scrivi una funzione o un programma che "creerà una radice quadrata numerica".

Se è consentito nella tua classe, puoi utilizzare una libreria matematica complessa come supporto qui, installala eseguendo il comando:

pip install num2words

Quindi avresti semplicemente eseguito qualcosa di simile a questo script Python:

import num2words
import os
import crypt

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

(Assicurati di eseguirlo con i privilegi di amministratore)

C

Ovviamente questo è il modo migliore. È più veloce che puoi immaginare guardando il codice. Utilizzando C, perché C è più veloce e questo problema richiede una soluzione rapida. Ho provato questo per i miei numeri preferiti, come 7, 13 e 42, e sembra funzionare.

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

C

Trucchi e magie lo faranno funzionare.

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

È una radice quadrata inversa veloce .

Python 3

Ragazzi, state sbagliando tutto. Chiunque può vedere che la radice quadrata di 20 non è 4.47213595499958, o addirittura √20. Questa soluzione sposta il difficile compito di calcolare la radice quadrata sul modulo destinato a questo scopo.

Uno di questi moduli è sympy, che fornisce matematica con radici quadrate. A differenza di altre soluzioni qui, in realtà fa tutto correttamente. Suppone anche che sqrt (-1) sia I - nessuna delle soluzioni qui può risolverlo.

Ed ecco il codice modulare, che è l'aspetto dei buoni programmi. Le funzioni dovrebbero essere le più piccole possibili, se non lo sono, ciò significa che devi scrivere programmi terribili. Inoltre, i programmi dovrebbero avere molti commenti.

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

Ed ecco un esempio di questo programma funzionante.

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

JavaScript

Sfortunatamente, JavaScript non supporta il simbolo della radice quadrata per i nomi delle funzioni. Invece, possiamo usare qualche altro carattere alfabetico Unicode per rappresentare una funzione radice quadrata.

In questo esempio userò ᕂ.

Una volta che abbiamo un simbolo valido da usare, possiamo usare l'oggetto Math per generare una funzione radice quadrata.

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

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

È semplice! :)

Certo, sarebbe più semplice da usare var ᕂ = Math.sqrt;

Julia

Ovviamente il modo migliore per farlo, è usare la radice quadrata Taylor Series:

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

Che in realtà ha prodotto valori molto precisi:

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

Ma ovviamente come se fosse un'aproximation (e anche essere una serie convergente) è inutile per valori non vicini a 1:

julia> sqroot(0)  #what?
9.659961241569848

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

LaTeX

La soluzione per questo è piuttosto difficile e molto complessa, quindi prendi il tuo caffè. Il problema è che, a seconda del tipo di numero che desideri, lo squareroot del codice cambia in modo significativo. Ti faccio vedere il problema. Diciamo che 9è il tuo numero. Quindi il codice sarebbe simile al seguente:

\sqrt{9}

Ora diciamo che 1234321è il tuo numero, guarda il codice:

\sqrt{1234321}

Ultimo ma non meno importante, supponiamo che il tuo numero sia 0.

\sqrt{0}

Un buon modo per risolvere questo è scrivere un programma in Ook!o Piet, che vuole il tuo numero e ne genera l'output LaTeX-sqrt-code. Ecco un esempio molto semplice per Ook!, in quanto è in grado di leggere solo un byte e non controlla se questo byte è un numero legale o meno, ma penso che arriverai 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 stesso per Piet:

Questo sarebbe il modo più efficiente. Vorrei anche suggerire di usare Pietcome è ogni volta un bellissimo pezzo d'arte, quindi le cose non si annoiano velocemente.

Haskell

Ho smesso di fidarmi dei computer quando ho sentito parlare per la prima volta di errori in virgola mobile. Voglio dire, seriamente, se nemmeno Google non riesce a metterli sotto controllo , chi può farlo ?

Quindi la nostra scommessa migliore è trovare una soluzione che coinvolga solo numeri interi. Fortunatamente è facile dato che possiamo semplicemente controllare tutti i numeri, perché ogni intervallo [1..n] ne contiene solo una quantità finita, non come i reali schifo aleph-1. Ecco un'implementazione di esempio in Haskell:

import Prelude hiding (sqrt)
import Data.List

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

Funziona come un fascino, dai un'occhiata:

λ> sqrt 8
2

La precisione dovrebbe essere sufficiente per la maggior parte delle applicazioni.

Giava

Il modo più preciso per farlo è iterare. Innanzitutto, esegui il ciclo per integers fino a quando non superi il bersaglio, quindi passa a doubles. Questo metodo ha il vantaggio di essere esatto , a differenza di altri metodi di "stima" che potresti vedere. Sacrifichi un po 'di velocità, ma per la maggior parte delle applicazioni, questo è esattamente ciò di cui hai bisogno.

Puoi modificare questa risposta a seconda di quanto devi essere preciso, ma questo dovrebbe funzionare almeno fino al miliardesimo:

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

Questa operazione richiede circa 3 secondi sqrt(99.9999998);. Passare attraverso (fino a) un miliardo di doppietti richiede del tempo, credo.

Javascript

Queste costanti magiche possono essere utilizzate per calcolare la radice quadrata di un numero usando l'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+'';
}

test:

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

Sembra funzionare abbastanza bene. Mi chiedo se c'è un modo più breve?

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

JavaScript

Problema molto difficile!
Non esiste una funzione integrata per questo in JavaScript ...
Sembra un lavoro per il risolutore 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;
}

Adesso puoi usare Math.sqrt

JavaScript / ActionScript

Non è possibile calcolare direttamente una radice quadrata in ActionScript o JavaScript, tuttavia esiste una soluzione alternativa. Puoi ottenere la radice quadrata di un numero elevandolo al 1/2potere.

Ecco come apparirebbe in JavaScript e ActionScript 2:

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

E sebbene la funzione funzioni altrettanto bene in ActionScript 3, consiglierei di usare variabili tipizzate e restituire valori per chiarezza e affidabilità:

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

Il troll:

Sebbene ciò che ho detto sul num^(1/2)risultato di una radice quadrata sia corretto in matematica, ciò che l' ^operatore fa effettivamente in JavaScript e ActionScript è Bitwise XOR .

Python 2.7

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

Spiegazione

citando

Wikipedia - Radice quadrata

In matematica, una radice quadrata di un numero a è un numero y tale che y ² = a

In altre parole, ogni numero è una radice quadrata di qualche altro numero.

Nota

Questa domanda per me è simile a un puzzle ben noto Come accorciare una linea senza strofinarla o tagliarla

PHP (e altri):

Poiché il modo in cui è stata descritta la domanda non ha significato che dobbiamo effettivamente calcolarla, ecco la mia soluzione:

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

Fornisce un modo per calcolare con precisione la radice quadrata in più lingue.

L'elenco delle lingue può essere espanso.

Il valore può essere inviato tramite POST, GET, un cookie o addirittura salvato nella sessione.

Se si fornisce solo il numero, viene confuso e si ottiene il risultato calcolato, valido per (quasi) TUTTA la lingua di sempre!

C

È meglio di tutte le altre 27 risposte perché sono tutte inaccurate. Esatto, danno solo una risposta quando dovrebbero esserci 2. Questo non prova nemmeno a rispondere se sarà sbagliato, si arrende e arrotonda.

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

Codice-trolling:

• Denominazione molto strana
• forabuso di ciclo
• Mettere i punti e virgola all'inizio della riga, dove avrebbero dovuto essere
• #defineutilizzare per aumentare la leggibilità di diminuzione
• messaggio di utilizzo inutile
• meno o più anziché più o meno
• restituisce una stringa
• restituisce una variabile locale
• 4 avvisi del compilatore (2 risultati di espressioni inutilizzati, restituzione dell'indirizzo della variabile locale, non una stringa letterale in printf)
• Funziona solo con quadrati perfetti non negativi <100 (ovvero 0, 4, 9, 16, 25, 36, 49, 64 e 81) poiché la risposta può essere solo di 1 cifra (colpisce un backspace dopo che la risposta è stata stampata per nessun motivo , quindi ad esempio √1024restituisce 3√1024 = ∓32, che è semplicemente sbagliato)

C ++

basato su http://en.wikipedia.org/wiki/Fast_inverse_square_root e la risposta di @ snack.

Tranne che invece di scappare via per convertire x ^ (- 0,5) in x ^ (0,5) ho modificato l'algoritmo per farlo direttamente.

ALGORITMO

Trasmetti un numero in virgola mobile (in questo caso un doppio) in un numero intero (in questo caso lungo).

I primi bit del numero in virgola mobile sono l'esponente: ovvero, il numero viene memorizzato come 2 ^ AAA * 1.BBBBBBB. Quindi fai uno spostamento dei diritti e questo esponente viene dimezzato.

Nella radice quadrata inversa originale , questo numero è stato sottratto da una costante per dare il reciproco. Lo aggiungo solo alla costante, perché voglio direttamente la radice quadrata. Il valore della costante viene scelto per dare una risposta che è la migliore approssimazione al valore desiderato.

Riporta il numero in virgola mobile.

Opzionalmente, una o due iterazioni del metodo di Newton possono essere utilizzate per migliorare il risultato, ma non mi sono preoccupato, perché volevo vedere quanto sarei potuto sfuggire.

Le costanti utilizzate sembrano molto misteriose, ma al di là delle prime cifre, i valori non sono critici. Ho trovato la costante per tentativi ed errori. Mi sono fermato non appena ho ottenuto un valore che a volte sottovalutava e talvolta sopravvalutava.

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

risultati

Il casting è necessario solo perché C non ti consentirà di eseguire operazioni di spostamento dei bit su un float, quindi le uniche operazioni reali sono il cambio di bit e l'aggiunta. Non ho usato una sola iterazione del metodo di Newton per migliorare il risultato, quindi la precisione è notevole. L'insegnante del PO sarà impressionato dalla velocità del metodo che (francamente) è abbastanza preciso per molti scopi!

E

Nota: questo funziona solo sul mio computer, poiché l'hardware sottostante non memorizza i numeri in binario ma in base e, in modo tale che ciò che appare come 10rappresenta e, 100rappresenta e ^e così via. In questo modo, ciò che si potrebbe chiamare una macchina binaria a uno spostamento di bit verso sinistra esegue x => e ^x , e ciò che si potrebbe chiamare una macchina binaria a uno spostamento di bit verso destra esegue x => ln x. Chiaramente, è difficile rappresentare i suoi numeri sottostanti su questo mezzo Internet binario molto limitato, ma faccio del mio meglio.

La sintassi di E è notevolmente simile a quella di C / C ++, quindi questo dovrebbe essere facile da capire per la maggior parte delle persone.

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

JavaScript / HTML / CSS

Ho pensato di usare jQuery e gli ID per trollare un po 'di più, ma preferisco i vanilla js.

Il risultato non è perfettamente preciso, ma funziona!

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]

Leggi il valore della tua risposta dall'asse delle coordinate.

100% puro bash (basato su numeri interi)

Con presentazione ascii-art:

Questo quadrato di radice perfetto deve essere ottenuto in bash usando il 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}",$'!     !',+-----+};}

Vecchio (questa versione potrebbe essere semplicemente incollata in qualsiasi terminale console)

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

Funzionerà come:

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

Nota: la radice è quadrata !!

Giava

Grazie a ggmx's per il codice sulla generazione di n cifre di pi in 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);
    }
}

Non mi andava di implementare input. Per testare la modifica del codice sqrtThiseexpectedPercision .

Ecco come funziona il codice. In primo luogo, ottenere la radice sqrt per intero è banale, quindi non mi andava di implementarla e invece utilizzavo javas costruiti in sqrt fcn. Il resto del codice è comunque legittimo al 100%.

L'idea di base, poiché pi è un numero decimale lungo non ripetuto infinito, tutte le sequenze numeriche devono avvenire al suo interno (leggi modifica). Perciò la tua risposta è dentro pi !! Come tale possiamo semplicemente applicare una ricerca regex su pi cercando la tua risposta. Se non riusciamo a trovare una buona risposta, raddoppieremo la dimensione di pi su cui stiamo cercando!

È davvero facile, infatti si potrebbe dire che è facile come pi :)

Modifica
Pi non ha dimostrato di contenere ogni sequenza di numeri finiti al suo interno. Il fatto che pi sia infinito e non ripetitivo non è una prova sufficiente per affermazioni come quelle dimostrate da Exelian. Comunque molti matematici credono che pi contenga ogni sequenza di numeri finiti.

JQuery

questo è il più preciso (bonus: funziona anche per le lettere!)

Please enter the number : 

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

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

Ecco un violino

C ++

Questo alla fine ti darà una radice quadrata.

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

Ho corretto il codice per riflettere meglio la domanda. Grazie per i tuoi suggerimenti ... il codice è aggiornato.

Pitone

Questa soluzione:

1. non è deterministico e fornisce risposte approssimative
2. è O (N) e abbastanza lento, anche per N basso
3. si basa su un'oscura relazione matematica

spoiler:

Somma N variabili indipendenti uniformi [-.5, .5]. Stimare la deviazione standard prendendo la media dei valori assoluti. Come succede, la deviazione standard è proporzionale a sqrt (N) come N -> \ infty. 139 e 2.71828 sono solo fattori di scala che controllano la precisione e sono stati scelti per apparire misteriosi.

Codice:

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

La tua domanda non viene compilata perché hai inserito un! alla fine. C ++ non mi piace!
Ecco la domanda corretta per il compilatore:

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

Oh .. e il file make.

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

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

e 26317.def. Questo dovrebbe già essere presente nel tuo compilatore

#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ì, qualcuno può usare -E per produrre la risposta di preelaborazione corretta, ma se conosci -E sai anche come fare squareroot. : P Ecco alcuni dei preelaborati. Soluzione minima molto scarsa, nessun controllo associato, nessun prompt. TIL che la trigrafia è preelaborata.

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