Aidez-moi!! Comment faire la racine carrée! [fermé]


42

Salut les gars, pour ma classe, je dois créer une racine carrée numérique, mais ça ne marche pas !! HELLPP!

Le défi:

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

Remarque: Ceci est le code trolling. Donnez une réponse "utile" pour guider ce nouveau programmateur vers la réussite de sa programmation! Sois créatif!


63
@CloseVoters S'il vous plaît, arrêtez de voter pour fermer [code-trolling] comme étant hors sujet, faute de critères gagnants. Dans ce cas, il s’agit évidemment d’un [concours de popularité]. Modifiez-le si vous le souhaitez. Ce n’est pas parce que vous n’aimez pas [code-trolling] que vous devez fermer le défi à tous les autres. De toute évidence, beaucoup de gens aiment ce type de défi, comme en témoigne le nombre de réponses, alors, comme SE est un site géré par la communauté , laissez-le ouvert pour ces personnes.
Justin

12
@Quincunx Pour mémoire, mon vote était pour Too Broad. Il n'y a littéralement rien à faire sauf "faire quelque chose en rapport avec les racines carrées". (Comme en témoigne déjà quinze réponses.)
Bouton de porte

7
Électeurs proches: Pouvez-vous m'aider à comprendre en quoi cette question est plus "large" que d'autres questions non clôturées? Peut-être y at-il une raison valable valable ici, mais la catégorie de la pêche à la traîne des codes sera naturellement un peu plus large que la plupart des défis. Autrement, cela irait à l’encontre de l’objectif visé.
Geobits

6
@Geobits, en disant que la réponse n'a même pas à être correcte, c'est aussi large que "Ecrire du code".
Peter Taylor

11
@Gareth C'est une analogie intéressante, mais elle ne correspond pas au commentaire d'origine. Vous êtes le bienvenu si vous restez à l'extérieur de McDonalds toute la journée avec une bannière informant les gens que la nourriture est de la merde. Et vous êtes les bienvenus pour voter / mettre des commentaires négatifs sur cette question. Toutefois, si vous essayez d'empêcher physiquement les personnes d'entrer dans McDonalds (l'équivalent du deuxième tour de scrutin serré qui vient de commencer), vous serez probablement arrêté. J'ai un peu de sympathie pour la cause anti code trolling et je ne voterai pas (ou ne voterai pas) cette question. Mais je veux la liberté de poster une réponse si j'en ai une.
Level River St

Réponses:


121

Java

Wow, c'est un problème compliqué. Je n'ai jamais fait de racine carrée auparavant. J'ai pris des racines carrées, mais je n'en ai pas fait. N'oubliez pas de rendre votre code joli pour un crédit supplémentaire dans vos cours. Voici le code qui fait une racine carrée d'un nombre entré:

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

Trolls:

  • De toute évidence, le code est obscurci.
    • Est-ce que je reçois des points bonus pour les illustrations dans le code?
  • Le System.out.prints n'imprime pas java.lang.System.out.print. Ils impriment à une classe intérieure. Les deux premiers (qui sont supposés imprimer des chaînes) ne font rien; le deuxième:
  • Sorties dans une fenêtre. Exemple de sortie - voyez-vous la racine carrée (l’entrée est 100) ?:entrez la description de l'image ici
  • La fenêtre ne fait rien fermer. Ni ALT-F4, en cliquant sur le bouton de fermeture, ou de faire quelque chose qui fermerait normalement il échoue.
  • La fenêtre est toujours au-dessus des autres fenêtres. Combiné au fait qu'il est maximisé, cela nécessite un peu de réflexion pour le fermer.
  • trouve le carré par entier ADDITION à partir du nombre jusqu’à atteindre le nombre correct. Cela prend beaucoup de temps depuis l'attente d'un bouclage entier. Pour cette raison, il faut moins de temps pour les grands nombres. Cela a pris 20 secondes pour l’échantillon de sortie.
  • Ne fonctionne pas correctement lorsque l'entrée est 0. Échec par boucle infinie lorsque l'entrée est négative pour la même raison qu'il échoue par boucle infinie lorsque l'entrée est 0.
  • Je me suis traîné et j'ai passé ~ 2 heures à coder ceci et à l'aligner.

11
Excellemment trollé, bon monsieur.
Code Whisperer

1
Je pense que vous avez JFrame.DO_NOTHING_ON_CLOSE
omis

2
@PlasmaPower J'étais sur le point de l'éditer. Vous avez oublié de mentionner setAlwaysOnTop(true)également.
Justin

4
"Je me suis traîné moi-même" Je pense que vous avez également guetté votre petite amie, lol
Herjan

15
Petite amie @Herjan? Quelle petite amie?
Justin

71

C ++

Eh bien, si vous n'avez pas de meilleur itinéraire, il y a toujours la solution de force brute:

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

Cela parcourt toutes les valeurs possibles de a double(en y unionajoutant un long longde la même taille en bits, car il n’existe aucun moyen efficace de les parcourir en utilisant des doublons comme doubles réels) jusqu’à ce qu’il en trouve une dont le carré est n.


12
Vous vous demandez maintenant à quelle fréquence (avec un temps de parole illimité) fonctionne-t-il réellement et à quelle fréquence n'arrive-t-il pas à trouver une correspondance exacte et à renvoyer NaN? Je pense que c'est à peu près 50/50, mais il est trop tard pour une bonne réflexion mathématique.
Hobbs

29
Oh mon dieu, l'union d'un doubleet a long longest la chose la plus terrifiante que j'ai jamais vue.
Patrick Collins

10
Peut-être que ceci est voulu (partie de la pêche à la traîne) mais accéder à différentes parties d'un unioncomportement est indéfini et itérer à travers des doublons est possible avec la fonctionstd::nextafter
Personne Personne

6
Je n'avais aucune idée de ce qui std::nextafterexistait avant que vous ne m'en parliez, alors oui, c'était voulu.
Joe Z.

3
Certaines doublevaleurs ne peuvent pas être produites en multipliant x*xxest double, aussi. Donc, la recherche ne réussit pas parfois (la plupart du temps?), Donnant NaN au lieu d'un résultat plus correct.
Sarge Borsch

64

Python 3

Ce code simple donnera une réponse exacte :

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

Il ne fait qu'imprimer un caractère devant le numéro saisi.



24
@ JanDvorak, d’autre part, c’est le seul programme qui donne toujours la réponse exacte.
Level River St

1
@steveverrill: Non, le mien aussi.
NaCl

1
@steveverrill: Je lance un défi à ce programme alors, j’ai écrit un programme qui donne toujours la bonne réponse et résout réellement le problème (c’est mon programme Python 3, et non pas le programme C).
Konrad Borowski

16
@JanDvorak c'est du code
TheDoctor Le

45

En Python 3, vous pouvez effectuer les opérations suivantes:

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

38
J'ai compris ton troll: ça ne marche pas. Cela semble être le cas, mais la deuxième ligne doit être indentée.
Justin

7
@DLeh est-il possible qu'il se traîne?
krs013

42

Corriger cette réponse ,

Utiliser C, parce que C est le plus rapide

C'est tout simplement faux. Tout le monde sait que le plus rapide est l'ASM.

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

Contrairement aux autres réponses retardées, celle-ci a une complexité de O (1)!
Et contrairement à d’autres réponses, c’est précis à 101%, sqrt(0.5)c’est très utile 0.70710678118655!

Trolls:
* Écriture en assemblée. Personne n'écrit en assemblée
* Être O (1) ne fait pas vite. Il faut environ 90 secondes sur mon système pour effectuer un test sur n'importe quel nombre.
* Emplacements de sauts codés.
* Pas de cadre de pile
* Syntaxe AT & T. Certaines personnes le considèrent déjà comme un troll.

Explication: Si vous regardez la spécification IEEE flotte, vous remarquerez peut - être que les représentations binaires de doubles sont ordonnées, qui est, si a > balors *(long long *)&a > *(long long *)&b.
Nous utilisons cette astuce et itérons sur le mot clé de la réponse, chaque fois que la FPU la place au carré et effectue une comparaison de CPU avec l'argument.
Ensuite, nous parcourons aussi le mot inférieur.
Cela nous donne une réponse précise avec un nombre de calculs presque constant.


5
Correction de votre correction: C est plus rapide que l’assemblage, car le compilateur peut optimiser mieux que l’être humain. Sauf si vous connaissez chaque opération d'assemblage x86, le compilateur écrit généralement un meilleur code.
Konrad Borowski

30
@xfix Correction de votre correction: avec un manuel Intel à portée de main, un humain peut produire un assemblage plus efficace que GCC
mniip

6
@xfix Après avoir lu de brèves descriptions pour chaque mnémonique, des choses comme PCMPEQQne vous apparaissent plus comme des "ordures illisibles magiques produites par un compilateur"
mniip

1
Wow, j'aimerais que tu sois mon partenaire de laboratoire, je n'ai aucune idée de ce que je fais en assemblée. Réponse / commentaires hilarants.
HC_

@mniip (Correction de votre correction) ^ 3: Un superoptimiseur peut trouver le code optimal (en essayant toutes les séries d'instructions possibles) et surpasser celui d'un humain ^ _ ^ Cela devrait sûrement être intégré à tout rooter carré?
Navin

39

Python

Ecrivez une fonction ou un programme qui "créera une racine carrée numérique".

Si cela est autorisé dans votre classe, vous pouvez utiliser ici une bibliothèque de mathématiques complexe comme aide, installez-la en exécutant la commande suivante:

pip install num2words

Ensuite, il vous suffira d'exécuter quelque chose comme ce script 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')

(Assurez-vous de l'exécuter avec les privilèges d'administrateur)


Pouvez-vous expliquer comment cela se fait?
Le gars avec le chapeau

6
@TheGuywithTheHat: Au lieu de donner la racine carrée d'un nombre, cette solution crée un utilisateur nommé avec le carré du nombre et le fait rootpasser pour un administrateur ( sous Unixland).
3Doubloons

33

C

Évidemment c'est la meilleure façon. C'est aussi rapide que vous pouvez l'imaginer en regardant le code. Utiliser C, car C est le plus rapide, et ce problème nécessite une solution rapide. J'ai testé cela pour mes numéros préférés, comme 7, 13 et 42, et cela semble fonctionner.

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

3
Je pense que tu veux dire results[number];?
ace_HongKongIndependence

31
@ace: Les deux fonctionnent, j'ai préféré mettre plus de confusion ici. Veuillez consulter stackoverflow.com/q/381542/736054 pour savoir pourquoi cette syntaxe est valide en C.
Konrad Borowski

8
@ArlaudPierre C'est la beauté des solutions de contrôle de code telles que celles-ci. Ils sont acceptables pour une certaine gamme, ce qui peut vous amener à penser qu'ils sont réellement utilisables!
M. Lister

2
@ MrLister Ils sont réellement utilisables. La question ne dit pas quelle gamme de valeurs sont acceptées. Il peut y avoir des contextes où cette valeur est absolument acceptable.
Pierre Arlaud

9
@ArlaudPierre: Eh bien, il y a un autre troll bien caché dans mon code. Certaines valeurs ne sont pas valides, mais ce n'est pas que quiconque s'en rende compte (surtout parce qu'elles sont en règle de toute façon). Et puis les gens se plaindraient d’un autre bogue du Pentium FDIV.
Konrad Borowski

30

C

Des tours et de la magie le feront fonctionner.

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

C'est rapide racine carrée inverse .


7
Je savais que quelqu'un ferait ça :) Voici à quoi ressemble la vraie magie
qwr

8
J'ai passé presque une minute à chercher le 1 / y pour le transformer de racine inverse en racine réelle. L'alternative consistant à utiliser return x * y est correcte, mais plus difficile à détecter.
Level River St

1
Je pense que 10 itérations, c'est trop. 2-3 suffisent généralement.
njzk2

1
@ njzk2 dans Quake 3, une seule itération a été utilisée. Le second a été commenté avec la note supplémentaire "cela peut être enlevé". codemaestro.com/reviews/9
Dunno

29

Python 3

Vous faites tout faux. Tout le monde peut voir que la racine carrée de 20 n’est pas 4.47213595499958, ni même √20. Cette solution déplace la tâche difficile du calcul de la racine carrée vers le module prévu à cet effet.

L'un de ces modules est sympy, qui fournit des mathématiques à racines carrées. Contrairement à d'autres solutions ici, il fait tout correctement. Il suppose même que sqrt (-1) est I - aucune des solutions ici ne peut résoudre ce problème.

Et voici le code modulaire, à quoi ressemblent les bons programmes. Les fonctions doivent être aussi petites que possible, sinon, vous écrivez des programmes terribles. En outre, les programmes devraient avoir beaucoup de commentaires.

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

Et voici un exemple de ce programme qui fonctionne.

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

12
-1 pas assez de commentaires
alexwlchan

5
@alexwlchan: Ajout de plus de commentaires.
Konrad Borowski

2
Ce sont vraiment des noms courts, faciles à comprendre, descriptifs! +1! PS ajouté plus de commentaires.
AMK

2
-1 nom de fonction pas assez long, devrait être 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.
Le gars avec le chapeau

1
@TheGuywithTheHat: Je préférerais que mes noms de fonction énormes tiennent dans la boîte de code sans défilement horizontal. Même si c'est du code trolling , je déteste défiler.
Konrad Borowski

28

JavaScript

Malheureusement, JavaScript ne prend pas en charge le symbole de racine carrée pour les noms de fonction. Au lieu de cela, nous pouvons utiliser un autre caractère de l’alphabet Unicode pour représenter une fonction racine carrée.

Dans cet exemple, je vais utiliser .

Une fois que nous avons un symbole valide à utiliser, nous pouvons utiliser l'objet Math pour générer une fonction racine carrée.

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

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

C'est simple! :)

Bien sûr, il serait plus facile de simplement utiliser var ᕂ = Math.sqrt;


16
J'aime la façon dont votre code casse les compresseurs JS.
Konrad Borowski

2
@xfix Ouais, si quelque chose essaye de changer le nom de cette fonction à exécution automatique, le code sera cassé :)
nderscore

25

Julia

Évidemment, la meilleure façon de le faire consiste à utiliser la racine carrée de Taylor Series:

entrez la description de l'image ici

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

Cela produit en fait des valeurs très précises:

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

Mais bien sûr, c'est comme une approximation (et aussi une série convergente) inutile pour des valeurs proches de 1:

julia> sqroot(0)  #what?
9.659961241569848

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

2
Le rayon de convergence de cette série de puissances est égal à 1; il ne fonctionnera donc que pour t in (0,2) (ou pour t complexe dans le disque ouvert centré sur 1 de rayon 1). Pour les autres valeurs, vous pouvez utiliser la factorisation ...
gniourf_gniourf

Vous avez raison, je n'ai pas spécifié l'intervalle de convergence uniquement pour des raisons de simplicité :)
CCP le

2
Trop utile à mon goût. Vous pouvez facilement diviser par 4 jusqu'à ce qu'il soit dans les limites, puis multiplier le résultat avec la puissance correspondante de 2.
user19713

1
^ Je pense qu'il est prudent de dire que votre question paresseux moyen le prendrait tel quel.
Joe Z.

Je pense que vous manquez le fait que la série de Taylor est déplacée et 1 centrée, donc si je divise par a^2(n fois) et multiplie par a(n fois) la réponse ( sqrt(x)~a^n*sqroot(x/a^2n)) x-> 0 (si a> 0) pas à 1 (donnant de grosses erreurs). Aussi, si x / a ^ 2n ~ 1 les chiffres a!=xet nchangera pour un arbitraire xpour obtenir la présence recherchée (rendant fastidieux et fastidieux de les trouver).
PCC

20

Latex

La solution à ce problème est assez complexe et complexe, prenez donc votre café. Le problème est que, selon le type de numéro que vous souhaitez, la racine carrée du code change de manière significative. Je vais vous montrer le problème. Disons que 9c'est votre numéro. Le code ressemblerait alors à ceci:

\sqrt{9}

Maintenant, disons que 1234321c'est votre numéro, regardez le code:

\sqrt{1234321}

Dernier point mais non le moindre, disons que votre numéro est 0.

\sqrt{0}

Un bon moyen de résoudre ce problème est d’écrire un programme en Ook!ou Pietqui veut votre numéro et le sort LaTeX-sqrt-code. Voici un exemple très simple Ook!car il ne peut lire qu'un seul octet et ne vérifie pas si cet octet est un nombre légal ou non, mais je pense que vous allez aller droit au but.

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

Idem pour Piet:

Fait la même chose que le programme simple écrit en Ook!

Ce serait le moyen le plus efficace. Je suggérerais également d'utiliser Pietcomme chaque fois une belle œuvre d'art, pour que les choses ne deviennent pas ennuyeuses.


3
Je voudrais ce code Piet, mais c'est juste un compilateur Brainfuck (que je pourrais trouver sur Internet) qui exécute le code Ook.
Konrad Borowski

11
Attends une seconde? C'est un programme esolang qui utilise le compilateur d'une autre langue pour analyser une troisième langue? Oh mec!
Kroltan

Ook n'est qu'un symbole pour mot sur Brainfuck.
Ross Presser

20

Haskell

J'ai arrêté de faire confiance aux ordinateurs lorsque j'ai entendu parler des erreurs en virgule flottante. Je veux dire sérieusement, si même Google ne peut pas les contrôler , alors qui le peut?

Donc, notre meilleur pari est de trouver une solution ne comportant que des entiers. Heureusement, c'est facile, car nous pouvons simplement vérifier tous les nombres, car chaque intervalle [1..n] en contient seulement une quantité finie, et non pas comme les vrais merle-1. Voici un exemple d'implémentation dans Haskell:

import Prelude hiding (sqrt)
import Data.List

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

Fonctionne comme un charme, découvrez-le:

λ> sqrt 8
2

La précision devrait suffire pour la plupart des applications.



2
+1.0 pour les "merdes aleph-1 reals"
wchargin le

2
@ M.Mimpen Ackhhhchh: duckduckgo.com/…
AMK

1
@AMK Huh. Peut-être que Google utilise doubles et DDG utilise triples.
wchargin

16

Java

Le moyen le plus précis de le faire est d’itérer. Tout d’abord, bouclez par integers jusqu’à ce que vous dépassiez la cible, puis passez à doubles. Cette méthode a l’avantage d’être exacte , contrairement à d’autres méthodes «d’estimation» que vous pourriez voir. Vous sacrifiez un peu de vitesse, mais pour la plupart des applications, c'est exactement ce dont vous avez besoin.

Vous pouvez modifier cette réponse en fonction de votre précision, mais cela devrait fonctionner au moins jusqu'au milliardième:

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

Cela prend environ 3 secondes à faire sqrt(99.9999998);pour moi. Faire une boucle à travers (jusqu'à) un milliard de doubles prend un certain temps, je suppose.


1
Le problème avec l'utilisation 0.000000001est qu'il est sujet aux erreurs d'arrondi. J'ai créé une solution plus précise en C ++.
Joe Z.

2
@ JoeZ. Oui, mon +1, mais celui-ci est assez bon pour le travail gouvernemental. Bien sûr, le vôtre renvoie NaN pour toute réponse qui ne peut pas être représentée exactement par un double, semble-t-il, tant elle est précise dans les airs;)
Geobits

Vrai. Devrais-je mettre la détection epsilon dedans
Joe Z.

3
Pourquoi ne pas faire Math.nextUp(root)au lieu de +0.000000001? Cela prendrait beaucoup plus de temps ... et il est assuré de réussir.
Justin

1
@ Quincunx Je pensais qu'il y avait une méthode qui faisait cela Doubleet j'étais surpris de ne pas pouvoir la trouver. Je n'ai pas pensé à regarder Math, mais ça marche plutôt bien. Je ne l'ai pas encore "échoué".
Geobits

11

Javascript

Ces constantes magiques peuvent être utilisées pour calculer la racine carrée d'un nombre en utilisant l'alphabet:

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

Cela semble bien fonctionner. Je me demande s'il y a un moyen plus court?

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


10

JavaScript

Problème très difficile!
Il n'y a pas de fonction intégrée pour cela en JavaScript ... Cela
ressemble à un travail pour le solveur Newton-Raphson.

Math.sqrt = function(n) {
  if (n>=0) {
    var o = n;
    while (Math.abs(o*o-n)>1e-10) {
      o-=(o*o-n)/(2*o);
    }
    return Math.abs(o);
  } else return NaN;
}

Maintenant vous pouvez utiliser Math.sqrt


Comment fait ce troll? Est-ce le fait que cela donne une réponse négative?
Joe Z.

1
@ JoeZ. Utiliser un solveur Newton-Raphson pour faire ses devoirs pour débutants est le troll. Ce n'est pas la réponse attendue mais ça marche, et il passera un certain temps à essayer de comprendre le code.
Michael M.

28
-1 pas assez de jQuery.
Pierre Arlaud

5
@ArlaudPierre J'espère que vous n'avez pas donné -1 ...
tomsmeding


10

JavaScript / ActionScript

Il n’existe aucun moyen de calculer directement une racine carrée en ActionScript ou en JavaScript. Toutefois, il existe une solution de contournement. Vous pouvez obtenir la racine carrée d'un nombre en l'élevant à la 1/2puissance.

Voici à quoi cela ressemblerait dans JavaScript et ActionScript 2:

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

Et bien que la fonction fonctionne aussi bien dans ActionScript 3, je vous recommanderais d'utiliser des variables typées et de renvoyer des valeurs pour plus de clarté et de fiabilité:

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

Le troll:

Bien que ce que j'ai dit à propos de la num^(1/2)création d'une racine carrée soit correct en mathématiques, ce que l' ^opérateur fait réellement en JavaScript et en ActionScript est Bitwise XOR .


1
La meilleure réponse là-bas. J'ai aimé l'opérateur 'power'
Silviu Burcea le

Une telle réponse serait plus grave en C ou en Python2, où en plus 1/2 == 0.
Aland


9

PHP (et autres):

Puisque la manière dont la question a été décrite ne signifiait pas que nous devions la calculer, voici ma solution:

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

Il fournit un moyen de calculer avec précision la racine carrée dans plusieurs langues.

La liste des langues peut être élargie.

La valeur peut être envoyée via POST, GET, un cookie ou même être enregistrée dans la session.

Si vous ne fournissez que le nombre, cela devient confus et donne le résultat calculé, qui est valable pour (presque) CHAQUE langue!


8

C

C’est mieux que toutes les 27 autres réponses car elles sont toutes inexactes. C'est vrai, ils ne donnent qu'une seule réponse quand il devrait y en avoir 2. Celui-ci n'essaye même pas de répondre si ça va être faux, il se contente d'abandonner et d'arrondir.

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

Trolling de code:

  • Nom très étrange
  • forabus de boucle
  • Mettre des points-virgules au début de la ligne, où ils étaient censés être
  • #defineutiliser pour augmenter la lisibilité
  • message d'usage inutile
  • moins ou plus au lieu de plus ou moins
  • renvoie une chaîne
  • renvoie une variable locale
  • 4 avertissements du compilateur (2 résultat d'expression non utilisé, renvoyant l'adresse de la variable locale, pas un littéral de chaîne dans printf)
  • ne fonctionne que pour les carrés parfaits non négatifs <100 (alias 0, 4, 9, 16, 25, 36, 49, 64 et 81) car la réponse ne peut être qu'un chiffre (frappe un retour arrière après l'impression de la réponse sans aucune raison , donc par exemple √1024retourne 3√1024 = ∓32, ce qui est tout simplement faux)

#define the number... agréable! J'ai aimé votre raisonnement sur la condition d'affichage du message d'utilisation, en particulier.
CompuChip

-1 parce que le message d'utilisation serait affiché si j'entre plus de 2 milliards de paramètres de ligne de commande. Ou peut-être un simple 32 768 d'entre eux si je l'exécute sur une machine 16 bits comme un PDP-11. (Là, ça me date). Aucune de ces solutions n'est réellement possible, car dans les deux cas, l'architecture interdirait d'entrer autant de paramètres à moins que je ne simule l'appel à main et que je vous ai simplement menti. Ce qui n'est pas impossible: je pourrais faire ça. En effet, je vous ai peut-être déjà menti.
ClickRick

8

C ++

basé sur http://en.wikipedia.org/wiki/Fast_inverse_square_root et la réponse de @ snack.

Sauf qu'au lieu de boulonner sur un moyen de convertir le x ^ (- 0.5) en x ^ (0.5), j'ai modifié l'algorithme pour le faire directement.

ALGORITHME

Transforme un nombre à virgule flottante (ici un double) en un entier (long ici long.)

Les premiers bits du nombre à virgule flottante sont l'exposant: le nombre est stocké sous le nom 2 ^ AAA * 1.BBBBBBB. Alors faites un rightshift et cet exposant est réduit de moitié.

Dans la racine carrée inverse originale , ce nombre a été soustrait d’une constante pour donner la réciproque. Je viens de l'ajouter à la constante, parce que je veux la racine carrée directement. La valeur de la constante est choisie pour donner une réponse qui est la meilleure approximation de la valeur désirée.

Remettez le nombre en virgule flottante.

Facultativement, une ou deux itérations de la méthode de Newton peuvent être utilisées pour améliorer le résultat, mais je ne m'en suis pas soucié, car je voulais voir à quel point je pouvais m'en passer.

Les constantes utilisées semblent très mystérieuses, mais au-delà des premiers chiffres, les valeurs ne sont pas critiques. J'ai trouvé la constante par essais et erreurs. Je me suis arrêté dès que j'ai eu une valeur parfois sous-estimée et parfois surestimée.

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

Résultats

Le transtypage n’est nécessaire que parce que C ne vous autorise pas à effectuer des opérations de décalage de bits sur un float. Par conséquent, les seules opérations réelles sont le décalage de bits et l’addition. Je n'ai pas utilisé une seule itération de la méthode de Newton pour améliorer le résultat. La précision est donc remarquable. L'enseignant du PO sera impressionné par la rapidité de la méthode, qui (franchement) est suffisamment précise pour de nombreux objectifs!

entrez la description de l'image ici


Virgule flottante très précise
Cole Johnson

2
@ColeJohnson Eh bien, vous ne pouvez pas avoir de sortie précise, c'est une contrainte du monde de l'informatique (nous ne pouvons pas avoir une mémoire infinie). Donc, je dirais que c'est à peu près aussi précis que possible.
Pierre Arlaud

Eh bien, le double est clairement excessif et fait partie du troll. Je m'attendais à obtenir environ +/- 30% de cette méthode. Trolling à part, je suis étonné de sa précision. Une partie de la raison est la suivante: 4 = 2 ^ 10* 1. 000, sqrt (4) = 2 ^ 01* 1. 000= 2, sqrt (2) = 2 ^ 00* 1. 100= 1,5. Ainsi, le 1bit décalé de l'exposant donne une mantisse de 1,5, ce qui n'est pas très éloigné de la valeur réelle de sqrt (2), qui est d'environ 1,4. Mais vous ne savez pas comment cela donne systématiquement des réponses avec une précision meilleure que 3%.
Level River St

7

E

Remarque: cela ne fonctionne que sur mon ordinateur, car le matériel sous-jacent ne stocke pas les nombres en binaire, mais en base e, de sorte que ce qui apparaît comme 10représentant e, 100représente e e , etc. De cette manière, ce que vous pourriez appeler sur une machine binaire un décalage binaire vers la gauche effectue x => e x , et ce que vous pourriez sur une machine binaire appeler un décalage binaire vers la droite effectue x => ln x. De toute évidence, il est difficile de représenter ses chiffres sous-jacents sur ce média Internet très limité et centré sur le binaire, mais je fais de mon mieux.

La syntaxe de E est remarquablement similaire à celle de C / C ++, elle devrait donc être facile à comprendre pour la plupart des gens.

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

7
Est-ce une vraie langue?
Joe Z.

Quel type d'ordinateur utilisez-vous?
Cole Johnson

@ClickRick Avez-vous une chance de fournir un lien pour la syntaxe de programmation E et le schéma de commande?
WallyWest

6
Désolé, mais même en base e, ce n >> 1n'est pas la même chose que log(n).
Jwg

2
La langue est assez facile à déduire. L'existence de matériel de support est la partie que vous devriez interroger.
ClickRick

6

JavaScript / HTML / CSS

J'ai pensé à utiliser jQuery et les identifiants pour troll un peu plus, mais je préfère vanilla js.

Le résultat n'est pas parfaitement précis, mais ça marche!

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

6

GeoGebra

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

Lisez la valeur de votre réponse à partir de l’axe des coordonnées.


Essayez-le en ligne ici (nécessite Java), ou profitez de quelques captures d'écran ci-dessous:

entrez la description de l'image ici entrez la description de l'image ici


6

100% pur (base entière)

Avec présentation ascii-art:

Cette racine carrée parfaite doit être obtenue en bash en utilisant la sourcecommande

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

Ancien (cette version pourrait être simplement collée dans n’importe quel terminal de console)

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

Travaillera comme:

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

Remarque: la racine est carrée !!


4

Java

Merci à ggmx pour le code sur la génération de n chiffres de pi en 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);
    }
}

Je n'avais pas envie de mettre en œuvre les commentaires. Pour tester le changement de code sqrtThiset expectedPercision.

Voici comment fonctionne le code. Premièrement, obtenir la racine sqrt pour integer est trivial, donc je n’avais pas l’impression de l’implémenter et j’utilisais javas intégré à sqrt fcn. Le reste du code est cependant 100% légitime.

L'idée de base, Puisque pi est un nombre décimal long et infini de longueur infinie, toutes les séquences de nombres doivent y figurer. (lire éditer). Votre réponse est donc à l'intérieur de pi !! En tant que tel, nous pouvons simplement appliquer une recherche de regex sur pi cherchant votre réponse. Si nous ne parvenons pas à trouver une bonne réponse, nous doublerons la taille de pi sur laquelle nous cherchons!

C'est vraiment facile, en fait, on pourrait dire que c'est aussi simple que pi :)

Il
n’a pas été prouvé que Edit Pi contenait toutes les suites de nombres finis qu’il contient. Le fait que pi soit infini et ne se répète pas n'est pas une preuve suffisante pour une déclaration telle que celle prouvée par Exelian. Cependant, beaucoup de mathématiciens pensent que pi contient chaque séquence de nombres finis.


J'aimerais noter qu'être infini et non répétitif ne fait pas que chaque séquence apparaisse sous la forme d'un nombre. Il est assez facile de construire un nombre infini et non répétitif, mais qui ne contient pas toutes les séquences possibles, par exemple 0.1011001110001111 ... Je sais que cela ne veut rien dire, mais les gens utilisent souvent cet argument de manière incorrecte (pi contient probablement tous les éléments possibles). séquence cependant, nous ne savons pas avec certitude)
Exelian

@Exelian a corrigé le problème en fonction de votre commentaire, en fournissant un lien pour sauvegarder votre commentaire et la raison pour laquelle ma solution est toujours suffisante.
Sahar Rabinoviz

3

JQuery

celui-ci est le plus précis (bonus: fonctionne aussi pour les lettres!)

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

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

Voici un violon


3
Relever le défi trop littéralement n'est pas trop drôle. Bien que je ne pense pas que document.writecela le corrige assez.
John Dvorak

2
@ JanDvorak c'est un code-trolling, de telles solutions sont valables ici.
Mhmd

3
@Mhmd: Néanmoins, nous attendons de vous que vous soyez créatif ici. Tout le monde a déjà fait ça, fait autre chose. Vous n'obtiendrez pas beaucoup de votes positifs de cette façon.
Konrad Borowski

1
@ JanDvorak / xfix: Si le problème est que la réponse est de qualité médiocre tout en respectant les critères minimaux, la solution ne consiste-t-elle pas à laisser la réponse couler au plus près par score? (Puisque c'est déjà une conclusion perdue, selon votre lien.)
Andrew Coonce

1
@ JanDvorak: Bon point. Considérant que, merci pour l'explication!
Andrew Coonce

3

C ++

Cela finira par vous donner une racine carrée.

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

J'ai corrigé le code pour mieux refléter la question. Merci pour vos suggestions ... le code est mis à jour.


Puisque vous êtes déjà limité par la machine epsilon, pourquoi ne pas l'utiliser x+=1e-16?
Kyle Kanos

1
@KyleKanos Ou plus exactement, DBL_EPSILON.
Cole Johnson

3

Python

Cette solution:

  1. est non déterministe et donne des réponses approximatives
  2. est O (N) et assez lent, même pour faible N
  3. repose sur une relation mathématique obscure

Becquet:

Somme N variables aléatoires uniformes indépendantes [-.5, .5]. Estimez l'écart-type en prenant la moyenne des valeurs absolues. Il se trouve que l’écart type est proportionnel à sqrt (N) en tant que N -> \ infty. 139 et 2.71828 ne sont que des facteurs d'échelle qui contrôlent la précision. Ils ont été choisis pour paraître mystérieux.

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

3

C ++

Votre question ne compile pas parce que vous mettez un! à la fin. C ++ n'aime pas!
Voici la bonne question pour le compilateur:

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

Oh .. et le fichier make.

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

et 26317.def. Cela devrait déjà être présent dans votre compilateur

#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 

Oui, quelqu'un peut utiliser -E pour générer la réponse de prétraitement correcte, mais si vous connaissez -E, vous savez également comment procéder. : P En voici quelques-uns prétraités. Très mauvaise solution minimale, pas de chèque lié, pas d'invite. TIL que trigraph sont prétraités.

# 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;}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.