Hilfe!! Wie man Quadratwurzel macht! [geschlossen]

42

Hallo Leute, für meine Klasse muss ich eine Quadratwurzel machen, aber es funktioniert nicht !! HELLPP!

Die Herausforderung:

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

Hinweis: Dies ist Code-Trolling. Geben Sie eine "nützliche" Antwort, um diesen neuen Programmierer auf seinem Weg zum Programmiererfolg anzuleiten! Seien Sie kreativ!

qwr
quelle
63
@CloseVoters Bitte beenden Sie die Abstimmung, um [Code-Trolling] wegen fehlender Gewinnkriterien als "Off Topic" zu schließen. In diesem Fall handelt es sich offensichtlich um einen [Beliebtheitswettbewerb]. Bearbeiten Sie es, wenn Sie möchten. Nur weil Sie [Code-Trolling] nicht mögen, heißt das nicht, dass Sie die Herausforderung für alle anderen schließen müssen. Offensichtlich mögen viele Leute diese Art von Herausforderung, was sich in der Anzahl der Antworten zeigt. Da SE eine Community-gesteuerte Site ist, lassen Sie sie für diese Leute offen.
Justin
12
@ Quincunx Für das Protokoll war meine Abstimmung für zu breit. Es gibt buchstäblich nichts anderes zu tun, als "etwas mit Quadratwurzeln zu tun". (Wie bereits fünfzehn Antworten belegen.)
Türknauf
7
Enge Wähler: Können Sie mir helfen, zu verstehen, wie weitreichender diese Frage ist als bei anderen offenen [Code-Trolling] -Fragen? Vielleicht gibt es hier einen berechtigten engen Grund, aber die Kategorie Code-Trolling wird natürlich etwas breiter sein als die meisten Herausforderungen. Andernfalls würde es den Zweck etwas zunichte machen.
Geobits
6
@Geobits, wenn man sagt, dass die Antwort nicht einmal richtig sein muss, ist dies so umfassend wie "Schreibe etwas Code".
Peter Taylor
11
@Gareth Es ist eine interessante Analogie, aber sie stimmt nicht mit dem ursprünglichen Kommentar überein. Sie sind herzlich eingeladen, den ganzen Tag vor McDonalds zu stehen und den Leuten mitzuteilen, dass das Essen Mist ist. Und Sie sind herzlich eingeladen, negative Kommentare zu dieser Frage abzustimmen. Wenn Sie jedoch versuchen, die Teilnahme von Personen an McDonalds physisch zu unterbinden (das entspricht der gerade erst begonnenen zweiten Runde enger Abstimmungen), werden Sie höchstwahrscheinlich festgenommen. Ich habe ein gewisses Verständnis für die Ursache von Anti-Code-Trolling und werde diese Frage nicht upvoten (oder downvoten). Aber ich möchte die Freiheit, eine Antwort zu posten, wenn ich eine habe.
Stufe River St

Antworten:

121

Java

Wow, das ist ein kompliziertes Problem. Ich habe noch nie eine Quadratwurzel gemacht. Ich habe Quadratwurzeln gezogen, aber noch keine. Vergiss nicht, deinen Code hübsch aussehen zu lassen, um zusätzliche Credits in deinen Klassen zu erhalten. Hier ist der Code, der aus einer eingegebenen Zahl eine Quadratwurzel macht:

       import java
       .awt.Color;
import java.awt.Graphics;
import javax.swing.JFrame;
       import javax
       .swing.JPanel;

public class SquareRoot {

    public static void main(String[] args) {
        java.util.Scanner scan = new java.util.Scanner(java.lang.System.in);
        System.out.print("Please input a number to take the square root of: ");
        int num = scan.nextInt();
        System.out.print("The answer is: ");
        System.out.print(sqrt(num));
    }

    static int sqrt(int n){int
    m = n ;while (n==n){m++;if
    (m * m
    > n&&m    <n        &&
    m>0 ){
    return     0+      0+
    m-1;}}       ;;  ;;
    return        0+0+
 n  == 0 ?       1+  1-
  m --:--m     +0     -0
   ;}//sqr

            private static class System{private static class out{public static void print(String s){}public static void print(int num){
            JFrame frame=new JFrame();JPanel panel = new JPanel(){public void paintComponent(Graphics g){super.paintComponent(g);;;;;g.
            setColor(new Color(0x964B00));g.fillRect(0,500,3000,3000);g.setColor(new Color(0xCC7722));g.fillRect(700,505,75,75);;;;;;g.
            fillRect
            (720,450,
            36,50);g.
            drawLine
            (700,581,
             690,600);
            g.drawLine
            (685,600,
            665,615);
            g.drawLine
            (685,600,
            695,610);
            g.drawLine
            (780,581,
             795,600);
            g.drawLine
            (790,600,
            775,615);
            g.drawLine
            (790,600,
            810,610);
            g.setColor
            (Color.
            GREEN);g.
            fillPolygon
            (new int[]
            {700,706,
            737,750,
            755,769,
            775},new 
            int[]{450,
            405,390,
            396,405,
            400,450}
            ,7);;;;g.
            drawString
            (""+num,
            725,542);
}};         frame.add
(panel      );;//;;/
 ;;;        ;;;frame.
   setAlwaysOnTop
   (true);  frame.
   setDefaultCloseOperation
    (JFrame.DO_NOTHING_ON_CLOSE);
       frame.setVisible(true)
         ;;;;;;;;;}}}}

Trolle:

  • Offensichtlich ist der Code verschleiert.
    • Bekomme ich Bonuspunkte für die Grafik im Code?
  • Die System.out.prints drucken nicht nach java.lang.System.out.print. Sie drucken an eine innere Klasse. Die ersten beiden (die Zeichenfolgen drucken sollen) tun nichts; der zweite:
  • Ausgabe in ein Fenster. Beispielausgabe - sehen Sie die Quadratwurzel (Eingabe ist 100) ?:Bildbeschreibung hier eingeben
  • Das Fenster macht beim Schließen nichts. Weder ALT-F4, noch das Klicken auf die Schaltfläche zum Schließen oder andere Aktionen, die normalerweise zum Schließen führen, schlagen fehl.
  • Das Fenster befindet sich immer über anderen Fenstern. In Kombination mit der Tatsache, dass es maximiert ist, erfordert dies ein wenig Nachdenken, um es zu schließen.
  • findet den sqrt mit der ganzen Zahl ADDITION aus der Zahl, bis wir die richtige Zahl erreichen. Dies dauert lange, bis wir auf das Umbrechen von Ganzzahlen warten. Aus diesem Grund dauert es für größere Zahlen weniger Zeit. Für die Beispielausgabe wurden 20 Sekunden benötigt.
  • Funktioniert nicht richtig, wenn der Eingang ist 0. Schlägt durch Endlosschleife fehl, wenn der Eingang negativ ist, aus dem gleichen Grund, aus dem es durch Endlosschleife fehlschlägt, wenn der Eingang negativ ist 0.
  • Ich trollte mich und verbrachte ca. 2 Stunden damit, dies zu codieren und auszurichten.
Justin
quelle
11
Hervorragend getrollt, guter Herr.
Code Whisperer
1
Ich denke, Sie haben das JFrame.DO_NOTHING_ON_CLOSEin der Liste der Trolle
ausgelassen
2
@PlasmaPower Das wollte ich gerade bearbeiten. Du hast auch vergessen zu erwähnen setAlwaysOnTop(true).
Justin
4
"Ich habe mich selbst
getrollt
15
@Herjan Freundin? Welche Freundin?
Justin
71

C ++

Wenn Sie keine bessere Route haben, gibt es immer die Brute-Force-Lösung:

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

Dies iteriert durch jeden möglichen Wert von a double(indem uniones mit einem Wert von long longder gleichen Bitgröße versehen wird, da es keine gute Möglichkeit gibt, sie unter Verwendung von Doubles als tatsächliche Doubles zu iterieren), bis es einen Wert findet, dessen Quadrat gleich ist n.

Joe Z.
quelle
12
Jetzt habe ich mich gefragt, wie oft (bei unbegrenzter Laufzeit) dies tatsächlich funktioniert und wie oft es nicht gelingt, eine genaue Übereinstimmung zu finden und NaN zurückzugeben. Ich denke, es ist ungefähr 50/50, aber es ist hier zu spät für gutes mathematisches Denken.
Hobbs
29
Oh mein Gott, die Vereinigung von a doubleund a long longist das Schrecklichste, was ich je gesehen habe.
Patrick Collins
10
Möglicherweise ist dies erwünscht (Teil des Trolling), aber der Zugriff auf verschiedene Teile eines unionist undefiniertes Verhalten und das Durchlaufen von Doubles ist mit der Funktion möglichstd::nextafter
Nobody
6
Ich hatte keine Ahnung, dass std::nextafteres das gab, bevor du es mir gegenüber erwähnt hast, also ja, es wurde gesucht.
Joe Z.
3
Einige doubleWerte können nicht aus der Multiplikation erzeugt werden , x*xwo xist double, auch. Daher gelingt die Suche manchmal (meistens?) Nicht und es wird NaN anstelle eines korrekteren Ergebnisses angezeigt.
Sarge Borsch
64

Python 3

Dieser einfache Code gibt eine genaue Antwort:

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

Es wird nur ein Zeichen vor der eingegebenen Nummer gedruckt .

dan04
quelle
24
@ JanDvorak auf der anderen Seite, dies ist das einzige Programm hier, das immer die genaue Antwort gibt.
Level River St
1
@steveverrill: Nein, meiner auch.
NaCl
1
@steveverrill: Ich fordere dieses Programm heraus, habe ein Programm geschrieben, das immer die richtige Antwort gibt und das Problem tatsächlich löst (es ist übrigens mein Python 3-Programm, nicht C-Programm).
Konrad Borowski
16
@ JanDvorak Dies ist Code-Trolling
TheDoctor
45

In Python 3 können Sie Folgendes tun:

def square_root(n):
return float(n)**0.5
Jamierocks
quelle
38
Ich habe deinen Troll herausgefunden: Das funktioniert nicht. Es sieht so aus, als ob es so wäre, aber die zweite Zeile müsste eingerückt werden.
Justin
7
@DLeh ist es möglich, dass er sich selbst trollt?
krs013
42

Diese Antwort korrigierend ,

Mit C, weil C am schnellsten ist

Das ist einfach falsch. Jeder weiß, dass der schnellste ASM ist.

Pure 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

Im Gegensatz zu anderen verzögerten Antworten hat diese eine Komplexität von O (1)!
Und auch im Gegensatz zu anderen Antworten ist dies 101% genau, denn sqrt(0.5)es gibt 0.70710678118655!

Trolle:
* Schreiben in der Versammlung. Niemand schreibt in der Versammlung
* O (1) zu sein, macht es nicht schnell. Auf meinem System dauert es ungefähr 90 Sekunden, um sqrt für eine beliebige Anzahl auszuführen.
* Hardcoded Sprungstellen.
* Kein Stack-Frame
* AT & T-Syntax. Einige Leute halten es bereits für einen Troll.

Erklärung: Wenn Sie an der IEEE - Spezifikation aussehen schwimmt, könnte man feststellen , dass binäre Darstellungen von Doppel bestellt werden, das heißt, wenn a > bdann *(long long *)&a > *(long long *)&b.
Wir verwenden diesen Trick und iterieren jedes Mal, wenn die FPU die Antwort quadriert und den CPU-Vergleich mit dem Argument durchführt, über das Hochkomma der Antwort.
Dann iterieren wir auch über das untere Dword.
Dies ergibt eine exakt genaue Antwort bei einer nahezu konstanten Anzahl von Berechnungen.

mniip
quelle
5
Korrigieren Sie Ihre Korrektur: C ist schneller als Assembly, da der Compiler besser als Human optimieren kann. Sofern Sie nicht jeden einzelnen x86-Assembly-Vorgang kennen, schreibt der Compiler im Allgemeinen besseren Code.
Konrad Borowski
30
@xfix Korrektur Ihrer Korrektur: Mit einem vorliegenden Intel-Handbuch kann ein Mensch effizienter zusammenbauen als GCC
mniip
6
@xfix Nachdem Sie für jede Mnemonik eine kurze Beschreibung durchgelesen haben, PCMPEQQerscheint Ihnen etwas nicht mehr als "magischer, unlesbarer Müll, der von einem Compiler erzeugt wurde"
mniip
1
Wow ich wünschte du wärst mein Laborpartner, ich habe keine Ahnung was ich in der Montage mache. Urkomische Antwort / Kommentare.
HC_
@mniip (Korrigieren Sie Ihre Korrektur) ^ 3: Ein Superoptimierer kann den optimalen Code finden (indem er jede mögliche Reihe von Anweisungen ausprobiert) und einen Menschen übertreffen ^ _ ^ Sicherlich sollte das in jedem Quadratwurzler eingebaut sein?
Navin
39

Python

Schreiben Sie eine Funktion oder ein Programm, das "eine Quadratwurzel aus Zahlen" erstellt.

Wenn es in Ihrer Klasse zulässig ist, können Sie hier eine komplexe Mathematikbibliothek als Hilfsmittel verwenden. Installieren Sie sie, indem Sie den folgenden Befehl ausführen:

pip install num2words

Dann würden Sie einfach so etwas wie dieses Python-Skript ausführen:

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

(Stellen Sie sicher, dass Sie dies mit Administratorrechten ausführen)

nvuono
quelle
Können Sie erklären, wie das Trolling ist?
Der Kerl mit dem Hut
6
@TheGuywithTheHat: Anstatt die Quadratwurzel einer Zahl zu geben, diese Lösung einen Benutzer mit dem Quadrat der Zahl genannt und macht diesen Benutzer ein Admin ( rootin Unixland).
3Doubloons
33

C

Offensichtlich ist dies der beste Weg. Es ist so schnell, wie Sie sich vorstellen können, wenn Sie sich den Code ansehen. Verwenden von C, da C am schnellsten ist und dieses Problem eine schnelle Lösung erfordert. Ich habe dies für meine Lieblingszahlen wie 7, 13 und 42 getestet, und es scheint zu funktionieren.

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];
}
Konrad Borowski
quelle
3
Ich denke du meinst results[number];?
ace_HongKongIndependence
31
@ace: Beide funktionieren, ich habe es einfach vorgezogen, hier mehr Verschleierung zu machen. Informationen dazu, warum diese Syntax in C gültig ist, finden Sie unter stackoverflow.com/q/381542/736054 .
Konrad Borowski
8
@ArlaudPierre Das ist das Schöne an solchen Code-Trolling-Lösungen. Sie sind für einen bestimmten Bereich in Ordnung, was Sie täuschen könnte, dass sie tatsächlich verwendbar sind!
Mr Lister
2
@ MrLister Sie sind tatsächlich verwendbar. Die Frage sagt nicht aus, welcher Wertebereich akzeptiert wird. Es kann Kontexte geben, in denen dies ein absolut akzeptabler Wert ist.
Pierre Arlaud
9
@ArlaudPierre: Nun, in meinem Code befindet sich ein weiterer, gut versteckter Troll. Einige Werte sind ungültig, aber es ist nicht so, dass dies jemand bemerken würde (vor allem, weil sie sowieso in Ordnung sind). Und dann würden sich die Leute über einen weiteren Pentium FDIV-Fehler beschweren.
Konrad Borowski
30

C

Tricks und Magie machen es möglich.

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

Es ist schnell inverse Quadratwurzel .

Snack
quelle
7
Ich wusste, dass jemand dies tun würde :) So sieht echte Magie aus
qwr
8
Ich habe fast eine Minute damit verbracht, nach dem 1 / y zu suchen, um es von der inversen Wurzel in die tatsächliche Wurzel umzuwandeln. Die Alternative, return x * y zu verwenden, ist korrekt, aber schwerer zu erkennen.
Level River St
1
Ich würde denken, 10 Iterationen sind zu viel. 2-3 sind normalerweise ausreichend.
njzk2
1
@ njzk2 tatsächlich in Quake 3 Engine wurde nur eine Iteration verwendet. Der zweite wurde mit dem Zusatz "dies kann entfernt werden" auskommentiert. codemaestro.com/reviews/9
Keine Ahnung,
29

Python 3

Ihr macht alles falsch. Jeder kann sehen, dass die Quadratwurzel von 20 nicht 4.47213595499958 oder sogar √20 ist. Diese Lösung verlagert die schwierige Aufgabe der Quadratwurzelberechnung auf das dafür vorgesehene Modul.

Eines dieser Module ist Sympy, das Quadratwurzel-Mathematik liefert. Im Gegensatz zu anderen Lösungen hier macht es eigentlich alles richtig. Es wird sogar angenommen, dass sqrt (-1) I ist - keine der Lösungen hier kann das lösen.

Und hier ist der modulare Code, wie gute Programme aussehen. Die Funktionen sollten so klein wie möglich sein, wenn dies nicht der Fall ist, bedeutet dies, dass Sie schreckliche Programme schreiben. Außerdem sollten Programme viele Kommentare haben.

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

Und hier ist ein Beispiel dafür, wie dieses Programm funktioniert.

> python sqrt.py 
Specify number: 10 + 10
2*sqrt(5)
> python sqrt.py 
Specify number: cos(pi)
I
Konrad Borowski
quelle
12
-1 nicht genug Kommentare
alexwlchan
5
@alexwlchan: Weitere Kommentare hinzugefügt.
Konrad Borowski
2
Das sind wirklich kurze, leicht verständliche, beschreibende Funktionsnamen! +1! PS Weitere Kommentare hinzugefügt.
AMK
2
-1 Funktionsname nicht lang genug, sollte sein print_format_prompt_with_thing_to_specify_get_default_prompt_format_to_getattr_get_sys_name_from_get_stdout_name_and_print_square_root_of_read_from_stdin_and_print_get_string_from_get_newline_to_getattr_get_sys_name_from_get_stdout_name.
Der Kerl mit dem Hut
1
@TheGuywithTheHat: Ich würde es vorziehen, wenn meine riesigen Funktionsnamen ohne horizontales Scrollen in das Codefeld passen würden. Selbst wenn es sich um Code-Trolling handelt , hasse ich das Scrollen.
Konrad Borowski
28

JavaScript

Leider unterstützt JavaScript das Quadratwurzelsymbol für Funktionsnamen nicht. Stattdessen können wir ein anderes Unicode-Alphabet verwenden, um eine Quadratwurzelfunktion darzustellen.

In diesem Beispiel verwende ich .

Sobald wir ein gültiges Symbol haben, können wir mit dem Math-Objekt eine Quadratwurzelfunktion erzeugen.

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

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

Es ist einfach! :)

Natürlich wäre es einfacher, nur zu verwenden var ᕂ = Math.sqrt;

nderscore
quelle
16
Mir gefällt, wie Ihr Code JS-Kompressoren bricht.
Konrad Borowski
2
@xfix Ja, wenn irgendetwas versucht, den Namen dieser selbstausführenden Funktion zu ändern, bricht der Code :)
nderscore
25

Julia

Offensichtlich der beste Weg, dies zu tun, ist die Verwendung der Quadratwurzel Taylor-Serie:

Bildbeschreibung hier eingeben

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

Das gibt eigentlich sehr genaue Werte aus:

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

Aber natürlich ist es wie eine Annäherung (und auch eine konvergente Reihe) nutzlos für Werte, die nicht nahe bei 1 liegen:

julia> sqroot(0)  #what?
9.659961241569848

julia> sqroot(4)  #interesting...
-8.234843085717233e7   
CCP
quelle
2
Der Konvergenzradius dieser Potenzreihe ist 1, daher funktioniert dies nur für t in (0,2) (oder für den Komplex t in der offenen Scheibe, die bei 1 von Radius 1 zentriert ist). Für andere Werte könnten Sie Faktorisierungen verwenden ...
gniourf_gniourf
Sie haben Recht, ich habe das Konvergenzintervall nicht nur der Einfachheit halber angegeben :)
KPCh
2
Zu nützlich für meinen Geschmack. Sie können leicht durch 4 dividieren, bis es in Grenzen ist, und dann das Ergebnis mit der entsprechenden Potenz von 2
multiplizieren
1
^ Ich denke, man kann mit Sicherheit sagen, dass ein durchschnittlicher fauler Fragesteller es einfach so nimmt, wie es ist.
Joe Z.
Ich denke, Sie vermissen die Tatsache, dass die Taylor-Reihe verschoben und 1 zentriert ist. Wenn ich also durch a^2(n-mal) dividiere und mit (n-mal) multipliziere, lautet adie Antwort ( sqrt(x)~a^n*sqroot(x/a^2n)) x-> 0 (wenn a> 0) nicht 1 (gibt große Fehler). Auch wenn x / a ^ 2n ~ 1 ist , ändern sich die Zahlen a!=xund nwerden beliebig geändert x, um die gewünschte Vorgabe zu erhalten (was nervig und zeitaufwendig macht, um sie zu finden).
KPCh
20

Latex

Die Lösung dafür ist ziemlich schwierig und sehr komplex. Nehmen Sie also Ihren Kaffee mit. Das Problem ist, dass sich die Quadratwurzel des Codes abhängig von der gewünschten Zahl erheblich ändert. Ich zeige dir das Problem. Sagen wir mal, das 9ist deine Nummer. Dann würde der Code so aussehen:

\sqrt{9}

Nehmen wir nun an, das 1234321ist Ihre Nummer. Schauen Sie sich den Code an:

\sqrt{1234321}

Last but not least sagen wir, Ihre Nummer ist 0.

\sqrt{0}

Eine gute Möglichkeit, dies zu lösen, besteht darin, ein Programm in Ook!oder zu schreiben Piet, das Ihre Nummer will und das dafür ausgibt LaTeX-sqrt-code. Hier ist ein sehr einfaches Beispiel dafür Ook!, da es nur ein Byte lesen kann und nicht prüft, ob dieses Byte eine zulässige Zahl ist oder nicht, aber ich denke, Sie kommen auf den Punkt.

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

Gleiches für Piet:

Entspricht dem einfachen Programm von Ook!

Dies wäre der effizienteste Weg. Ich würde auch vorschlagen, es zu verwenden, Pietda es jedes Mal ein wunderschönes Kunstwerk ist, damit Sachen nicht schnell langweilig werden.

NaCl
quelle
3
Ich möchte diesen Piet-Code, aber es ist nur ein Brainfuck-Compiler (den ich im Internet finden kann), der den Ook-Code ausführt.
Konrad Borowski
11
Warte kurz? Es ist ein Esolang-Programm, das den Compiler einer anderen Sprache ausführt, um eine dritte Sprache zu analysieren. Oh Junge!
Kroltan
Ook ist nur ein Symbol für Wortglanz bei Brainfuck.
Ross Presser
20

Haskell

Ich habe aufgehört, Computern zu vertrauen, als ich zum ersten Mal von Gleitkommafehlern hörte. Ich meine, im Ernst, wenn selbst Google sie nicht unter Kontrolle bringen kann , wer kann das dann?

Unsere beste Wette ist es also, eine Lösung zu finden, die nur ganze Zahlen enthält. Glücklicherweise ist das einfach, da wir einfach alle Zahlen überprüfen können, da jedes Intervall [1..n] nur eine begrenzte Menge von ihnen enthält, nicht wie der Mist Aleph-1 Real. Hier ist eine Beispielimplementierung in Haskell:

import Prelude hiding (sqrt)
import Data.List

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

Funktioniert wie ein Zauber, probiere es aus:

λ> sqrt 8
2

Die Genauigkeit sollte für die meisten Anwendungen ausreichen.

Flonk
quelle
2
+1.0 für die "Mist Aleph-1 Reals"
wchargin
2
@ M.Mimpen Ackhhhchh: duckduckgo.com/…
AMK
1
@ AMK Huh. Möglicherweise verwendet Google doubles und DDG triples.
Wchargin
16

Java

Der genaueste Weg, dies zu tun, ist die Iteration. Führen Sie zunächst eine Schleife mit integers durch, bis Sie das Ziel überfahren, und wechseln Sie dann zu doubles. Diese Methode hat den Vorteil, dass sie genau ist , im Gegensatz zu anderen "Schätzmethoden", die Sie möglicherweise sehen. Sie opfern ein bisschen Geschwindigkeit, aber für die meisten Anwendungen ist dies genau das, was Sie brauchen.

Sie können diese Antwort ändern, je nachdem, wie genau Sie sein müssen, dies sollte jedoch mindestens milliardstel genau funktionieren:

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

Das dauert sqrt(99.9999998);für mich ungefähr 3 Sekunden . Das Durchlaufen von (bis zu) einer Milliarde Doppeln dauert, glaube ich, einige Zeit.

Geobits
quelle
1
Das Problem bei der Verwendung 0.000000001ist, dass es zu Rundungsfehlern kommt. Ich habe eine genauere Lösung in C ++ erstellt.
Joe Z.
2
@JoeZ. Ja, das hat meine +1 bekommen, aber das ist gut genug für die Regierungsarbeit. Natürlich gibt Ihre NaN für jede Antwort zurück, die nicht genau durch ein Doppel dargestellt werden kann, wie es scheint, so präzise ist ein bisschen in der Luft;)
Geobits
Wahr. Soll ich dort die Epsilon-Erkennung einsetzen?
Joe Z.
3
Warum nicht Math.nextUp(root)statt +0.000000001? Das würde viel länger dauern ... und es wird garantiert gelingen.
Justin
1
@Quincunx Ich dachte, dass es eine Methode gibt, die das macht Doubleund war überrascht, als ich sie nicht finden konnte. Ich habe nicht daran gedacht, nachzuschauen Math, aber das funktioniert ziemlich gut. Ich habe es noch nicht "scheitern" lassen.
Geobits
11

Javascript

Diese magischen Konstanten können verwendet werden, um die Quadratwurzel einer Zahl mit dem Alphabet zu berechnen:

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

Tests:

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

Es scheint ziemlich gut zu funktionieren. Ich frage mich, ob es einen kürzeren Weg gibt.

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

Paul
quelle
10

JavaScript

Sehr schwieriges Problem!
In JavaScript ist dafür keine Funktion integriert ...
Sieht nach einem Job für den Newton-Raphson-Solver aus.

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

Jetzt können Sie verwenden Math.sqrt

Michael M.
quelle
Wie macht dieser Troll? Ist es die Tatsache, dass es eine negative Antwort gibt?
Joe Z.
1
@JoeZ. Der Troll verwendet einen Newton-Raphson-Solver als Hausaufgabe für Anfänger. Es ist nicht die erwartete Antwort, aber es funktioniert und er wird einige Zeit damit verbringen, den Code zu verstehen.
Michael M.
28
-1 nicht genug jQuery.
Pierre Arlaud
5
@ArlaudPierre Hoffe, Sie haben nicht wirklich eine -1 ...
tomsmeding
@ Tomsmeding hat er nicht.
Justin
10

JavaScript / ActionScript

Es gibt keine Möglichkeit, eine Quadratwurzel direkt in ActionScript oder JavaScript zu berechnen, es gibt jedoch eine Problemumgehung. Sie können die Quadratwurzel einer Zahl erhalten, indem Sie sie zur 1/2Potenz erhöhen .

So würde es in JavaScript und ActionScript 2 aussehen:

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

Und obwohl die Funktion in ActionScript 3 genauso gut funktioniert, würde ich aus Gründen der Klarheit und Zuverlässigkeit die Verwendung typisierter Variablen und Rückgabewerte empfehlen:

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

Der Troll:

Obwohl das, was ich über num^(1/2)das Erzielen einer Quadratwurzel sagte, in der Mathematik korrekt ist, ist das, was der ^Operator in JavaScript und ActionScript tatsächlich tut, Bitweises XOR .

IQAndreas
quelle
1
Die beste Antwort da draußen. Ich mochte die "Power" -Operator
Silviu Burcea
Eine solche Antwort wäre in C oder Python2, wo zusätzlich, gemeiner 1/2 == 0.
Aland
9

Python 2.7

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

Erläuterung

Zitieren

Wikipedia - Quadratwurzel

In der Mathematik ist eine Quadratwurzel einer Zahl a eine Zahl y, so dass y 2 = a ist

Mit anderen Worten ist jede Zahl eine Quadratwurzel einer anderen Zahl.

Hinweis

Diese Frage ähnelt für mich einem bekannten Puzzle. Wie man eine Linie kürzer macht, ohne sie zu reiben oder zu schneiden

Abhijit
quelle
9

PHP (und andere):

Da die Art und Weise, wie die Frage beschrieben wurde, nicht bedeutete, dass wir sie tatsächlich berechnen müssen, ist hier meine Lösung:

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

Es bietet eine Möglichkeit, die Quadratwurzel in mehreren Sprachen genau zu berechnen.

Die Liste der Sprachen kann erweitert werden.

Der Wert kann über POST, GET, ein Cookie gesendet oder sogar in der Sitzung gespeichert werden.

Wenn Sie nur die Nummer angeben, wird es verwirrend und gibt das berechnete Ergebnis, das für (fast) JEDE Sprache gültig ist !

Ismael Miguel
quelle
8

C

Dies ist besser als alle anderen 27 Antworten, da diese alle ungenau sind. Das ist richtig, sie geben nur eine Antwort, wenn es 2 geben sollte. Diese versucht nicht einmal zu antworten, wenn es falsch wird, sie gibt einfach auf und rundet ab.

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

Code-Trolling:

  • Sehr merkwürdige Benennung
  • forLoop-Missbrauch
  • Setzen Sie Semikolons an den Anfang der Zeile, wo sie sein sollten
  • #defineVerwenden Sie diese Taste, um die Lesbarkeit zu verringern
  • nutzlose Nutzungsnachricht
  • Minus oder Plus anstelle von Plus oder Minus
  • Gibt eine Zeichenfolge zurück
  • gibt eine lokale Variable zurück
  • 4 Compiler-Warnungen (2 unbenutzte Ausdrucksergebnisse, die die Adresse der lokalen Variablen zurückgeben, kein String-Literal in printf)
  • Funktioniert nur für nichtnegative perfekte Quadrate <100 (auch bekannt als 0, 4, 9, 16, 25, 36, 49, 64 und 81), da die Antwort nur eine Ziffer umfassen kann (wenn die Antwort ohne Grund gedruckt wurde) , also zum Beispiel √1024zurück 3√1024 = ∓32, was einfach falsch ist)
0942v8653
quelle
#define the number... nett! Mir hat Ihre Argumentation bezüglich der Bedingung für das Anzeigen der Verwendungsnachricht gefallen, insbesondere.
CompuChip
-1, da die Verwendungsmeldung angezeigt wird, wenn ich mehr als 2 Milliarden Befehlszeilenparameter eingebe. Oder vielleicht nur 32768, wenn ich es auf einem 16-Bit-Computer wie einem PDP-11 ausführe. (Dort datiert mich das). Beides ist eigentlich nicht möglich, da die Architektur in beiden Fällen die Eingabe so vieler Parameter verbietet, es sei denn, ich habe den Aufruf zu main vorgetäuscht und Sie einfach angelogen. Was nicht unmöglich ist: Ich könnte das tun. In der Tat könnte ich dich bereits angelogen haben.
ClickRick
8

C ++

basierend auf http://en.wikipedia.org/wiki/Fast_inverse_square_root und der Antwort von @ snack.

Abgesehen davon, dass ich keine Möglichkeit gefunden habe, x ^ (- 0.5) in x ^ (0.5) umzuwandeln, habe ich den Algorithmus dahingehend modifiziert, dass er direkt ausgeführt wird.

ALGORITHMUS

Wandelt eine Gleitkommazahl (in diesem Fall ein Double) in eine Ganzzahl um (in diesem Fall long long.)

Die ersten paar Bits der Gleitkommazahl sind der Exponent: Das heißt, die Zahl wird als 2 ^ AAA * 1.BBBBBBB gespeichert. Wenn Sie also eine Rechtsverschiebung durchführen, halbiert sich dieser Exponent.

In der ursprünglichen inversen Quadratwurzel, wurde diese Zahl von einer Konstanten abgezogen , um den reziproken zu geben. Ich füge es einfach zur Konstante hinzu, weil ich die Quadratwurzel direkt haben möchte. Der Wert der Konstante wird gewählt, um eine Antwort zu geben, die die beste Annäherung an den gewünschten Wert darstellt.

Wandle die Zahl zurück auf Gleitkomma.

Optional können ein oder zwei Iterationen der Newton-Methode verwendet werden, um das Ergebnis zu verbessern, aber ich habe mich nicht darum gekümmert, weil ich sehen wollte, wie nahe ich dran sein kann.

Die verwendeten Konstanten sehen sehr mysteriös aus, aber über die ersten Ziffern hinaus sind die Werte nicht kritisch. Ich habe die Konstante durch Ausprobieren gefunden. Ich hörte auf, sobald ich einen Wert bekam, der manchmal unterschätzt und manchmal überschätzt wurde.

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

Ergebnisse

Das Casting ist nur erforderlich, weil Sie mit C keine Bitverschiebungsoperationen auf einem Float ausführen können. Die einzigen echten Operationen sind also die Bitverschiebung und die Addition. Ich habe keine einzige Iteration von Newtons Methode verwendet, um das Ergebnis zu verbessern, daher ist die Präzision bemerkenswert. Der Lehrer des OP wird von der Schnelligkeit der Methode beeindruckt sein, die (ehrlich gesagt) für viele Zwecke genau genug ist!

Bildbeschreibung hier eingeben

Level River St
quelle
Super genaue Gleitkommazahl
Cole Johnson
2
@ColeJohnson Nun, Sie können keine genaue Ausgabe haben, das ist eine Einschränkung der Computerwelt (wir können nicht unendlich viel Speicher haben). Also würde ich sagen, dass dies so genau ist, wie es nur geht.
Pierre Arlaud
Nun, das Double ist eindeutig übertrieben und Teil des Trolls. Ich habe erwartet, dass diese Methode ungefähr +/- 30% bringt. Ich trolle auseinander und bin erstaunt, wie genau es ist. Ein Grund dafür ist: 4 = 2 ^ 10* 1. 000, sqrt (4) = 2 ^ 01* 1. 000= 2, sqrt (2) = 2 ^ 00* 1. 100= 1,5. Das 1aus dem Exponenten herausgeschobene Bit ergibt also eine Mantisse von 1,5, was nicht weit vom wahren Wert von sqrt (2) entfernt ist, der etwa 1,4 beträgt. Aber habe keine Ahnung, wie es konsequent Antworten mit einer Genauigkeit besser als 3% gibt.
Level River St
7

E

Hinweis: Dies funktioniert nur auf meinem Computer, da die zugrunde liegende Hardware Zahlen nicht in Binärform, sondern in der Basis e speichert, sodass das, was als 10e 100dargestellt wird, e e darstellt und so weiter. Auf diese Weise führt das, was Sie auf einer Binärmaschine als Bitverschiebung nach links bezeichnen, x => e x aus , und das, was Sie auf einer Binärmaschine als Bitverschiebung nach rechts bezeichnen, führt x => ln x aus. Es ist klar, dass es schwierig ist, die zugrunde liegenden Zahlen auf diesem sehr begrenzten, binär zentrierten Internetmedium darzustellen, aber ich gebe mein Bestes.

Die Syntax von E ist der von C / C ++ bemerkenswert ähnlich, daher dürfte dies für die meisten Menschen leicht verständlich sein.

double sqrt(double n)
{
    return ((n >> 1) / 2) << 1;
}
ClickRick
quelle
7
Ist das eine richtige Sprache?
Joe Z.
Welche Art von Computer verwenden Sie?
Cole Johnson
@ClickRick Können Sie einen Link für die E-Programmiersyntax und das Befehlsschema bereitstellen?
WallyWest
6
Tut mir leid, aber auch in Basis e n >> 1ist das nicht dasselbe wie log(n).
JWG
2
Die Sprache ist leicht zu erschließen. Die Existenz von unterstützender Hardware ist der Teil, den Sie in Frage stellen sollten.
ClickRick
6

JavaScript / HTML / CSS

Ich habe darüber nachgedacht, jQuery und ids zu verwenden, um ein bisschen mehr zu trollen, aber ich bevorzuge Vanille-js.

Das Ergebnis ist nicht ganz präzise, ​​aber es funktioniert!

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;
}
sebcap26
quelle
6

GeoGebra

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

Lesen Sie den Wert Ihrer Antwort von der Koordinatenachse ab.


Probieren Sie es hier online aus (erfordert Java) oder genießen Sie einige Screenshots unten:

Bildbeschreibung hier eingeben Bildbeschreibung hier eingeben

ace_HongKongIndependence
quelle
6

100% pure (ganzzahlig)

Mit ascii-art Präsentation:

Dieser perfekte Wurzelquadrat muss mit dem sourceBefehl in bash ermittelt werden

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

Alt (diese Version kann einfach in jedes Konsolenterminal eingefügt werden)

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

Wird funktionieren wie:

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

Bitte beachten Sie: Die Wurzel ist quadratisch !!

F. Hauri
quelle
4

Java

Vielen Dank an ggmx für den Code zum Generieren von n Ziffern von pi in 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);
    }
}

Hatte keine Lust, Input zu implementieren. Um die Codeänderung zu testen sqrtThisund expectedPercision.

So funktioniert der Code. Erstens ist es trivial, die sqrt-Wurzel für Integer zu bekommen, also hatte ich keine Lust, diese zu implementieren, und verwendete stattdessen Java-Dateien, die in sqrt fcn erstellt wurden. Der Rest des Codes ist jedoch zu 100% legitim.

Die Grundidee, da pi eine unendlich lange, sich nicht wiederholende Dezimalzahl ist, müssen alle Zahlenfolgen darin vorkommen (Lies Bearbeiten). Daher ist deine Antwort in pi !! Als solches können wir einfach eine reguläre Suche auf pi anwenden, um nach Ihrer Antwort zu suchen. Wenn wir keine gute Antwort finden können, verdoppeln wir einfach die Größe des Pi, nach dem wir suchen!

Es ist wirklich einfach, man könnte sogar sagen, dass es so einfach ist wie pi :)

Es
wurde nicht nachgewiesen, dass Edit Pi jede Folge endlicher Zahlen enthält. Die Tatsache, dass pi unendlich ist und sich nicht wiederholt, ist kein ausreichender Beweis für eine Aussage, wie sie von Exelian bewiesen wurde. Doch viele Mathematiker tun glauben pi jede Folge von endlichen Zahlen enthält.

Sahar Rabinoviz
quelle
Ich möchte darauf hinweisen, dass nicht jede Sequenz in einer Zahl erscheint, wenn sie unendlich ist und sich nicht wiederholt. Es ist ziemlich einfach, eine Zahl zu konstruieren, die unendlich ist und sich nicht wiederholt, aber nicht jede mögliche Sequenz enthält, z Sequenz jedoch, wir wissen nur nicht sicher)
Exelian
@Exelian hat eine Korrektur gemäß Ihrem Kommentar vorgenommen und einen Link zum Sichern Ihres Kommentars sowie den Grund angegeben, warum meine Lösung immer noch ausreicht.
Sahar Rabinoviz
3

JQuery

Dieser ist der genaueste (Bonus: funktioniert auch für Briefe!)

Please enter the number : 
<script>
$("#b").submit(function() 
{

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

Hier ist eine Geige

Mhmd
quelle
3
Die Herausforderung zu wörtlich anzunehmen ist nicht zu lustig. Obwohl ich nicht denke document.write, dass es genug widerspricht.
John Dvorak
2
@JanDvorak das ist ein Code-Trolling, solche Lösungen gelten hier.
Mhmd
3
@Mhmd: Trotzdem erwarten wir, dass Sie hier kreativ sind. Alle haben das schon gemacht, machen was anderes. Sie werden auf diese Weise nicht viel Gegenstimmen bekommen.
Konrad Borowski
1
@ JanDvorak / xfix: Wenn das Problem darin besteht, dass die Antwort eine geringe Qualität aufweist und dennoch die Mindestkriterien erfüllt, ist die Lösung dann nicht einfach, die Antwort nach Punktzahl auf den Grund sinken zu lassen? (Da dies laut Ihrem Link bereits eine ausgemachte Sache ist.)
Andrew Coonce
1
@ JanDvorak: Guter Punkt. In Anbetracht dessen vielen Dank für die Erklärung!
Andrew Coonce
3

C ++

Dadurch erhalten Sie schließlich eine Quadratwurzel.

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

Ich habe den Code korrigiert, um die Frage besser widerzuspiegeln. Vielen Dank für Ihre Vorschläge. Der Code wurde aktualisiert.

Bacchusbeale
quelle
Da Sie bereits durch die Maschine epsilon begrenzt sind, warum nicht verwenden x+=1e-16?
Kyle Kanos
1
@KyleKanos Oder genauer gesagt DBL_EPSILON.
Cole Johnson
3

Python

Diese Lösung:

  1. ist nicht deterministisch und liefert ungefähre Antworten
  2. ist O (N) und ziemlich langsam, auch für niedrige N
  3. stützt sich auf eine obskure mathematische Beziehung

Spoiler:

Summiere N unabhängige einheitliche [-.5, .5] Zufallsvariablen. Schätzen Sie die Standardabweichung anhand des Mittelwerts der absoluten Werte. Die Standardabweichung ist dabei proportional zu sqrt (N) als N -> \ infty. 139 und 2.71828 sind nur Skalierungsfaktoren, die die Präzision steuern, und sie wurden ausgewählt, um geheimnisvoll auszusehen.

Code:

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)))
Emanuel Landeholm
quelle
3

C ++

Ihre Frage wird nicht kompiliert, weil Sie ein! Am Ende. C ++ mag ich nicht!
Hier die richtige Frage für den Compiler:

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

Oh ... und die Make-Datei.

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

und 26317.def. Dies sollte bereits in Ihrem Compiler vorhanden sein

#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 

Ja, jemand kann -E verwenden, um die richtige Antwort vor dem Prozess auszugeben, aber wenn Sie -E kennen, wissen Sie auch, wie man squareroot. : P Hier einige der vorverarbeiteten. Sehr schlechte minimale Lösung, kein gebundener Scheck, keine Aufforderung. Bis zu diesem Trigraph sind vorverarbeitet.

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