Cześć chłopaki, dla mojej klasy muszę wykonać pierwiastek kwadratowy, ale to nie działa !! HELLPP!

Wyzwanie:

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

Uwaga: To jest trolling kodu. Podaj „przydatną” odpowiedź, która poprowadzi tego nowego programistę na jego drodze do sukcesu programistycznego! Bądź kreatywny!

Jawa

Wow, to skomplikowany problem. Nigdy wcześniej nie robiłem pierwiastka kwadratowego. Wziąłem pierwiastki kwadratowe, ale jeszcze tego nie zrobiłem. Nie zapomnij, aby Twój kod wyglądał ładnie na dodatkowe kredyty na zajęciach. Oto kod, który tworzy pierwiastek kwadratowy z wprowadzonej liczby:

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

Trolle:

• Oczywiście kod jest zaciemniony.
  • Czy dostanę punkty bonusowe za grafikę w kodzie?
• Do System.out.prints nie drukować java.lang.System.out.print. Drukują do klasy wewnętrznej. Pierwsze dwa (które mają wypisywać ciągi) nic nie robią; Druga:
• Dane wyjściowe do okna. Przykładowe dane wyjściowe - czy widzisz pierwiastek kwadratowy (dane wejściowe są 100) ?:
• Okno nic nie robi po zamknięciu. Ani ALT-F4, kliknięcie przycisku zamykania lub w inny sposób robienie czegoś, co normalnie zamknęłoby to niepowodzenie.
• Okno jest zawsze na wierzchu innych okien. W połączeniu z faktem, że jest on zmaksymalizowany, wymaga to trochę myślenia, aby go zamknąć.
• znajduje sqrt według liczby całkowitej DODATEK od liczby, aż osiągniemy poprawną liczbę. To zajmuje dużo czasu, ponieważ czekamy na zawijanie liczb całkowitych. Z tego powodu w rzeczywistości większe liczby zajmują mniej czasu. Wyjście próbki zajęło 20 sekund.
• Nie działa poprawnie, gdy wejście jest 0. Nie powiedzie się przez nieskończoną pętlę, gdy wejście jest ujemne z tego samego powodu, że zawiedzie przez nieskończoną pętlę, gdy wejście jest 0.
• Trollowałem się i spędziłem ~ 2 godziny na kodowaniu i dostosowywaniu tego.

C ++

Cóż, jeśli nie masz lepszej trasy, zawsze istnieje rozwiązanie brutalnej siły:

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

Powoduje to iterację każdej możliwej wartości a double(poprzez uniondodanie do niej long longtej samej wielkości bitu, ponieważ nie ma dobrego sposobu na iterację poprzez użycie dubletów jako rzeczywistych dubletów), dopóki nie znajdzie tej, której kwadrat jest n.

Python 3

Ten prosty kod da dokładną odpowiedź:

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

Po prostu drukuje √znak przed wprowadzoną liczbą.

W Pythonie 3 możesz wykonać następujące czynności:

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

Poprawiając tę odpowiedź ,

Używam C, ponieważ C jest najszybszy

To po prostu źle. Wszyscy wiedzą, że najszybszy to ASM.

Czysty 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

W przeciwieństwie do innych opóźnionych odpowiedzi, ta ma złożoność O (1)!
I w przeciwieństwie do innych odpowiedzi, jest to 101% precyzji, sqrt(0.5)ponieważ daje 0.70710678118655!

Trolle:
* Pisanie w asemblerze. Nikt nie pisze w asemblerze
* Bycie O (1) nie przyspiesza. Wykonanie sqrt na dowolnej liczbie zajmuje w moim systemie około 90 sekund.
* Lokalizacje skoków zakodowane na stałe.
* Brak ramki stosu
* Składnia AT&T. Niektórzy uważają to już za trolla.

Objaśnienie: Jeśli spojrzysz na specyfikację liczb zmiennoprzecinkowych IEEE, możesz zauważyć, że binarne reprezentacje podwójnych są uporządkowane, to znaczy jeśli a > btak *(long long *)&a > *(long long *)&b.
Używamy tej sztuczki i iterujemy nad ogromem odpowiedzi, za każdym razem, gdy FPU ją kwadruje i wykonuje porównanie procesora z argumentem.
Następnie iterujemy również nad niższym dworem.
To daje nam precyzyjną odpowiedź w prawie stałej liczbie obliczeń.

Pyton

Napisz funkcję lub program, który „wykona pierwiastek kwadratowy”.

Jeśli jest to dozwolone w twojej klasie, możesz użyć złożonej biblioteki matematycznej jako pomocnika tutaj, zainstaluj ją, uruchamiając polecenie:

pip install num2words

Następnie wystarczy uruchomić taki skrypt w języku 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')

(Upewnij się, że uruchamiasz to z uprawnieniami administratora)

do

Oczywiście jest to najlepszy sposób. Jest tak szybki, jak można sobie wyobrazić, patrząc na kod. Używanie C, ponieważ C jest najszybszy, a ten problem wymaga szybkiego rozwiązania. Przetestowałem to dla moich ulubionych liczb, takich jak 7, 13 i 42, i wydaje się, że działa.

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

do

Sztuczki i magia sprawią, że zadziała.

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

Jest to szybki odwrotny pierwiastek kwadratowy .

Python 3

Robicie to wszystko źle. Każdy może zobaczyć, że pierwiastek kwadratowy z 20 nie wynosi 4,47213595499958, a nawet √20. To rozwiązanie przenosi trudne zadanie obliczenia pierwiastka kwadratowego do modułu przeznaczonego do tego celu.

Jednym z takich modułów jest sympy, która zapewnia matematykę pierwiastków kwadratowych. W przeciwieństwie do innych rozwiązań tutaj robi wszystko właściwie. Zakłada nawet, że sqrt (-1) to I - żadne z rozwiązań tutaj tego nie rozwiązuje.

A oto kod modułowy, czyli jak wyglądają dobre programy. Funkcje powinny być tak małe, jak to możliwe, jeśli nie są, oznacza to, że piszesz okropne programy. Ponadto programy powinny mieć wiele komentarzy.

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

A oto przykład działania tego programu.

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

JavaScript

Niestety, JavaScript nie obsługuje symbolu pierwiastka kwadratowego dla nazw funkcji. Zamiast tego możemy użyć innego znaku alfabetu Unicode do przedstawienia funkcji pierwiastka kwadratowego.

W tym przykładzie użyję ᕂ.

Po uzyskaniu prawidłowego symbolu możemy użyć obiektu Math do wygenerowania funkcji pierwiastka kwadratowego.

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

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

To proste! :)

Oczywiście łatwiej byłoby po prostu użyć var ᕂ = Math.sqrt;

Julia

Oczywiście najlepszy sposób, aby to zrobić, używając kwadratu z serii Taylor:

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

To faktycznie generuje bardzo dokładne wartości:

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

Ale oczywiście, podobnie jak aproksymacja (a także być konwergentną serią), jest bezużyteczny dla wartości zbliżonych do 1:

julia> sqroot(0)  #what?
9.659961241569848

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

Lateks

Rozwiązanie tego problemu jest dość trudne i bardzo złożone, więc weź kawę. Problem polega na tym, że w zależności od tego, jaki numer chcesz, znacznik kwadratowy kodu zmienia się znacząco. Pokażę ci problem. Powiedzmy, że 9to twój numer. Następnie kod wyglądałby tak:

\sqrt{9}

Powiedzmy teraz, że 1234321to twój numer, spójrz na kod:

\sqrt{1234321}

Na koniec powiedzmy, że twój numer to 0.

\sqrt{0}

Dobrym sposobem na rozwiązanie tego jest napisanie programu w Ook!lub Piet, który chce twój numer i wypisuje LaTeX-sqrt-codego. Oto bardzo prosty przykład Ook!, ponieważ jest on w stanie odczytać tylko jeden bajt i nie sprawdza, czy ten bajt jest prawidłowy, czy nie, ale myślę, że przejdziesz do sedna.

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

To samo dla Piet:

To byłby najbardziej wydajny sposób. Proponuję również użyć, Pietponieważ jest to za każdym razem piękne dzieło sztuki, więc rzeczy nie nudzą się szybko.

Haskell

Przestałem ufać komputerom, kiedy po raz pierwszy usłyszałem o błędach zmiennoprzecinkowych. Mówiąc poważnie, jeśli nawet Google nie może ich kontrolować , to kto może?

Więc naszym najlepszym rozwiązaniem jest znalezienie rozwiązania obejmującego tylko liczby całkowite. Na szczęście jest to łatwe, ponieważ możemy po prostu sprawdzić wszystkie liczby, ponieważ każdy interwał [1..n] zawiera tylko ich skończoną liczbę, nie tak jak w przypadku bzdurnych aleph-1. Oto przykładowa implementacja w Haskell:

import Prelude hiding (sqrt)
import Data.List

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

Działa jak urok, sprawdź to:

λ> sqrt 8
2

Dokładność powinna wystarczyć dla większości aplikacji.

Jawa

Najdokładniejszym sposobem na to jest iteracja. Najpierw zapętlaj integers, aż przejdziesz nad celem, a następnie przełącz się na doubles. Ta metoda ma tę zaletę, że jest dokładna , w przeciwieństwie do innych metod „szacowania”, które możesz zobaczyć. Poświęcasz trochę prędkości, ale w przypadku większości aplikacji jest to dokładnie to, czego potrzebujesz.

Możesz zmodyfikować tę odpowiedź w zależności od tego, jak precyzyjnie musisz być, ale powinno to działać co najmniej do jednej miliardowej:

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

To zajmuje mi około 3 sekund sqrt(99.9999998);. Wydaje mi się, że zapętlenie (do) miliarda podwójnych zajmuje trochę czasu.

JavaScript

Tych magicznych stałych można użyć do obliczenia pierwiastka kwadratowego liczby za pomocą alfabetu:

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

Testy:

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

Wygląda na to, że działa całkiem dobrze. Zastanawiam się, czy istnieje krótsza droga?

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

JavaScript

Bardzo trudny problem!
W JavaScript nie ma takiej wbudowanej funkcji ...
Wygląda jak zadanie dla solvera Newtona-Raphsona.

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

Teraz możesz użyć Math.sqrt

JavaScript / ActionScript

Nie ma sposobu, aby bezpośrednio obliczyć pierwiastek kwadratowy w ActionScript lub JavaScript, jednak istnieje obejście tego problemu. Możesz uzyskać pierwiastek kwadratowy z liczby, podnosząc go do 1/2potęgi.

Tak to wyglądałoby w JavaScript i ActionScript 2:

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

I chociaż funkcja działa równie dobrze w ActionScript 3, zaleciłbym użycie zmiennych typowych i zwracanych wartości dla przejrzystości i niezawodności:

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

Troll:

Chociaż to, co powiedziałem o num^(1/2)uzyskaniu pierwiastka kwadratowego, jest poprawne w matematyce, to, co ^operator faktycznie robi w JavaScript i ActionScript to Bitwise XOR .

Python 2.7

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

Wyjaśnienie

Cytowanie

Wikipedia - pierwiastek kwadratowy

W matematyce pierwiastek kwadratowy z liczby a jest liczbą y taką, że y ² = a

Innymi słowy, każda liczba jest pierwiastkiem kwadratowym z innej liczby.

Uwaga

To pytanie jest dla mnie podobne do znanej łamigłówki. Jak skrócić linię, nie pocierając jej ani nie przecinając

PHP (i inne):

Ponieważ sposób, w jaki zostało to opisane, pytanie nie oznaczało, że musimy go obliczyć, oto moje rozwiązanie:

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

Zapewnia sposób dokładnego obliczenia pierwiastka kwadratowego w wielu językach.

Lista języków może zostać rozszerzona.

Wartość można wysłać za pomocą POST, GET, ciasteczka, a nawet zapisać w sesji.

Jeśli podasz tylko liczbę, myli się i podaje obliczony wynik, który obowiązuje (prawie) KAŻDY język kiedykolwiek!

do

To jest lepsze niż wszystkich pozostałych 27 odpowiedzi bo to wszystko niedokładne. Zgadza się, podają tylko jedną odpowiedź, kiedy powinno być 2. Ta nawet nie próbuje odpowiedzieć, jeśli będzie źle, po prostu się poddaje i zaokrągla w dół.

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

Trolling kodu:

• Bardzo dziwne nazywanie
• fornadużywanie pętli
• Umieszczanie średników na początku wiersza, gdzie powinny być
• #defineużyj, aby zwiększyć czytelność
• niepotrzebny komunikat o użytkowaniu
• minus lub plus zamiast plus lub minus
• zwraca ciąg
• zwraca zmienną lokalną
• 4 ostrzeżenia kompilatora (2 nieużywane wyniki wyrażenia, zwracający lokalny adres zmiennej, a nie literał ciągu w printf)
• działa tylko dla nieujemnych idealnych kwadratów <100 (aka 0, 4, 9, 16, 25, 36, 49, 64 i 81), ponieważ odpowiedź może składać się tylko z 1 cyfry (uderza w backspace po wydrukowaniu odpowiedzi bez absolutnie żadnego powodu , więc na przykład √1024zwraca 3√1024 = ∓32, co jest po prostu błędne)

C ++

na podstawie http://en.wikipedia.org/wiki/Fast_inverse_square_root i odpowiedzi @ snack.

Z wyjątkiem zamiast rygoru na drodze do konwersji x ^ (- 0,5) na x ^ (0,5) zmodyfikowałem algorytm, aby zrobić to bezpośrednio.

ALGORYTM

Rzuć liczbę zmiennoprzecinkową (w tym przypadku podwójną) na liczbę całkowitą (w tym przypadku długą).

Pierwsze kilka bitów liczby zmiennoprzecinkowej jest wykładnikiem wykładni: liczba jest przechowywana jako 2 ^ AAA * 1.BBBBBBB. Więc zrób przesunięcie w prawo, a ten wykładnik zmniejszy się o połowę.

W pierwotnym odwrotnym pierwiastku kwadratowym liczba ta została odjęta od stałej, aby uzyskać odwrotność. Po prostu dodaję to do stałej, ponieważ chcę bezpośrednio pierwiastka kwadratowego. Wartość stałej jest wybierana, aby dać odpowiedź, która jest najlepszym przybliżeniem pożądanej wartości.

Rzuć liczbę z powrotem na zmiennoprzecinkową.

Opcjonalnie można zastosować jedną lub dwie iteracje metody Newtona, aby poprawić wynik, ale nie zawracałem sobie głowy, ponieważ chciałem zobaczyć, jak blisko mogę się zbliżyć.

Zastosowane stałe wyglądają bardzo tajemniczo, ale poza pierwszymi kilkoma cyframi wartości nie są krytyczne. Znalazłem stałą metodą prób i błędów. Przestałem, gdy tylko dostałem wartość, która czasem była niedoceniana, a czasem przeceniana.

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

Wyniki

Rzutowanie jest konieczne tylko dlatego, że C nie pozwala na wykonywanie operacji przesunięcia bitów na liczbach zmiennoprzecinkowych, więc jedynymi prawdziwymi operacjami są przesunięcie bitów i dodanie. Nie użyłem ani jednej iteracji metody Newtona, aby poprawić wynik, więc precyzja jest niezwykła. Nauczyciel OP będzie pod wrażeniem szybkości metody, która (szczerze mówiąc) jest wystarczająco dokładna do wielu celów!

mi

Uwaga: działa to tylko na moim komputerze, ponieważ podstawowy sprzęt nie przechowuje liczb w formacie binarnym, ale w bazie e, tak że to, co wygląda jak 10reprezentuje e, 100reprezentuje e ^e i tak dalej. W ten sposób to, co można nazwać na maszynie binarnej przesunięciem bitów w lewo, wykonuje x => e ^x , a to, co można nazwać na maszynie binarnej przesunięciem bitów w prawo, wykonuje x => ln x. Oczywiście trudno jest przedstawić swoje podstawowe liczby na tym bardzo ograniczonym, skoncentrowanym na binarnie medium internetowym, ale robię co w mojej mocy.

Składnia E jest niezwykle podobna do C / C ++, więc powinna być łatwa do zrozumienia dla większości ludzi.

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

JavaScript / HTML / CSS

Myślałem o użyciu jQuery i identyfikatorów do trollowania trochę więcej, ale wolę waniliowe js.

Wynik nie jest idealnie precyzyjny, ale działa!

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]

Odczytaj wartość swojej odpowiedzi z osi współrzędnych.

100% czystej bash (na podstawie liczb całkowitych)

Z prezentacją ascii-art:

Ten idealny pierwiastek musi być uzyskany w trybie bash za pomocą sourcepolecenia

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}",$'!     !',+-----+};}

Stara (tę wersję można po prostu wkleić w dowolnym terminalu konsoli)

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',+-----+}
}

Będzie działać jak:

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

Uwaga: pierwiastek jest kwadratowy !!

Jawa

Dzięki, dla ggmx za kod generujący n cyfr pi w Javie .

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

Nie miałem ochoty implementować danych wejściowych. Aby przetestować zmianę kodu sqrtThisi expectedPercision.

Oto jak działa kod. Po pierwsze, uzyskanie katalogu głównego sqrt dla liczby całkowitej jest trywialne, więc nie miałem ochoty go wdrożyć i zamiast tego użyłem javas wbudowanych w sqrt fcn. Reszta kodu jest jednak w 100% legalna.

Podstawowa idea, ponieważ pi jest nieskończoną długą, nie powtarzającą się liczbą dziesiętną, wszystkie sekwencje liczb muszą się w nim znajdować (czytaj edytuj). Dlatego twoja odpowiedź jest w pi! W związku z tym możemy po prostu zastosować wyszukiwanie wyrażeń regularnych na pi szukając odpowiedzi. Jeśli nie jesteśmy w stanie znaleźć dobrej odpowiedzi, podwoimy rozmiar pi, którego szukamy!

To naprawdę łatwe, w rzeczywistości można powiedzieć, że to tak proste jak pi :)

Nie udowodniono, że Edit Pi zawiera w sobie każdą sekwencję liczb skończonych. Fakt, że pi jest nieskończony i niepowtarzalny, nie jest wystarczającym dowodem na takie stwierdzenie, jak udowodnił Exelian. Jednak wielu matematyków uważa, że ​​pi zawiera każdą sekwencję liczb skończonych.

JQuery

ten jest najdokładniejszy (bonus: działa również na litery!)

Please enter the number : 

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

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

Oto skrzypce

C ++

To w końcu da ci pierwiastek kwadratowy.

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

Poprawiłem kod, aby lepiej odzwierciedlał pytanie. Dziękujemy za sugestie ... kod został zaktualizowany.

Pyton

To rozwiązanie:

1. jest niedeterministyczny i daje przybliżone odpowiedzi
2. wynosi O (N) i jest dość wolny, nawet dla niskiego N
3. opiera się na niejasnym związku matematycznym

Spojler:

Suma N niezależnych jednorodnych zmiennych losowych [-5, .5]. Oszacuj odchylenie standardowe, przyjmując średnią wartości bezwzględnych. Tak się składa, że ​​odchylenie standardowe jest proporcjonalne do sqrt (N), ponieważ N -> \ infty. 139 i 2,71828 to tylko czynniki skalujące, które kontrolują precyzję i zostały wybrane, aby wyglądać tajemniczo.

Kod:

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

Twoje pytanie się nie kompiluje, ponieważ umieściłeś! na końcu. C ++ nie lubię!
Oto prawidłowe pytanie dla kompilatora:

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

Och .. i plik 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

i 26317.def. To powinno już być obecne w twoim kompilatorze

#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 

Tak, ktoś może użyć -E, aby wypisać poprawną odpowiedź wstępnego przetwarzania, ale jeśli znasz -E, wiesz również, jak wykonać rootroot. : P Oto niektóre wstępnie przetworzone. Bardzo słabe minimalne rozwiązanie, brak kontroli granicznej, bez monitowania. TIL, że trygrafty są wstępnie przetwarzane.

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