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
source
— 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
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
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
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
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
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
— 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
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
source
1
47 octets ; modifier: Merci, mais crédit @JungHwanMin pour avoir trouvé cela.
— Stan Strum
— Olivier Grégoire
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
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
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
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
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
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
source
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.