หวัดดีสำหรับชั้นเรียนของฉันฉันต้องสร้างสแควร์รูท แต่มันใช้งานไม่ได้ HELLPP!

ความท้าทาย:

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

หมายเหตุ: นี่คือการหมุนรหัส ให้คำตอบ "มีประโยชน์" เพื่อเป็นแนวทางให้โปรแกรมเมอร์คนใหม่ในแนวทางของเขา / เธอสู่การประสบความสำเร็จในการเขียนโปรแกรม! มีความคิดสร้างสรรค์!

ชวา

ว้าวนี่เป็นปัญหาที่ซับซ้อน ฉันไม่เคยทำสแควร์รูทมาก่อน ฉันได้รากที่สอง แต่ฉันยังไม่ได้ทำ อย่าลืมที่จะทำให้รหัสของคุณดูน่ารักสำหรับเครดิตพิเศษในชั้นเรียนของคุณ นี่คือรหัสที่ทำให้รากที่สองของตัวเลขที่ป้อน:

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

โทรลล์:

• เห็นได้ชัดว่ารหัสนั้นงงงวย
  • ฉันจะได้รับคะแนนโบนัสสำหรับศิลปะในรหัสหรือไม่
• System.out.prints java.lang.System.out.printไม่พิมพ์ไป พวกเขาพิมพ์ไปที่ชั้นใน สองคนแรก (ซึ่งควรจะพิมพ์สตริง) ไม่ได้ทำอะไรเลย ที่สอง:
• ส่งออกไปยังหน้าต่าง เอาต์พุตตัวอย่าง - คุณเห็นสแควร์รูท (อินพุตคือ100) หรือไม่:
• หน้าต่างไม่ทำอะไรเลยเมื่อปิด ทั้ง ALT-F4 คลิกปุ่มปิดหรือทำสิ่งที่ปกติจะปิดมันล้มเหลว
• หน้าต่างจะอยู่ด้านบนสุดของหน้าต่างอื่นเสมอ เมื่อรวมกับความจริงที่ว่ามันถูกขยายให้ใหญ่สุดสิ่งนี้ต้องใช้ความคิดเล็กน้อยในการปิด
• ค้นหา sqrt ด้วยจำนวนเต็มเพิ่มจากจำนวนจนกว่าเราจะถึงจำนวนที่ถูกต้อง การดำเนินการนี้ใช้เวลานานเนื่องจากเรารอการคำนวณจำนวนเต็ม ด้วยเหตุนี้จึงใช้เวลาน้อยลงสำหรับจำนวนที่มากขึ้น สำหรับตัวอย่างผลลัพธ์มันใช้เวลา 20 วินาที
• 0ทำงานไม่ถูกต้องเมื่อเข้าเป็น ล้มเหลวโดยวง จำกัด เมื่อป้อนข้อมูลที่เป็นลบด้วยเหตุผลเดียวกันมันล้มเหลวโดยวง จำกัด 0เมื่อเข้าเป็น
• ฉันหมุนรอบตัวเองและใช้เวลาประมาณ 2 ชั่วโมงในการเข้ารหัสและจัดแนวมัน

C ++

ถ้าคุณไม่มีเส้นทางที่ดีกว่านี้จะมีวิธีแก้ปัญหาที่ดุร้ายอยู่เสมอ:

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

iterates นี้ผ่านทุกค่าเป็นไปได้ของdouble(โดยunionไอเอ็นจีด้วยlong longซึ่งเป็นขนาดบิตเดียวกันเนื่องจากไม่มีวิธีที่ดีจริงย้ำผ่านพวกเขาโดยใช้คู่เป็นคู่ที่เกิดขึ้นจริง) nจนกว่าจะพบใครมีตาราง

Python 3

รหัสง่ายๆนี้จะให้คำตอบที่ถูกต้อง :

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

เพียงพิมพ์√ตัวอักษรที่อยู่ด้านหน้าหมายเลขที่ป้อน

ใน Python 3 คุณสามารถทำสิ่งต่อไปนี้:

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

แก้ไขคำตอบนี้ ,

ใช้ C เพราะ C เร็วที่สุด

นั่นเป็นเพียงความผิดธรรมดา ทุกคนรู้ว่าสิ่งที่เร็วที่สุดคือ ASM

เพียว 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

ต่างจากคำตอบที่ชะลออื่น ๆ อันนี้มีความซับซ้อนของO (1)!
และแตกต่างจากคำตอบอื่น ๆ นี่คือความแม่นยำ 101% เพราะsqrt(0.5)มันให้0.70710678118655!

Trolls:
* การเขียนในการชุมนุม ไม่มีใครเขียนในชุดประกอบ
* การเป็น O (1) ไม่ได้ทำให้เร็ว ระบบของฉันใช้เวลาประมาณ 90 วินาทีในการแสดง sqrt บนหมายเลขใด ๆ
* ตำแหน่งการข้าม Hardcoded
* ไม่มีเฟรมสแต็ก
* ไวยากรณ์ AT&T บางคนคิดว่ามันเป็นการหมุนรอบแล้ว

คำอธิบาย: ถ้าคุณดูที่ IEEE ลอยสเปคที่คุณอาจสังเกตเห็นว่าของเลขฐานสองคู่จะได้รับคำสั่งว่าคือถ้าแล้วa > b เราใช้เคล็ดลับนี้และย้ำกว่าคำสำคัญที่สูงของคำตอบทุกครั้งที่ FPU ยกกำลังสองและดำเนินการเปรียบเทียบ CPU กับอาร์กิวเมนต์ จากนั้นเราก็วนซ้ำ dword ที่ต่ำกว่าด้วย นี่ทำให้เราได้คำตอบที่แม่นยำอย่างแม่นยำในการคำนวณจำนวนเกือบคงที่*(long long *)&a > *(long long *)&b

หลาม

เขียนฟังก์ชั่นหรือโปรแกรมที่จะ "ทำให้รากที่สองจำนวน"

หากได้รับอนุญาตในชั้นเรียนของคุณคุณสามารถใช้ห้องสมุดคณิตศาสตร์ที่ซับซ้อนเป็นผู้ช่วยที่นี่ติดตั้งโดยใช้คำสั่ง:

pip install num2words

จากนั้นคุณจะเรียกใช้บางอย่างเช่นสคริปต์หลามนี้:

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

(ตรวจสอบให้แน่ใจว่าคุณใช้งานด้วยสิทธิ์ของผู้ดูแลระบบ)

C

เห็นได้ชัดว่านี่เป็นวิธีที่ดีที่สุด มันเร็วเท่าที่คุณจะจินตนาการได้โดยดูที่โค้ด ใช้ C เนื่องจาก C เร็วที่สุดและปัญหานี้ต้องการวิธีแก้ปัญหาที่รวดเร็ว ฉันได้ทดสอบสิ่งนี้กับตัวเลขที่ฉันโปรดปรานเช่น 7, 13 และ 42 และดูเหมือนว่าจะใช้งานได้

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

เทคนิคและเวทมนตร์จะทำให้มันใช้งานได้

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

มันรวดเร็วผกผันราก

Python 3

พวกคุณทำผิดทุกอย่าง ทุกคนสามารถเห็นว่าสแควร์รูทของ 20 ไม่ใช่ 4.47213595499958 หรือแม้กระทั่ง√20 โซลูชันนี้ย้ายงานที่ยากของการคำนวณสแควร์รูทไปยังโมดูลที่มีไว้สำหรับวัตถุประสงค์นี้

หนึ่งในโมดูลดังกล่าวคือ sympy ซึ่งให้การคำนวณทางคณิตศาสตร์รากที่สอง แตกต่างจากโซลูชันอื่นที่นี่จริง ๆ แล้วมันทำอย่างถูกต้อง มันยังอนุมานว่า sqrt (-1) คือ I - ไม่มีวิธีแก้ปัญหาที่นี่ที่สามารถแก้ไขได้

และนี่คือรหัสมอดูลาร์ซึ่งเป็นโปรแกรมที่มีลักษณะอย่างไร ฟังก์ชั่นควรมีขนาดเล็กที่สุดเท่าที่จะเป็นไปได้หากไม่ใช่นั่นหมายความว่าคุณเขียนโปรแกรมที่น่ากลัว นอกจากนี้โปรแกรมควรมีความคิดเห็นมากมาย

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

และนี่คือตัวอย่างของการทำงานของโปรแกรมนี้

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

JavaScript

น่าเสียดายที่ JavaScript ไม่รองรับสัญลักษณ์สแควร์รูทสำหรับชื่อฟังก์ชัน แต่เราสามารถใช้ตัวอักษร Unicode อื่น ๆ แทนฟังก์ชันสแควร์รูท

ᕂในตัวอย่างนี้ผมจะใช้

เมื่อเรามีสัญลักษณ์ที่ถูกต้องที่จะใช้เราสามารถใช้วัตถุคณิตศาสตร์เพื่อสร้างฟังก์ชั่นสแควร์รูท

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

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

มันง่ายมาก! :)

แน่นอนว่ามันจะง่ายกว่าที่จะใช้งาน var ᕂ = Math.sqrt;

จูเลีย

เห็นได้ชัดว่าวิธีที่ดีที่สุดที่จะทำมันใช้ซีรีย์รากที่สองของ Taylor:

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

ที่จริงแล้วส่งออกค่าที่แม่นยำมาก:

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

แต่แน่นอนว่ามันจะเป็นการประมาณ (และยังเป็นชุดคอนเวอร์เจนซ์) มันไร้ประโยชน์สำหรับค่าที่ไม่ใกล้เคียงกับ 1:

julia> sqroot(0)  #what?
9.659961241569848

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

น้ำยาง

วิธีแก้ปัญหาสำหรับเรื่องนี้ค่อนข้างยากและซับซ้อนมากดังนั้นควรดื่มกาแฟของคุณ ปัญหาคือว่าขึ้นอยู่กับชนิดของหมายเลขที่คุณต้องการ squareroot ของรหัสการเปลี่ยนแปลงอย่างมีนัยสำคัญ ฉันจะแสดงปัญหาให้คุณ ให้บอกว่า9เป็นหมายเลขของคุณ จากนั้นโค้ดจะเป็นดังนี้:

\sqrt{9}

ตอนนี้สมมติว่านั่น1234321คือหมายเลขของคุณดูรหัส:

\sqrt{1234321}

สุดท้าย แต่อย่า0ท้ายสุดให้บอกว่าเบอร์ของคุณคืออะไร

\sqrt{0}

วิธีที่ดีในการแก้ไขปัญหานี้คือการเขียนโปรแกรมลงในOok!หรือPietต้องการให้หมายเลขของคุณและผลลัพธ์ออกLaTeX-sqrt-codeมา นี่เป็นตัวอย่างที่ง่ายมากOok!เพราะมันสามารถอ่านได้เพียงหนึ่งไบต์เท่านั้นและไม่ได้ตรวจสอบว่าไบต์นี้เป็นหมายเลขถูกกฎหมายหรือไม่ แต่ฉันคิดว่าคุณจะไปถึงจุดนั้น

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

เหมือนกันสำหรับPiet:

นี่จะเป็นวิธีที่มีประสิทธิภาพมากที่สุด ฉันขอแนะนำให้ใช้Pietเนื่องจากเป็นงานศิลปะที่สวยงามทุกครั้งดังนั้นสิ่งต่างๆจึงไม่น่าเบื่ออย่างรวดเร็ว

Haskell

ฉันหยุดไว้วางใจคอมพิวเตอร์เมื่อครั้งแรกที่ฉันได้ยินเกี่ยวกับข้อผิดพลาดของจุดลอย ฉันหมายถึงอย่างจริงจังหาก Google ไม่สามารถควบคุมพวกมันได้ใครจะทำได้

ทางออกที่ดีที่สุดของเราคือการหาทางออกที่เกี่ยวข้องกับจำนวนเต็มเท่านั้น โชคดีที่เป็นเรื่องง่ายเนื่องจากเราสามารถตรวจสอบตัวเลขทั้งหมดได้เนื่องจากทุกช่วงเวลา [1..n] มีจำนวน จำกัด เท่านั้นไม่ชอบอึอล์ฟ -1 นี่คือตัวอย่างการใช้งานใน Haskell:

import Prelude hiding (sqrt)
import Data.List

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

ใช้งานได้อย่างมีเสน่ห์ลองดูสิ:

λ> sqrt 8
2

ความแม่นยำควรเพียงพอสำหรับการใช้งานส่วนใหญ่

ชวา

วิธีที่แม่นยำที่สุดในการทำเช่นนี้คือการย้ำ ก่อนอื่นวนซ้ำintegerจนกว่าคุณจะไปถึงเป้าหมายแล้วสลับไปที่doubles วิธีนี้มีข้อดีตรงที่ไม่เหมือนวิธีการ "ประมาณ" อื่น ๆ ที่คุณอาจเห็น คุณเสียสละความเร็วเพียงเล็กน้อย แต่สำหรับแอปพลิเคชั่นส่วนใหญ่นี่คือสิ่งที่คุณต้องการ

คุณสามารถแก้ไขคำตอบนี้ได้โดยขึ้นอยู่กับว่าคุณต้องการความแม่นยำเพียงใด แต่สิ่งนี้ควรทำงานอย่างน้อยเป็นพันล้าน:

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

ใช้เวลาประมาณ 3 วินาทีsqrt(99.9999998);สำหรับฉัน การวนซ้ำ (สูงถึง) หนึ่งพันล้านคู่ต้องใช้เวลาพอสมควร

จาวาสคริ

ค่าคงที่เวทมนตร์เหล่านี้สามารถใช้คำนวณรากที่สองของตัวเลขโดยใช้ตัวอักษร:

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

แบบทดสอบ:

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

ดูเหมือนว่าจะทำงานได้ดี ฉันสงสัยว่ามีวิธีที่สั้นกว่านี้ไหม?

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

JavaScript

ปัญหาที่ยากมาก!
ไม่มีฟังก์ชั่นในตัวสำหรับ JavaScript ใน ...
ดูเหมือนว่างานสำหรับตัวแก้ 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;
}

ตอนนี้คุณสามารถใช้ Math.sqrt

JavaScript / ActionScript

ไม่มีวิธีการคำนวณรากที่สองโดยตรงใน ActionScript หรือ JavaScript อย่างไรก็ตามมีวิธีแก้ปัญหา คุณสามารถหาสแควร์รูทของตัวเลขได้โดยการยกมันขึ้นสู่1/2อำนาจ

นี่คือลักษณะที่จะปรากฏใน JavaScript และ ActionScript 2:

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

และถึงแม้ว่าฟังก์ชั่นนี้ทำงานได้ดีใน ActionScript 3 แต่ฉันขอแนะนำให้ใช้ตัวแปรที่พิมพ์แล้วส่งคืนค่าเพื่อความชัดเจนและความน่าเชื่อถือ:

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

โทรลล์:

แม้ว่าสิ่งที่ผมพูดเกี่ยวกับnum^(1/2)ผลในรากที่ถูกต้องในคณิตศาสตร์สิ่งที่ผู้^ประกอบการจริงไม่ใน JavaScript และ ActionScript เป็นBitwise แฮคเกอร์

Python 2.7

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

คำอธิบาย

quoting

Wikipedia - รากที่สอง

ในคณิตศาสตร์รากที่สองของตัวเลข a คือตัวเลข y เช่น y ² = a

กล่าวอีกนัยหนึ่งทุกตัวเลขคือสแควร์รูทของจำนวนอื่น

บันทึก

คำถามนี้สำหรับฉันมีลักษณะคล้ายกับปริศนาที่รู้จักกันดีวิธีทำให้เส้นสั้นลงโดยไม่ต้องถูหรือตัด

PHP (และอื่น ๆ ):

เนื่องจากวิธีการอธิบายคำถามไม่ได้หมายความว่าเราจำเป็นต้องคำนวณจริงนี่คือวิธีแก้ปัญหาของฉัน:

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

มันมีวิธีในการคำนวณรากที่สองอย่างถูกต้องในหลายภาษา

รายการภาษาสามารถขยายได้

ค่าสามารถส่งผ่าน POST, GET, คุกกี้หรือแม้กระทั่งการบันทึกในเซสชั่น

ถ้าคุณให้เฉพาะตัวเลขมันจะสับสนและให้ผลการคำนวณที่ถูกต้องสำหรับ (เกือบ) ทุกภาษาเลยทีเดียว!

C

นี่เป็นคำตอบที่ดีกว่าคำตอบอื่น ๆ ทั้งหมด 27 ข้อเพราะนั่นไม่ถูกต้องทั้งหมด ถูกต้องพวกเขาให้คำตอบเพียงคำตอบเดียวเมื่อควรมี 2 ข้อนี้ไม่ได้พยายามตอบว่ามันผิดหรือเปล่ามันแค่ยอมแพ้และปัดเศษ

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

รหัสหลอก:

• การตั้งชื่อที่แปลกมาก
• forวนรอบ
• ใส่เครื่องหมายอัฒภาคไว้ที่จุดเริ่มต้นของบรรทัด
• #defineใช้เพื่อเพิ่มความสามารถในการอ่านที่ลดลง
• ข้อความการใช้งานที่ไร้ประโยชน์
• ลบหรือบวกแทนบวกหรือลบ
• ส่งคืนสตริง
• ส่งคืนตัวแปรโลคัล
• คำเตือนของคอมไพเลอร์ 4 รายการ (ผลลัพธ์นิพจน์ที่ไม่ได้ใช้ 2 รายการส่งคืนที่อยู่ตัวแปรโลคัลไม่ใช่ตัวอักษรสตริงใน printf)
• ใช้ได้เฉพาะกับสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบที่ไม่เป็นลบ <100 (aka 0, 4, 9, 16, 25, 36, 49, 64 และ 81) เนื่องจากคำตอบสามารถเป็นตัวเลข 1 หลักเท่านั้น ดังนั้นตัวอย่างเช่น√1024ส่งคืน3√1024 = ∓32ซึ่งเป็นเพียงผิดธรรมดา)

C ++

อ้างอิงจากhttp://en.wikipedia.org/wiki/Fast_inverse_square_rootและ @ คำตอบของสแน็ค

ยกเว้นแทนที่จะใช้วิธีแปลง x ^ (- 0.5) เป็น x ^ (0.5) ฉันปรับเปลี่ยนอัลกอริทึมให้ทำโดยตรง

ขั้นตอนวิธี

โยนหมายเลขจุดลอยตัว (ในกรณีนี้เป็นสองเท่า) เป็นจำนวนเต็ม (ในกรณีนี้ยาวนาน)

บิตแรก ๆ ของเลขทศนิยมคือเลขชี้กำลัง: นั่นคือตัวเลขจะถูกเก็บไว้เป็น 2 ^ AAA * 1.BBBBBBB ดังนั้นจึงมีการขอสงวนสิทธิ์และเลขชี้กำลังนี้ลดลงครึ่งหนึ่ง

ในรากที่สองที่ผกผันดั้งเดิมจำนวนนี้จะถูกลบออกจากค่าคงที่เพื่อให้ส่วนกลับซึ่งกันและกัน ฉันแค่เพิ่มลงในค่าคงที่เพราะฉันต้องการสแควร์รูทโดยตรง ค่าของค่าคงที่ถูกเลือกเพื่อให้คำตอบซึ่งเป็นการประมาณค่าที่ดีที่สุดกับค่าที่ต้องการ

ร่ายตัวเลขกลับไปยังจุดลอย

อีกทางเลือกหนึ่งหรือสองวิธีซ้ำของวิธีการของนิวตันสามารถนำมาใช้เพื่อปรับปรุงผล แต่ฉันก็ไม่ได้กังวลเพราะฉันต้องการที่จะดูว่าฉันจะได้ใกล้ชิดโดยไม่ต้อง

ค่าคงที่ที่ใช้ดูลึกลับมาก แต่นอกเหนือจากตัวเลขสองสามตัวแรกค่านั้นไม่สำคัญ ฉันพบค่าคงที่จากการลองผิดลองถูก ฉันหยุดทันทีที่ฉันได้รับค่าที่บางครั้งประเมินค่าต่ำไปและบางครั้งก็ประเมินค่าสูงไป

#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 จะไม่อนุญาตให้คุณทำการบิตบิทการดำเนินการบนโฟลว์ดังนั้นการดำเนินการจริงเท่านั้นคือบิทชิพและการเพิ่ม ฉันไม่ได้ใช้วิธีซ้ำของวิธีการของนิวตันเพื่อปรับปรุงผลลัพธ์ดังนั้นความแม่นยำจึงน่าทึ่ง ครูของ OP จะประทับใจกับความเร็วของวิธีการที่ (ตรงไปตรง) มีความแม่นยำเพียงพอสำหรับวัตถุประสงค์มากมาย!

E

หมายเหตุ: สิ่งนี้ใช้ได้กับคอมพิวเตอร์ของฉันเท่านั้นเนื่องจากฮาร์ดแวร์ที่อยู่ภายในไม่ได้จัดเก็บตัวเลขในระบบเลขฐานสอง แต่ในฐาน e เช่นที่ปรากฏเป็น10ตัวแทน e 100หมายถึง e ^eและอื่น ๆ ด้วยวิธีนี้สิ่งที่คุณอาจใช้กับเครื่องเลขฐานสองจะเรียกบิต - กะไปทางซ้ายทำการ x => e ^xและสิ่งที่คุณอาจอยู่บนเครื่องไบนารีเรียกบิต - กะไปทางขวาจะทำการ x => ln x เห็นได้ชัดว่ามันเป็นเรื่องยากที่จะแสดงตัวเลขพื้นฐานของมันบนสื่ออินเทอร์เน็ตที่มี จำกัด และมีศูนย์กลางเป็นจำนวนมาก แต่ฉันพยายามอย่างเต็มที่

ไวยากรณ์ของ E นั้นคล้ายคลึงกับ C / C ++ อย่างน่าทึ่งดังนั้นสิ่งนี้จึงเป็นเรื่องง่ายสำหรับคนส่วนใหญ่ที่จะเข้าใจ

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

JavaScript / HTML / CSS

ฉันคิดถึงการใช้ jQuery และรหัสเพื่อหมุนรอบอีกเล็กน้อย แต่ฉันชอบวานิลลา js

ผลลัพธ์ไม่แม่นยำอย่างสมบูรณ์ แต่ใช้งานได้!

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]

อ่านค่าของคำตอบของคุณจากแกนพิกัด

ทุบตีบริสุทธิ์ 100% (ตามจำนวนเต็ม)

ด้วยการนำเสนองาน ASCII:

รูทสแควร์ที่สมบูรณ์แบบนี้จะต้องมีที่มาในทุบตีโดยใช้sourceคำสั่ง

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

เก่า (รุ่นนี้สามารถวางลงในคอนโซลเทอร์มินัลใดก็ได้)

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

จะทำงานเช่น:

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

โปรดทราบ: รูทเป็นรูปสี่เหลี่ยม !!

ชวา

ขอบคุณเพื่อggmx สำหรับรหัสในการสร้าง n ตัวเลขของปี่ใน 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);
    }
}

ไม่รู้สึกเหมือนกำลังใช้อินพุต ในการทดสอบการเปลี่ยนแปลงรหัสและsqrtThisexpectedPercision

นี่คือวิธีการทำงานของรหัส ประการแรกการรับรูท sqrt สำหรับจำนวนเต็มนั้นเป็นเรื่องเล็กน้อยดังนั้นฉันจึงไม่รู้สึกอยากจะใช้มันและใช้ javas ที่สร้างขึ้นใน sqrt fcn แทน ส่วนที่เหลือของรหัสนั้นถูกต้อง 100%

แนวคิดพื้นฐาน เนื่องจาก pi เป็นจำนวนทศนิยมที่ไม่ซ้ำที่ไม่ซ้ำกันยาวลำดับตัวเลขทั้งหมดจึงต้องเกิดขึ้นภายใน (อ่านแก้ไข) ดังนั้นคำตอบของคุณอยู่ใน pi !! ด้วยเหตุนี้เราจึงสามารถใช้การค้นหา regex กับคำตอบการค้นหา pi ของคุณ หากเราไม่สามารถหาคำตอบที่ดีได้เราก็จะเพิ่มขนาดของ pi ที่เราค้นหาเป็นสองเท่า!

มันง่ายจริงๆอันที่จริงคนเราสามารถพูดได้ว่ามันง่ายเหมือน pi :)

Edit
Pi ไม่ได้รับการพิสูจน์ว่ามีทุกลำดับของตัวเลขที่ จำกัด ภายใน ความจริงที่ว่า pi นั้นไม่มีที่สิ้นสุดและไม่ทำซ้ำนั้นไม่เพียงพอสำหรับการพิสูจน์เช่นข้อความที่พิสูจน์โดย Exelian อย่างไรก็ตามนักคณิตศาสตร์หลายคนเชื่อว่า pi มีลำดับตัวเลขที่แน่นอนทุกลำดับ

JQuery

อันนี้ถูกต้องที่สุด (โบนัส: ใช้ได้กับตัวอักษรด้วย!)

Please enter the number : 

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

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

นี่คือซอ

C ++

ในที่สุดคุณจะได้รับสแควร์รูท

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

ฉันแก้ไขรหัสเพื่อสะท้อนคำถามได้ดีขึ้น ขอบคุณสำหรับคำแนะนำของคุณ ... มีการอัปเดตรหัส

หลาม

วิธีนี้:

1. ไม่ได้กำหนดขึ้นและให้คำตอบโดยประมาณ
2. คือ O (N) และค่อนข้างช้าแม้สำหรับ N ต่ำ
3. อาศัยความสัมพันธ์ทางคณิตศาสตร์ที่ไม่ชัดเจน

สปอยเลอร์:

ชุดสุ่มอิสระ Sum N [-.5, .5] ประมาณค่าเบี่ยงเบนมาตรฐานโดยหาค่าเฉลี่ยของค่าสัมบูรณ์ เมื่อมันเกิดขึ้นค่าเบี่ยงเบนมาตรฐานจะแปรผันตาม sqrt (N) เท่ากับ N -> \ infty 139 และ 2.71828 เป็นเพียงตัวประกอบสเกลที่ควบคุมความแม่นยำและพวกเขาถูกเลือกให้ดูลึกลับ

รหัส:

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 ++ ไม่ชอบ!
นี่คือคำถามที่ถูกต้องสำหรับคอมไพเลอร์:

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

โอ้ .. และไฟล์ทำ

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

และ 26317.def สิ่งนี้ควรมีอยู่ในคอมไพเลอร์ของคุณ

#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 

ใช่มีคนสามารถใช้ -E เพื่อเอาท์พุทคำตอบ preprocess ที่ถูกต้อง แต่ถ้าคุณรู้ว่า -E คุณก็รู้วิธี squareroot : P นี่คือบางส่วนของการประมวลผลล่วงหน้า โซลูชันขั้นต่ำที่แย่มากไม่มีการตรวจสอบที่ถูกผูกไว้ไม่มีการแจ้งเตือน TIL ที่ประมวลผลล่วงหน้าจะถูกประมวลผลล่วงหน้า

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