Ungefähre meine Quadrate

10

Inspiriert von diesem Video von tecmath .

Eine Annäherung an die Quadratwurzel einer beliebigen Zahl xkann gefunden werden, indem die ganzzahlige Quadratwurzel s(dh die größte ganze Zahl so s * s ≤ x) genommen und dann berechnet wird s + (x - s^2) / (2 * s). Nennen wir diese Annäherung S(x). (Hinweis: Dies entspricht der Anwendung eines Schritts der Newton-Raphson-Methode.)

Dies hat zwar eine Eigenart, wobei S (n ^ 2 - 1) immer √ (n ^ 2) ist, aber im Allgemeinen ist es sehr genau. In einigen größeren Fällen kann dies eine Genauigkeit von> 99,99% haben.

Ein- und Ausgabe

Sie nehmen eine Nummer in einem beliebigen Format.

Beispiele

Format: Eingabe -> Ausgabe

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

Spezifikationen

  • Ihre Ausgabe muss auf mindestens das nächste Hundertstel gerundet sein (dh wenn die Antwort 47,2851 lautet, können Sie 47,29 ausgeben).

  • Ihre Ausgabe muss keine folgenden Nullen und keinen Dezimalpunkt haben, wenn die Antwort eine ganze Zahl ist (dh 125,00 können auch als 125 und 125,0 ausgegeben werden).

  • Sie müssen keine Zahlen unter 1 unterstützen.

  • Sie müssen keine nicht ganzzahligen Eingaben unterstützen. (dh 1,52 etc ...)

Regeln

Standardlücken sind verboten.

Dies ist ein Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

code-golf  math  approximation 
— Stan Strum
quelle
— Stan Strum
3
Hinweis:s + (x - s^2) / (2 * s) == (x + s^2) / (2 * s)
— JungHwan Min
Meine Lösungen: Pyth , 25 Bytes ; 14 Bytes
— Stan Strum
Muss es auf mindestens 2 Stellen genau sein?
— totalmenschlich
@totallyhuman Ja. 47.2851 kann als 47.28 dargestellt werden, ist aber nicht mehr ungenau.
— Stan Strum

Antworten:

2

Gelee ,  8  7 Bytes

-1 Byte dank Olivier Grégoires vereinfachter mathematischer Formel - siehe ihre Java-Antwort .

÷ƽ+ƽH

Probieren Sie es online aus!

Wie?

÷ƽ+ƽ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
quelle
7 Bytes: ÷ƽ+ƽHIch habe zum ersten Mal versucht, Jelly zu verwenden, damit ich mich irre. Ich wünschte, ich wüsste, wie man es speichert ƽ, um es nicht zu wiederholen. Das könnte ein weiteres Byte sparen.
— Olivier Grégoire
Danke @ OlivierGrégoire! ƽɓ÷⁹+Hwürde die Ganzzahlwurzel nicht neu berechnen, aber es ist auch 7. ɓStartet eine neue dyadische Kette mit vertauschten Argumenten und ⁹verweist dann auf das richtige Argument dieser Kette (dh das Ergebnis von ƽ). ƽɓ÷+⁹Hwürde auch hier funktionieren.
— Jonathan Allan
4

Java (OpenJDK 8) , 32 Bytes

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

Probieren Sie es online aus!

Erklärungen

Der Code entspricht diesem:

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

Die Mathematik dahinter:

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
quelle
Dies scheint die Spezifikation nicht zu handhaben: Ihre Ausgabe muss auf mindestens das nächste Hundertstel gerundet sein
— Ayb4btu
2
Nun, es ist auf ein Hundertstel gerundet, also ist es absolut gültig.
— Olivier Grégoire
Ah, ich verstehe, mein Missverständnis.
— Ayb4btu
4

Python 2 , 47 ... 36 Bytes

-3 Bytes dank @JungHwanMin
-1 Bytes dank @HyperNeutrino
-2 Bytes dank @JonathanFrech
-3 Bytes dank @ OlivierGrégoire

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

Probieren Sie es online aus!

— ovs
quelle
-2 Bytes: s+(x-s*s)/s/2bis(x+s*s)/s/2
— JungHwan Min
-2 Bytes mit einer Funktion
— HyperNeutrino
@ HyperNeutrino Ich bekomme nur -1 Byte
— ovs
Oh, tut mir leid, ich habe versehentlich ein Zeichen nach dem Testen gelöscht und dann die Bytes gezählt nach: P yeah nur -1
— HyperNeutrino
Können Sie nicht auslassen +.0und ersetzen /s/2mit /2./s, spart zwei Bytes?
— Jonathan Frech
3

R, 43 Bytes, 29 Bytes

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

Vielen Dank an @Giuseppe für die neue Gleichung und die Hilfe beim Golfen von 12 Bytes mit der Integer Division-Lösung. Durch Austauschen des Funktionsaufrufs gegen Scannen habe ich noch ein paar Bytes gespielt.

Probieren Sie es online aus!

— Kennzeichen
quelle
1
35 Bytes ; Im Allgemeinen können Sie das Feld "Header" von TIO verwenden und ein eingeben f <- , um die Funktion zuzuweisen. Aber trotzdem, nette Lösung, lesen Sie unbedingt die Tipps zum Golfen in R, wenn Sie die Gelegenheit dazu haben!
— Giuseppe
1
— Giuseppe
2

JavaScript (ES7), 22 Byte

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

Wir brauchen eigentlich keine Zwischenvariable, daher kann diese tatsächlich wie folgt umgeschrieben werden:

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

Testfälle

Code-Snippet anzeigen

— Arnauld
quelle
2

C 34 Bytes

Vielen Dank an @Olivier Grégoire!

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

Funktioniert nur mit floatEingängen.

Probieren Sie es online aus!

C  41   39  37 Bytes

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

Probieren Sie es online aus!

C,  49   47   45  43 Bytes

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

Probieren Sie es online aus!

Vielen Dank an @JungHwan Min für das Speichern von zwei Bytes!

— Steadybox
quelle
1
47 Bytes ; edit: Danke, aber danke @JungHwanMin, dass du das gefunden hast.
— Stan Strum
— Olivier Grégoire
2

AWK , 47 44 38 Bytes

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

Probieren Sie es online aus!

HINWEIS: Das TIO-Like verfügt über 2 zusätzliche Bytes \n, um die Ausgabe schöner zu gestalten. :) :)

Es fühlt sich an, als würde man ein bisschen schummeln, um mit sqrt die Quadratwurzel zu finden. Hier ist also eine Version mit ein paar weiteren Bytes, die dies nicht tut.

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

Probieren Sie es online aus!

— Robert Benson
quelle
1
Nun, man könnte sagen, das ist AWKward. Ich werde mich zeigen. Bearbeiten: Ursprünglich hatte ich geplant, die Frage mit sqrt zu meiden, aber es gibt zu viele Antworten, und ich werde unerlaubt, wenn ich sie ändere, damit meine ursprüngliche Idee funktioniert.
— Stan Strum
'AWK' Wortspiele machen Spaß :)
— Robert Benson
stattdessen sqrt($1)können Sie verwenden$1^.5
— Cabbie407
Danke @ Cabbie407 weiß nicht warum ich nicht daran gedacht habe.
— Robert Benson
1
Bitte. Einige andere Dinge: Sie benötigen das nicht \n, um die Ausgabe zu erhalten, das printf in awk benötigt keine Klammern und die Formel kann auf gekürzt werden s/2+$1/s/2, was zu führt {s=int($1^.5);printf"%.2f",s/2+$1/s/2}. Entschuldigung, wenn dieser Kommentar unhöflich erscheint.
— Cabbie407
1

Schläger , 92 Bytes

Vielen Dank an @JungHwan Min für den Tipp im Kommentarbereich

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

Probieren Sie es online aus!

Ungolfed

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

PowerShell , 54 Byte

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

Probieren Sie es online aus! oder Überprüfen Sie einige Testfälle

Nimmt Eingaben auf $xund macht dann genau das, was angefordert wird. Der |?Teil findet die maximale Ganzzahl, die im Quadrat für die Eingabe -less-than-or- equal ist, $xund führt dann die erforderlichen Berechnungen durch. Die Ausgabe ist implizit.

— AdmBorkBork
quelle
Beeindruckend. Ich habe nie nachvollziehen können, wie Leute in Windows Powershell
— Stan Strum
@ StanStrum Du bist nicht allein, lol. : D
— AdmBorkBork
1

Schale , 9 Bytes

½Ṡ§+K/(⌊√

Probieren Sie es online aus!

Diese Antwort enthält immer noch etwas Hässliches, aber ich kann anscheinend keine kürzere Lösung finden.

Erläuterung

Ich implementiere einen Schritt des Newtonschen Algorithmus (der tatsächlich dem in dieser Frage vorgeschlagenen entspricht).

½Ṡ§+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
— Löwe
quelle
Ich denke, Sie wollen tatsächliche Teilung, anstatt÷
— H.PWiz
@ H.PWiz whoops, ich weiß, danke. Das war ein Überbleibsel eines Experiments, um andere Lösungen zu finden
— Leo
1

Pyt , 11 10 Bytes

←Đ√⌊Đ↔⇹/+₂

Erläuterung

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
quelle
Ich habe das gerade gesehen und es war eine gute Minute, bis mir klar wurde, dass es nicht Pyth ist. Gute Antwort.
— Stan Strum
Ja, es ist eine kleine Sprache, über die ich eine Weile nachgedacht habe und die ich gerade gemacht habe.
— mudkip201
Ist ToS Top-of-Stack ... und wenn ja, was ist SoS?
— Stan Strum
ToS ist die Spitze des Stapels und SoS ist die zweite auf dem Stapel
— mudkip201
Schön, ich werde sehen, ob ich mich mit dieser Sprache befassen kann. Ich mag das!
— Stan Strum
1

Milchstraße , 17 14 Bytes

-3 Bytes nach der Formel von Olivier Grégoire

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

Probieren Sie es online aus!

Erläuterung

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
quelle
Sollte das nicht Boden statt Decke sein?
— mudkip201
@ mudkip201 Aktualisiert, danke
— ovs
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.