Привіт, хлопці, для мого класу мені потрібно зробити корінь квадратного числа, але це не працює !! HELLPP!

Змагання:

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

Примітка. Це тролінг коду. Дайте "корисну" відповідь, щоб направити цього нового програміста на його шляху до успіху в програмуванні! Будь креативним!

Java

Ого, це складна проблема. Я ніколи раніше не робив квадратний корінь. Я взяв квадратне коріння, але ще цього не зробив. Не забудьте зробити так, щоб ваш код виглядав гарним для додаткового кредитування у ваших класах. Ось код, який робить квадратний корінь введеного числа:

       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.printи не друкувати java.lang.System.out.print. Вони друкують до внутрішнього класу. Перші два (які повинні друкувати рядки) нічого не роблять; другий:
• Виходи у вікно. Вибірка зразка - чи бачите ви квадратний корінь (вхід є 100) ?:
• Вікно не робить нічого закритого. Ні ALT-F4, не натискаючи кнопку закриття, ні іншим чином не роблячи щось, що зазвичай його закриває, не вдається.
• Вікно завжди поверх інших вікон. У поєднанні з тим, що він максимізований, для його закриття потрібно трохи подумати.
• знаходить sqrt за цілим числом ADDITION від числа, поки ми не досягнемо правильного числа. Це займає багато часу, оскільки ми чекаємо цілої завершення. Через це фактично потрібно менше часу для більшої кількості. Для виведення зразка знадобилося 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;
}

Це повторюється через кожне можливе значення double(за unionдопомогою того, long longщо має той самий розмір бітів, оскільки немає хорошого способу насправді повторити їх за допомогою подвійних значень як фактичних подвійних), поки не знайде того, чий квадрат є n.

Пітон 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!

Тролі:
* Питання в зборах. Ніхто не пише в збірці
* Бути O (1) не робить це швидко. На мою систему потрібно приблизно 90 секунд, щоб виконати sqrt на будь-якому номері.
* Місця стрибків з жорстким кодом.
* Немає кадру стека
* Синтаксис AT&T. Деякі люди вже вважають це тролем.

Пояснення: Якщо ви подивитеся на специфікацію плавців IEEE, ви можете помітити, що двійкові представлення парних пар впорядковані, тобто, якщо a > bтоді *(long long *)&a > *(long long *)&b.
Ми використовуємо цей трюк і повторюємо над високим словом відповіді кожен раз, коли FPU-це відміряє його і виконує порівняння CPU з аргументом.
Тоді ми перебираємо і нижній меч.
Це знаходить нам точно точну відповідь у майже постійній кількості обчислень.

Пітон

Напишіть функцію або програму, яка «зробить корінь квадратного числа».

Якщо це дозволено у вашому класі, ви можете використовувати тут складну математичну бібліотеку як помічник, встановіть його, виконавши команду:

pip install num2words

Тоді ви просто запустите щось подібне до цього сценарію 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')

(Переконайтеся, що ви працюєте з адміністратором привілеїв)

С

Очевидно, це найкращий спосіб. Це так швидко, як ви можете собі уявити, подивившись на код. Використовуючи 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];
}

С

Трюки та магія змусять його працювати.

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

Це швидкий зворотний квадратний корінь .

Пітон 3

Ви, хлопці, все робите неправильно. Будь-хто може бачити, що квадратний корінь з 20 не є 4.47213595499958 або навіть √20. Це рішення переміщує складне завдання обчислення квадратного кореня на модуль, призначений для цієї мети.

Одним із таких модулів є симфія, яка забезпечує математику квадратних коренів. На відміну від інших рішень тут, насправді все робить правильно. Він навіть передбачає, що sqrt (-1) - це я - жодне з рішень тут не може цього вирішити.

І ось модульний код, який виглядає як хороші програми. Функцій повинно бути якомога менше, якщо їх немає, це означає, що ви пишете жахливі програми. Також програми повинні мати багато коментарів.

#!/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 для представлення функції квадратного кореня.

У цьому прикладі я буду використовувати ᕂ.

Після того, як у нас з'явиться дійсний символ, ми можемо використовувати об'єкт Math для створення функції квадратного кореня.

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   

LaTeX

Рішення для цього досить складне і дуже складне, тому візьміть свою каву. Проблема полягає в тому, що залежно від того, яке число ви хочете, прямокутна коду істотно змінюється. Я покажу вам проблему. Скажімо, 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як завжди гарний витвір мистецтва, так що речі не набридають швидко.

Хаскелл

Я перестав довіряти комп’ютерам, коли вперше почув про помилки з плаваючою комою. Я маю на увазі, серйозно, якщо навіть 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

Точності повинно вистачити для більшості застосувань.

Java

Найточніший спосіб це зробити ітерацію. Спочатку integerперебирайте цикл на s, поки ви не переходите через ціль, а потім переходите на 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);. Гадаю, що переглядає (до) мільярд подвійних знань, потрібно певний час.

Javascript

Ці магічні константи можна використовувати для обчислення квадратного кореня числа за допомогою алфавіту:

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 немає вбудованої функції ...
Виглядає як робота для вирішувача Ньютона-Рафсона.

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, є побітним XOR .

Python 2.7

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

Пояснення

Цитуючи

Вікіпедія - квадратний корінь

У математиці квадратний корінь числа 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, cookie або навіть зберегти в сеансі.

Якщо ви вводите лише число, воно заплутається і дає обчислений результат, що діє для (майже) КОЖНОЇ мови будь-коли!

С

Це краще, ніж всі інші 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 (ака 0, 4, 9, 16, 25, 36, 49, 64 та 81), оскільки відповідь може бути лише 1 цифрою (потрапляє у звороту область після того, як відповідь буде надрукована абсолютно без причин , наприклад, √1024повертає 3√1024 = ∓32, що просто неправильно)

C ++

на основі http://en.wikipedia.org/wiki/Fast_inverse_square_root та відповіді @ snack.

За винятком того, що замість болтів на шляху перетворення 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 не дозволить вам робити операції з переміщенням на бічній плавці, тому єдиними реальними операціями є біт-зміна та додавання. Я не використав жодної ітерації методу Ньютона, щоб поліпшити результат, тому точність чудова. Вчитель ОП буде вражений швидкістю методу, який (відверто кажучи) досить точний для багатьох цілей!

Е

Примітка. Це працює лише на моєму комп’ютері, оскільки базове обладнання не зберігає числа в двійковій, а в базовій e, таким чином, що те, що відображається як 10e, 100являє собою ^e , тощо. Таким чином, те, що ви могли б на двійковій машині викликати біт-зсув вліво, виконує x => e ^x , а те, що ви могли б на двійковій машині викликати бітовим зсувом вправо, виконує x => ln x. Очевидно, що важко представити її основні номери на цьому дуже обмеженому, бінарно-орієнтованому Інтернет-носії, але я роблю все можливе.

Синтаксис Е надзвичайно схожий на C / C ++, тому більшості людей це може бути легко зрозуміти.

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

JavaScript / HTML / CSS

Я думав про те, щоб скористатися jQuery та id для тролінгу трохи більше, але я вважаю за краще ванільний 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;
}

Геогебра

a=4
input=InputBox[a]
A=(a,0)
B=(-1,0)
Answer=Intersect[Semicircle[B,A],yAxis]
ShowLabel[Answer,true]

Прочитайте значення своєї відповіді з осі координат.

100% чистий баш (на основі цілого числа)

З презентацією ascii-art:

Цей ідеальний кореневий квадрат повинен бути використаний у башті за допомогою 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!
                                   !     !
                                   +-----+

Зверніть увагу: корінь квадратний !!

Java

Дякую, ggmx's за код для створення 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);
    }
}

Не схоже на те, щоб реалізувати вклад. Для перевірки зміни коду sqrtThisта expectedPercision.

Ось як працює код. По-перше, отримання кореня sqrt для цілого числа є тривіальним, тому я не відчував, як це реалізувати, і натомість використовував javas, побудований у sqrt fcn. Решта коду є 100% законною.

Основна ідея, оскільки pi - нескінченне довге десяткове число, яке не повторюється, всі послідовності чисел повинні виникати всередині нього (читати редагувати). Для цього ваша відповідь всередині pi !! Як такий, ми можемо просто застосувати регекс-пошук для пі-пошуку для вас відповіді. Якщо нам не вдасться знайти хорошої відповіді, ми просто подвоїмо розмір пі, який ми шукаємо!

Це дуже просто, адже можна сказати, що це так просто, як пі :)

В
редакторі Edit 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. спирається на незрозумілі математичні відносини

Спойлер:

Сума 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 для виведення правильної відповіді на попередню обробку, але якщо ви знаєте -E, ви також знаєте, як правильно встановити корінь. : P Ось деякі попередньо оброблені. Дуже бідне мінімальне рішення, без обмеженої перевірки, без підказки. Якщо цей триграф попередньо оброблений.

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