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 , donc la réponse la plus courte en octets l'emporte.



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

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

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

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!


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


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



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


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!


1
47 octets ; modifier: Merci, mais crédit @JungHwanMin pour avoir trouvé cela.
Stan Strum



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!


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

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.


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

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

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

cela ne devrait-il pas être le sol au lieu du plafond?
mudkip201

@ mudkip201 Mis à jour, merci
ovs

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.