Mes carrés approximatifs

10

Inspiré par cette vidéo de tecmath .

Une approximation de la racine carrée de n'importe quel nombre xpeut être trouvée en prenant la racine carrée entière s(c'est-à-dire le plus grand entier tel que s * s ≤ x), puis en calculant s + (x - s^2) / (2 * s). Appelons cette approximation S(x). (Remarque: cela équivaut à appliquer une étape de la méthode Newton-Raphson).

Bien que cela ait une bizarrerie, où S (n ^ 2 - 1) sera toujours √ (n ^ 2), mais généralement il sera très précis. Dans certains cas plus importants, cela peut avoir une précision> 99,99%.

Entrée et sortie

Vous prendrez un numéro dans n'importe quel format pratique.

Exemples

Format: entrée -> sortie

2 -> 1.50
5 -> 2.25
15 -> 4.00
19 -> 4.37               // actually 4.37       + 1/200
27 -> 5.20
39 -> 6.25
47 -> 6.91               // actually 6.91       + 1/300
57 -> 7.57               // actually 7.57       + 1/700
2612 -> 51.10            // actually 51.10      + 2/255
643545345 -> 25368.19    // actually 25,368.19  + 250,000,000/45,113,102,859
35235234236 -> 187710.50 // actually 187,710.50 + 500,000,000/77,374,278,481

Caractéristiques

  • Votre résultat doit être arrondi au moins au centième près (c.-à-d. Si la réponse est 47.2851, vous pouvez produire 47.29)

  • Votre sortie n'a pas besoin d'avoir des zéros suivants et une virgule décimale si la réponse est un nombre entier (c'est-à-dire que 125,00 peut également être sorti en 125 et 125,0)

  • Vous n'êtes pas obligé de prendre en charge les nombres inférieurs à 1.

  • Vous n'avez pas à prendre en charge les entrées non entières. (ie. 1.52 etc ...)

Règles

Les échappatoires standard sont interdites.

C'est un code-golf , donc la réponse la plus courte en octets l'emporte.

code-golf math approximation Stan Strum
la source
Sandbox
Stan Strum
3
Remarque:s + (x - s^2) / (2 * s) == (x + s^2) / (2 * s)
JungHwan Min
Mes solutions: Pyth , 25 octets ; 14 octets
Stan Strum
Doit-il être précis à au moins 2 chiffres?
2017 totalement humain à 1h01
@totallyhuman Oui. 47.2851 peut être représenté comme 47.28, mais pas plus inexact.
Stan Strum

Réponses:

2

Gelée ,  8  7 octets

-1 octet grâce à la formule mathématique simplifiée d' Olivier Grégoire - voir leur réponse Java .

÷ƽ+ƽH

Essayez-le en ligne!

Comment?

÷ƽ+ƽH - Link: number, n
 ƽ     - integer square root of n  -> s
÷       - divide                    -> n / s
    ƽ  - integer square root of n  -> s
   +    - add                       -> n / s + s
      H - halve                     -> (n / s + s) / 2
Jonathan Allan
la source
7 octets: ÷ƽ+ƽHpremière fois que j'utilise Jelly, je me trompe peut-être. J'aimerais bien savoir comment stocker ƽ, pour ne pas le répéter. Cela pourrait économiser un autre octet.
Olivier Grégoire
Merci @ OlivierGrégoire! ƽɓ÷⁹+Hne recalculerait pas la racine entière, mais c'est aussi 7. ɓdémarre une nouvelle chaîne dyadique avec des arguments échangés et ⁹fait ensuite référence au bon argument de cette chaîne (c'est-à-dire le résultat de ƽ). ƽɓ÷+⁹Hfonctionnerait ici aussi.
Jonathan Allan,
4

Haskell , 34 octets

f x=last[s+x/s|s<-[1..x],s*s<=x]/2

Essayez-le en ligne!

Explication en pseudocode impératif:

results=[]
foreach s in [1..x]:
 if s*s<=x:
  results.append(s+x/s)
return results[end]/2
Leo
la source
4

Java (OpenJDK 8) , 32 octets

n->(n/(n=(int)Math.sqrt(n))+n)/2

Essayez-le en ligne!

Explications

Le code est équivalent à ceci:

double approx_sqrt(double x) {
  double s = (int)Math.sqrt(x);  // assign the root integer to s
  return (x / s + s) / 2
}

Les maths derrière:

s + (x - s²) / (2 * s)  =  (2 * s² + x - s²) / (2 * s)
                        =  (x + s²) / (2 * s)
                        =  (x + s²) / s / 2
                        =  ((x + s²) / s) / 2
                        =  (x / s + s² / s) / 2
                        =  (x / s + s) / 2
Olivier Grégoire
la source
Cela ne semble pas gérer la spécification: votre sortie doit être arrondie au moins au centième près
Ayb4btu
2
Eh bien, il est arrondi à une valeur inférieure au centième le plus proche, il est donc totalement valide.
Olivier Grégoire
Ah, je vois, mon malentendu.
Ayb4btu
4

Python 2 , 47 ... 36 octets

-3 octets grâce à @JungHwanMin
-1 octet grâce à @HyperNeutrino
-2 octets grâce à @JonathanFrech
-3 octets grâce à @ OlivierGrégoire

def f(x):s=int(x**.5);print(x/s+s)/2

Essayez-le en ligne!

ovs
la source
-2 octets: s+(x-s*s)/s/2à(x+s*s)/s/2
JungHwan Min
-2 octets en utilisant une fonction
HyperNeutrino
@HyperNeutrino je reçois seulement -1 octet
ovs
Oh désolé, j'ai accidentellement supprimé un caractère après le test, puis j'ai compté les octets après: P ouais juste -1
HyperNeutrino
Ne pouvez-vous pas omettre +.0et remplacer /s/2par /2./s, en économisant deux octets?
Jonathan Frech
3

R, 43 octets 29 octets

x=scan()
(x/(s=x^.5%/%1)+s)/2

Merci à @Giuseppe pour la nouvelle équation et aide au golf de 12 octets avec la solution de division entière. En échangeant l'appel de fonction pour l'analyse, j'ai joué à un autre couple d'octets.

Essayez-le en ligne!

marque
la source
1
35 octets ; plus généralement, vous pouvez utiliser le champ "en-tête" de TIO et mettre un f <- pour affecter la fonction. Mais quand même, bonne solution, assurez-vous de lire les conseils pour jouer au golf en R lorsque vous en aurez l'occasion!
Giuseppe
1
31 octets en utilisant la formule d'Oliver Gregoire
Giuseppe
2

JavaScript (ES7), 22 octets

x=>(s=x**.5|0)/2+x/s/2

Nous n'avons pas vraiment besoin d'une variable intermédiaire, donc cela peut en fait être réécrit comme:

x=>x/(x=x**.5|0)/2+x/2

Cas de test

Afficher l'extrait de code

Arnauld
la source
2

C, 34 octets

Merci à @Olivier Grégoire!

s;
#define f(x)(x/(s=sqrt(x))+s)/2

Fonctionne uniquement avec des floatentrées.

Essayez-le en ligne!

C,  41   39  37 octets

s;
#define f(x).5/(s=sqrt(x))*(x+s*s)

Essayez-le en ligne!

C,  49   47   45  43 octets

s;float f(x){return.5/(s=sqrt(x))*(x+s*s);}

Essayez-le en ligne!

Merci à @JungHwan Min pour avoir économisé deux octets!

Steadybox
la source
1
47 octets ; modifier: Merci, mais crédit @JungHwanMin pour avoir trouvé cela.
Stan Strum
34 octets
Olivier Grégoire
2

Haskell , 40 octets

Un autre octroie la poussière grâce à H.PWiz.

f n|s<-realToFrac$floor$sqrt n=s/2+n/s/2

Essayez-le en ligne!

totalement humain
la source
2

AWK , 47 44 38 octets

{s=int($1^.5);printf"%.2f",$1/2/s+s/2}

Essayez-le en ligne!

REMARQUE: le TIO like a 2 octets supplémentaires pour \n rendre la sortie plus jolie. :)

Cela ressemble à tricher un peu pour utiliser sqrt pour trouver la racine carrée, alors voici une version avec quelques octets de plus qui ne le fait pas.

{for(;++s*s<=$1;);s--;printf("%.3f\n",s+($1-s*s)/(2*s))}

Essayez-le en ligne!

Robert Benson
la source
1
on pourrait dire que c'est AWKward. Je vais me montrer. edit: à l'origine, j'avais prévu que la question fuyait en utilisant sqrt, mais il y avait trop de réponses et j'obtiendrais un délit si je le change pour que mon idée originale fonctionne.
Stan Strum
Les jeux de mots 'AWK' sont amusants :)
Robert Benson
au lieu de sqrt($1)vous pouvez utiliser$1^.5
Cabbie407
Merci @ Cabbie407 ne sais pas pourquoi je n'y ai pas pensé.
Robert Benson
1
Je vous en prie. Quelques autres choses: vous n'avez pas besoin de \npour obtenir la sortie, le printf dans awk n'a pas besoin de parenthèses et la formule peut être raccourcie s/2+$1/s/2, ce qui se traduit par {s=int($1^.5);printf"%.2f",s/2+$1/s/2}. Désolé si ce commentaire vous semble grossier.
Cabbie407
1

Raquette , 92 octets

Merci à @JungHwan Min pour l'astuce dans la section commentaire

(λ(x)(let([s(integer-sqrt x)])(~r(exact->inexact(/(+ x(* s s))(* 2 s)))#:precision'(= 2))))

Essayez-le en ligne!

Non golfé

(define(fun x)
  (let ([square (integer-sqrt x)])
    (~r (exact->inexact (/ (+ x (* square square)) (* 2 square)))
        #:precision'(= 2))))
Rodrigo Ruiz Murguía
la source
1

PowerShell , 54 octets

param($x)($x+($s=(1..$x|?{$_*$_-le$x})[-1])*$s)/(2*$s)

Essayez-le en ligne!ou vérifier certains cas de test

Prend des informations $xpuis fait exactement ce qui est demandé. La |?partie trouve l'entier maximal qui, lorsqu'il est au carré, est -less-than-or- equal à l'entrée $x, puis nous effectuons les calculs requis. La sortie est implicite.

AdmBorkBork
la source
Sensationnel. Je n'ai jamais pu comprendre comment les gens jouent au golf dans Windows Powershell
Stan Strum
@StanStrum Vous n'êtes pas seul, lol. : D
AdmBorkBork
1

Coque , 9 octets

½Ṡ§+K/(⌊√

Essayez-le en ligne!

Il y a encore quelque chose de laid dans cette réponse, mais je n'arrive pas à trouver une solution plus courte.

Explication

J'implémente une étape de l'algorithme de Newton (qui est en effet équivalent à celui proposé dans cette question)

½Ṡ§+K/(⌊√
  §+K/       A function which takes two numbers s and x, and returns s+x/s
 Ṡ           Call this function with the input as second argument and
      (⌊√    the floor of the square-root of the input as first argument
½            Halve the final result
Leo
la source
Je pense que vous voulez une division réelle, plutôt que÷
H.PWiz
@ H.PWiz whoops, je fais, merci. C'était un vestige d'une expérience pour trouver d'autres solutions
Leo
1

Pyt , 11 10 octets

←Đ√⌊Đ↔⇹/+₂

Explication

code                explanation                        stack
←                   get input                          [input]
 Đ                  duplicate ToS                      [input,input]
  √⌊                calculate s                        [input,s]
    Đ               duplicate ToS                      [input,s,s]
     ↔              reverse stack                      [s,s,input]
      ⇹             swap ToS and SoS                   [s,input,s]
       /            divide                             [s,input/s]
        +           add                                [s+input/s]
         ₂          halve                              [(s+input/s)/2]
                    implicit print
mudkip201
la source
Je viens de voir ça et ce fut une bonne minute jusqu'à ce que je réalise que ce n'est pas Pyth. Très bonne réponse.
Stan Strum
Oui, c'est un petit langage auquel je pense depuis un moment et que je viens de décider de faire.
mudkip201
Le ToS est-il top-of-stack ... et si oui, qu'est-ce que le SoS?
Stan Strum,
ToS est au sommet de la pile, et SoS est deuxième sur la pile
mudkip201
Bien, je vais voir si je peux me plonger dans cette langue; Je l'aime!
Stan Strum
1

Voie lactée , 17 14 octets

-3 octets en utilisant la formule d'Olivier Grégoire

^^':2;g:>/+2/!

Essayez-le en ligne!

Explication

code              explanation                   stack layout

^^                clear preinitialized stack    []
  ':              push input and duplicate it   [input, input]
    2;            push 2 and swap ToS and SoS   [input, 2, input]
      g           nth root                      [input, s=floor(sqrt(input))]
       :          duplicate ToS                 [input, s, s]
        >         rotate stack right            [s, input, s]
         /        divide                        [s, input/s]
          +       add                           [s+input/s]
           2/     divide by 2                   [(s+input/s)/2]
             !    output                        => (s+input/s)/2
ovs
la source
cela ne devrait-il pas être le sol au lieu du plafond?
mudkip201
@ mudkip201 Mis à jour, merci
ovs