Привет, ребята, для моего класса мне нужно сделать квадратный корень из числа, но это не работает !! 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.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;
}

Это перебирает все возможные значения a double(с unionпомощью a 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!

Тролли:
* Запись в сборе. Никто не пишет в сборке
* Быть O (1) не делает это быстро. В моей системе требуется примерно 90 секунд, чтобы выполнить sqrt для любого числа.
* Закодированные места прыжка.
* Нет стека кадра
* AT & T синтаксис. Некоторые люди уже считают это троллем.

Объяснение: Если вы посмотрите на спецификацию поплавков IEEE, вы можете заметить, что двоичные представления типа double упорядочены, то есть, если 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;
}

Это быстрый обратный квадратный корень .

Python 3

Вы, ребята, все делаете неправильно. Любой может увидеть, что квадратный корень из 20 - это не 4.47213595499958 или даже √20. Это решение переносит сложную задачу вычисления квадратного корня в модуль, предназначенный для этой цели.

Один из таких модулей - это sympy, который предоставляет математику с квадратными корнями. В отличие от других решений здесь, на самом деле все делает правильно. Он даже предполагает, что 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 Series:

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   

Латекс

Решение для этого довольно сложное и очень сложное, поэтому возьмите свой кофе. Проблема в том, что в зависимости от того, какое число вы хотите получить, квадратный корень кода существенно меняется. Я покажу вам проблему. Допустим, 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] содержит только конечное их количество, не так, как в действии crap aleph-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переходите к 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) я изменил алгоритм, чтобы сделать это напрямую.

АЛГОРИТМ

Преобразуйте число с плавающей запятой (в нашем случае это double) в целое число (в нашем случае long long.)

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

Е

Примечание: это работает только на моем компьютере, так как основные аппаратные средства не хранят числа в двоичной системе, но в базовых е, такой, что выглядит как 10представляют е, 100представляет е ^е , и так далее. Таким образом, то, что вы могли бы на двоичной машине назвать смещением влево, выполняет x => e ^x , а то, что вы могли бы на двоичной машине назвать смещением вправо, выполняет x => ln x. Ясно, что трудно представить ее основные цифры на этой очень ограниченной, бинарно-ориентированной интернет-среде, но я прилагаю все усилия.

Синтаксис E очень похож на синтаксис C / C ++, поэтому большинство людей должно легко его понять.

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

JavaScript / HTML / CSS

Я думал об использовании jQuery и идентификаторов, чтобы троллить немного больше, но я предпочитаю vanilla 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% чистый bash (на основе целых чисел)

С презентацией ascii-art:

Этот идеальный квадрат должен быть получен в bash с помощью 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);
    }
}

Не хотелось реализовывать ввод. Чтобы проверить изменение кода sqrtThisи expectedPercision.

Вот как работает код. Во-первых, получить корень sqrt для целого числа тривиально, поэтому я не чувствовал, что реализую это, и вместо этого использовал javas, встроенный в sqrt fcn. Остальная часть кода на 100% законна, хотя.

Основная мысль, так как pi - бесконечное длинное неповторяющееся десятичное число, все числовые последовательности должны встречаться в нем (читать редактировать). Поэтому ваш ответ внутри пи !! Таким образом, мы можем просто применить поиск регулярных выражений к пи в поиске вашего ответа. Если мы не сможем найти хороший ответ, тогда мы просто удвоим размер числа пи, по которому мы ищем!

Это действительно легко, на самом деле можно сказать, что это так же просто, как пи :)

Доказано, что Edit Pi содержит в себе каждую последовательность конечных чисел. Тот факт, что число pi бесконечно и не повторяется, не является достаточным доказательством для такого утверждения, как доказано Экзелианом. Однако многие математики верят, что число 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 Вот некоторые предварительно обработанные. Очень плохое минимальное решение, без обязательной проверки, без подсказок. 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;}