Xin chào các bạn, đối với lớp học của tôi, tôi cần phải tạo một số căn bậc hai nhưng nó không hoạt động !! HELLPP!

Các thách thức:

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

Lưu ý: Đây là mã trolling. Đưa ra câu trả lời "hữu ích" để hướng dẫn lập trình viên mới này trên con đường lập trình thành công của anh ấy / cô ấy! Sáng tạo!

Java

Wow, đây là một vấn đề phức tạp. Tôi chưa bao giờ thực hiện một căn bậc hai trước đây. Tôi đã lấy căn bậc hai, nhưng tôi đã không làm một. Đừng quên làm cho mã của bạn trông đẹp mắt để có thêm tín dụng trong các lớp học của bạn. Đây là mã tạo ra một căn bậc hai của một số được nhập vào:

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

Quỷ dữ:

• Rõ ràng, mã bị xáo trộn.
  • Tôi có nhận được điểm thưởng cho nghệ thuật trong mã không?
• Các System.out.prints không in ra java.lang.System.out.print. Họ in ra một lớp bên trong. Hai cái đầu tiên (được cho là in chuỗi) không làm gì cả; cái thứ hai:
• Đầu ra cho một cửa sổ. Đầu ra mẫu - bạn có thấy căn bậc hai (đầu vào là 100) không?:
• Cửa sổ không có gì đóng. Không ALT-F4, nhấp vào nút đóng, hoặc nếu không làm điều gì đó thường đóng nó sẽ thất bại.
• Cửa sổ luôn ở trên cùng của các cửa sổ khác. Kết hợp với thực tế là nó được tối đa hóa, điều này đòi hỏi một chút suy nghĩ để đóng nó.
• tìm sqrt theo số nguyên THÊM từ số cho đến khi chúng ta đạt được số chính xác. Điều này mất một thời gian dài kể từ khi chúng tôi chờ đợi số nguyên bao quanh. Bởi vì điều này, nó thực sự mất ít thời gian hơn cho số lượng lớn hơn. Đối với đầu ra mẫu, phải mất 20 giây.
• Không hoạt động đúng khi đầu vào là 0. Thất bại bởi vòng lặp vô hạn khi đầu vào âm với cùng lý do nó bị lỗi bởi vòng lặp vô hạn khi đầu vào là 0.
• Tôi đã tự troll mình và dành ~ 2 giờ để viết mã này và sắp xếp nó.

C ++

Chà, nếu bạn không có con đường nào tốt hơn, luôn có giải pháp vũ phu:

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

Điều này lặp đi lặp lại qua mọi giá trị có thể có của một double(bằng cách nhập unionnó với long longcùng một kích thước bit, vì không có cách nào tốt để thực sự lặp lại thông qua chúng bằng cách nhân đôi như thực tế) cho đến khi tìm thấy một hình vuông có kích thước gấp đôi n.

Con trăn 3

Mã đơn giản này sẽ đưa ra một câu trả lời chính xác :

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

Nó chỉ in một √ký tự ở phía trước số đã nhập.

Trong Python 3, bạn có thể làm như sau:

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

Sửa chữa câu trả lời này ,

Sử dụng C, vì C là nhanh nhất

Điều đó hoàn toàn sai. Mọi người đều biết rằng người nhanh nhất là ASM.

Tinh khiết x86_64!

.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

Không giống như các câu trả lời chậm lại khác, câu trả lời này có độ phức tạp là O (1)!
Và cũng không giống như các câu trả lời khác, điều này là chính xác 101%, vì sqrt(0.5)nó mang lại 0.70710678118655!

Troll:
* Viết trong hội đồng. Không ai viết trong hội đồng
* Là O (1) không làm cho nó nhanh. Phải mất khoảng 90 giây trên hệ thống của tôi để thực hiện sqrt trên bất kỳ số nào.
* Vị trí nhảy mã hóa.
* Không có khung ngăn xếp
* Cú pháp AT & T. Một số người coi đó là một troll đã.

Giải thích: Nếu bạn xem thông số kỹ thuật nổi của IEEE, bạn có thể nhận thấy rằng các biểu diễn nhị phân của đôi được đặt hàng, nghĩa là, nếu a > bsau đó *(long long *)&a > *(long long *)&b.
Chúng tôi sử dụng thủ thuật này và lặp đi lặp lại từ ngữ cao của câu trả lời, mỗi khi FPU bình phương hóa nó và thực hiện so sánh CPU với đối số.
Sau đó, chúng tôi lặp đi lặp lại trên các từ thấp hơn.
Điều này tìm cho chúng tôi một câu trả lời chính xác trong một số lượng tính toán gần như không đổi.

Con trăn

Viết một hàm hoặc chương trình sẽ "tạo một số căn bậc hai".

Nếu nó được phép trong lớp của bạn, bạn có thể sử dụng một thư viện toán học phức tạp làm người trợ giúp ở đây, cài đặt nó bằng cách chạy lệnh:

pip install num2words

Sau đó, bạn sẽ chạy một cái gì đó như kịch bản python này:

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

(Hãy chắc chắn rằng bạn chạy nó với quyền riêng tư của quản trị viên)

C

Rõ ràng đây là cách tốt nhất. Nó nhanh như bạn có thể tưởng tượng bằng cách nhìn vào mã. Sử dụng C, vì C là nhanh nhất và vấn đề này đòi hỏi một giải pháp nhanh. Tôi đã thử nghiệm điều này cho các số yêu thích của tôi, như 7, 13 và 42, và nó dường như hoạt động.

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

Thủ thuật và phép thuật sẽ làm cho nó hoạt động.

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

Đó là căn bậc hai nghịch đảo nhanh .

Con trăn 3

Các bạn đang làm sai tất cả. Bất cứ ai cũng có thể thấy rằng căn bậc hai của 20 không phải là 4.47213595499958, hoặc thậm chí √20. Giải pháp này chuyển nhiệm vụ khó khăn là tính căn bậc hai cho mô đun dành cho mục đích này.

Một trong những mô-đun như vậy là sympy, cung cấp toán học căn bậc hai. Không giống như các giải pháp khác ở đây, nó thực sự làm mọi thứ đúng cách. Nó thậm chí còn giả định rằng sqrt (-1) là tôi - không có giải pháp nào ở đây có thể giải quyết điều đó.

Và đây là mã mô-đun, đó là cách các chương trình tốt trông như thế nào. Các chức năng nên càng nhỏ càng tốt, nếu không, điều đó có nghĩa là bạn viết các chương trình khủng khiếp. Ngoài ra, các chương trình nên có rất nhiều ý kiến.

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

Và đây là một ví dụ về chương trình này làm việc.

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

JavaScript

Thật không may, JavaScript không hỗ trợ biểu tượng căn bậc hai cho tên hàm. Thay vào đó, chúng ta có thể sử dụng một số ký tự bảng chữ cái Unicode khác để biểu diễn hàm căn bậc hai.

Trong ví dụ này tôi sẽ sử dụng ᕂ.

Khi chúng ta có một ký hiệu hợp lệ để sử dụng, chúng ta có thể sử dụng đối tượng Math để tạo hàm căn bậc hai.

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

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

Thật đơn giản! :)

Tất nhiên, sẽ dễ dàng hơn nếu chỉ sử dụng var ᕂ = Math.sqrt;

Julia

Rõ ràng là cách tốt nhất để làm điều đó, sử dụng Taylor Series bình phương gốc:

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

Điều đó thực sự tạo ra các giá trị rất chính xác:

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

Nhưng tất nhiên giống như một sự gần đúng của nó (và cũng là một chuỗi hội tụ), nó vô dụng đối với các giá trị không gần với 1:

julia> sqroot(0)  #what?
9.659961241569848

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

Mủ cao su

Giải pháp cho việc này khá khó khăn và rất phức tạp, vì vậy hãy uống cà phê của bạn. Vấn đề là, tùy thuộc vào loại số nào bạn muốn squareroot của mã thay đổi đáng kể. Tôi sẽ chỉ cho bạn vấn đề. Hãy nói rằng đó 9là số của bạn. Sau đó, mã sẽ trông như thế này:

\sqrt{9}

Bây giờ hãy nói rằng đó 1234321là số của bạn, hãy xem mã:

\sqrt{1234321}

Cuối cùng nhưng không kém phần quan trọng hãy nói số của bạn là 0.

\sqrt{0}

Một cách tốt để giải quyết điều này là viết một chương trình trong Ook!hoặc Piet, muốn số của bạn và xuất ra LaTeX-sqrt-codecho nó. Đây là một ví dụ rất đơn giản Ook!, vì nó chỉ có thể đọc một byte và không kiểm tra xem byte này có phải là số hợp pháp hay không, nhưng tôi nghĩ bạn sẽ hiểu rõ.

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

Tương tự cho Piet:

Đây sẽ là cách hiệu quả nhất. Tôi cũng sẽ đề nghị sử dụng Pietvì nó là một tác phẩm nghệ thuật tuyệt đẹp, vì vậy mọi thứ không trở nên nhàm chán nhanh chóng.

Haskell

Tôi đã ngừng tin tưởng máy tính khi lần đầu tiên tôi nghe về lỗi dấu phẩy động. Ý tôi là, nghiêm túc mà nói, ngay cả khi Google không thể kiểm soát chúng , thì ai có thể?

Vì vậy, đặt cược tốt nhất của chúng tôi là tìm một giải pháp chỉ liên quan đến số nguyên. May mắn thay, điều đó thật dễ dàng vì chúng ta chỉ có thể kiểm tra tất cả các con số, bởi vì mỗi khoảng [1..n] chỉ chứa một lượng hữu hạn của chúng, không giống như số thực crap aleph-1. Đây là một triển khai mẫu trong Haskell:

import Prelude hiding (sqrt)
import Data.List

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

Hoạt động như một bùa mê, kiểm tra xem nó:

λ> sqrt 8
2

Độ chính xác phải đủ cho hầu hết các ứng dụng.

Java

Cách chính xác nhất để làm điều này là lặp đi lặp lại. Đầu tiên, lặp theo integers cho đến khi bạn đi qua mục tiêu, sau đó chuyển sang doubles. Phương pháp này có ưu điểm là chính xác , không giống như các phương pháp "ước tính" khác mà bạn có thể thấy. Bạn hy sinh một chút tốc độ, nhưng đối với hầu hết các ứng dụng, đây chính xác là những gì bạn cần.

Bạn có thể sửa đổi câu trả lời này tùy thuộc vào mức độ chính xác mà bạn cần, nhưng điều này sẽ hoạt động ít nhất đến một phần tỷ:

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

Điều này mất khoảng 3 giây để làm sqrt(99.9999998);cho tôi. Tôi nghĩ rằng việc vượt qua (lên tới) một tỷ đôi sẽ mất một thời gian.

Javascript

Các hằng số ma thuật này có thể được sử dụng để tính căn bậc hai của một số bằng bảng chữ cái:

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

Các xét nghiệm:

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

Công việc có vẻ tốt. Tôi tự hỏi nếu có một cách ngắn hơn?

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

JavaScript

Vấn đề rất khó!
Không có chức năng tích hợp nào cho điều đó trong JavaScript ...
Trông giống như một công việc cho người giải 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;
}

Bây giờ bạn có thể sử dụng Math.sqrt

JavaScript / ActionScript

Không có cách nào để tính trực tiếp một căn bậc hai trong ActionScript hoặc JavaScript, tuy nhiên, có một cách giải quyết. Bạn có thể lấy căn bậc hai của một số bằng cách nâng nó lên 1/2lũy thừa.

Đây là giao diện của JavaScript và ActionScript 2:

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

Và mặc dù chức năng này cũng hoạt động tốt trong ActionScript 3, tôi sẽ khuyên bạn nên sử dụng các biến được nhập và trả về các giá trị cho rõ ràng và đáng tin cậy:

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

Các quỷ lùn:

Mặc dù những gì tôi đã nói về num^(1/2)việc tạo ra một căn bậc hai là chính xác trong toán học, những gì ^toán tử thực sự làm trong JavaScript và ActionScript là Bitwise XOR .

Python 2.7

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

Giải trình

Trích dẫn

Wikipedia - Căn bậc hai

Trong toán học, căn bậc hai của số a là số y sao cho y ² = a

Nói cách khác, mỗi số là một căn bậc hai của một số khác.

Ghi chú

Câu hỏi này đối với tôi trông giống như một câu đố nổi tiếng Làm thế nào để làm cho một dòng ngắn hơn mà không cần cọ xát hoặc cắt nó

PHP (và những người khác):

Vì cách mô tả câu hỏi không có nghĩa là chúng ta thực sự cần tính toán nó, đây là giải pháp của tôi:

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

Nó cung cấp một cách để tính toán chính xác căn bậc hai trong nhiều ngôn ngữ.

Danh sách các ngôn ngữ có thể được mở rộng.

Giá trị có thể được gửi qua POST, GET, cookie hoặc thậm chí được lưu trong phiên.

Nếu bạn chỉ cung cấp số, nó sẽ bị nhầm lẫn và đưa ra kết quả được tính toán, điều đó hợp lệ cho (gần như) MỌI ngôn ngữ!

C

Điều này tốt hơn tất cả 27 câu trả lời khác bởi vì tất cả đều không chính xác. Điều đó đúng, họ chỉ đưa ra một câu trả lời khi cần có 2. Câu trả lời này thậm chí không cố gắng trả lời nếu nó sai, nó chỉ bỏ cuộc và làm tròn xuống.

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

Mã trolling:

• Đặt tên rất kỳ quặc
• forlạm dụng vòng lặp
• Đặt dấu chấm phẩy ở đầu dòng, nơi chúng có nghĩa là
• #definesử dụng để tăng khả năng đọc
• tin nhắn sử dụng vô dụng
• trừ hoặc cộng thay vì cộng hoặc trừ
• trả về một chuỗi
• trả về một biến cục bộ
• 4 cảnh báo trình biên dịch (2 kết quả biểu thức không được sử dụng, trả về địa chỉ biến cục bộ, không phải là một chuỗi ký tự trong printf)
• chỉ hoạt động cho các ô vuông hoàn hảo không âm <100 (còn gọi là 0, 4, 9, 16, 25, 36, 49, 64 và 81) vì câu trả lời chỉ có thể là 1 chữ số (nhấn vào một khoảng lùi sau khi câu trả lời được in hoàn toàn không có lý do , vì vậy, ví dụ √1024trả về 3√1024 = ∓32, đó chỉ là sai)

C ++

dựa trên http://en.wikipedia.org/wiki/Fast_inverse_sapes_root và @ snack's answer.

Ngoại trừ thay vì bắt đầu một cách để chuyển đổi x ^ (- 0,5) thành x ^ (0,5) tôi đã sửa đổi thuật toán để thực hiện trực tiếp.

TIẾNG VIỆT

Truyền số dấu phẩy động (trong trường hợp này là gấp đôi) cho một số nguyên (trong trường hợp này dài.)

Một vài bit đầu tiên của số dấu phẩy động là số mũ: đó là số được lưu dưới dạng 2 ^ AAA * 1.BBBBBBB. Vì vậy, làm một quyền lợi và số mũ này được giảm một nửa.

Trong căn bậc hai nghịch đảo ban đầu , số này đã được trừ đi từ một hằng số để đưa ra đối ứng. Tôi chỉ cần thêm nó vào hằng số, vì tôi muốn căn bậc hai trực tiếp. Giá trị của hằng số được chọn để đưa ra câu trả lời gần đúng nhất với giá trị mong muốn.

Đúc số trở lại điểm nổi.

Tùy chọn, một hoặc hai lần lặp lại phương pháp của Newton có thể được sử dụng để cải thiện kết quả, nhưng tôi không bận tâm, vì tôi muốn xem tôi có thể tiến gần đến mức nào.

Các hằng số được sử dụng trông rất bí ẩn, nhưng ngoài vài chữ số đầu tiên, các giá trị không quan trọng. Tôi tìm thấy hằng số bằng cách thử và sai. Tôi dừng lại ngay khi tôi nhận được một giá trị đôi khi bị đánh giá thấp và đôi khi đánh giá quá cao.

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

Các kết quả

Việc truyền chỉ là cần thiết vì C sẽ không cho phép bạn thực hiện các thao tác bẻ khóa khi thả nổi, do đó, các hoạt động thực sự duy nhất là bithift và phép cộng. Tôi đã không sử dụng một lần lặp duy nhất của phương pháp Newton để cải thiện kết quả, vì vậy độ chính xác rất đáng chú ý. Giáo viên của OP sẽ rất ấn tượng với tốc độ của phương pháp mà (thật lòng mà nói) đủ chính xác cho nhiều mục đích!

E

Lưu ý: điều này chỉ hoạt động trên máy tính của tôi, vì phần cứng cơ bản không lưu trữ số ở dạng nhị phân mà ở cơ sở e, sao cho những gì xuất hiện dưới dạng 10đại diện cho e, 100đại diện cho e ^e , v.v. Theo cách này, những gì bạn có thể trên máy nhị phân gọi bit-shift sang trái thực hiện x => e ^x và những gì bạn có thể trên máy nhị phân gọi bit-shift sang phải thực hiện x => ln x. Rõ ràng, rất khó để thể hiện các con số cơ bản của nó trên phương tiện internet trung tâm nhị phân rất hạn chế này, nhưng tôi làm hết sức mình.

Cú pháp của E khá giống với cú pháp của C / C ++, vì vậy điều này sẽ dễ hiểu đối với hầu hết mọi người.

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

JavaScript / HTML / CSS

Tôi đã nghĩ về việc sử dụng jQuery và id để troll thêm một chút, nhưng tôi thích vanilla js hơn.

Kết quả không hoàn toàn chính xác, nhưng nó hoạt động!

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]

Đọc giá trị câu trả lời của bạn từ trục tọa độ.

Bash nguyên chất 100% (dựa trên số nguyên)

Với trình bày nghệ thuật ascii:

Hình vuông gốc hoàn hảo này phải có nguồn gốc trong bash bằng cách sử dụng sourcelệnh

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

Cũ (phiên bản này có thể được dán đơn giản vào bất kỳ thiết bị đầu cuối giao diện điều khiển nào)

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

Sẽ hoạt động như sau:

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

Xin lưu ý: gốc là hình vuông !!

Java

Cảm ơn, để ggmx's cho mã về việc tạo n chữ số pi trong 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);
    }
}

Không cảm thấy như thực hiện đầu vào. Để kiểm tra thay đổi mã sqrtThisvàexpectedPercision .

Đây là cách mã hoạt động. Đầu tiên, việc lấy gốc sqrt cho số nguyên là chuyện nhỏ nên tôi không cảm thấy muốn thực hiện điều đó và thay vào đó sử dụng javas được xây dựng trong sqrt fcn. Phần còn lại của mã là 100% hợp pháp mặc dù.

Ý tưởng cơ bản, vì pi là số thập phân không lặp lại dài vô hạn, tất cả các chuỗi số phải xảy ra trong nó (đọc chỉnh sửa). Do đó, câu trả lời của bạn là bên trong pi !! Như vậy, chúng tôi chỉ có thể áp dụng một tìm kiếm regex trên pi tìm kiếm cho bạn câu trả lời. Nếu chúng tôi không thể tìm thấy một câu trả lời tốt thì chúng tôi sẽ chỉ tăng gấp đôi kích thước của pi mà chúng tôi đang tìm kiếm!

Nó thực sự dễ dàng, trên thực tế người ta có thể nói rằng nó dễ như pi :)

Chỉnh sửa
Pi đã không được chứng minh là chứa mọi chuỗi số hữu hạn trong đó. Việc pi là vô hạn và không lặp lại là không đủ bằng chứng cho tuyên bố như đã được chứng minh bởi Exelian. Tuy nhiên, nhiều nhà toán học tin rằng pi chứa mọi dãy số hữu hạn.

JQuery

cái này là chính xác nhất (phần thưởng: cũng hoạt động cho các chữ cái!)

Please enter the number : 

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

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

Đây là một câu đố

C ++

Điều này cuối cùng sẽ giúp bạn có một căn bậc hai.

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

Tôi sửa mã để phản ánh câu hỏi tốt hơn. Cảm ơn bạn đã gợi ý ... mã được cập nhật.

Con trăn

Giải pháp này:

1. là không xác định và mang lại câu trả lời gần đúng
2. là O (N) và khá chậm, ngay cả đối với N thấp
3. dựa vào một mối quan hệ toán học tối nghĩa

Làm hỏng

Sum N thống nhất độc lập [-.5, .5] biến ngẫu nhiên. Ước tính độ lệch chuẩn bằng cách lấy giá trị trung bình của các giá trị tuyệt đối. Khi nó xảy ra, độ lệch chuẩn tỷ lệ với sqrt (N) là N -> \ infty. 139 và 2.71828 chỉ là các yếu tố tỷ lệ kiểm soát độ chính xác và chúng được chọn để trông bí ẩn.

Mã số:

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

Câu hỏi của bạn không được biên dịch bởi vì bạn đặt a! cuối cùng. C ++ không thích!
Đây là câu hỏi chính xác cho trình biên dịch:

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

Oh .. và các tập tin làm.

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

và 26317.def. Điều này đã có mặt trong trình biên dịch của bạn

#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 

Đúng, ai đó có thể sử dụng -E để đưa ra câu trả lời tiền xử lý chính xác, nhưng nếu bạn biết -E, bạn cũng biết cách squareroot. : P Đây là một số tiền xử lý. Giải pháp tối thiểu rất kém, không kiểm tra ràng buộc, không nhắc nhở. TIL rằng trecraft được xử lý trước.

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