I miei quadrati approssimativi

10

Ispirato da questo video di tecmath .

Un'approssimazione della radice quadrata di qualsiasi numero xpuò essere trovata prendendo la radice quadrata intera s(cioè il numero intero più grande tale s * s ≤ x) e quindi calcolando s + (x - s^2) / (2 * s). Chiamiamo questa approssimazione S(x). (Nota: questo equivale ad applicare un passaggio del metodo Newton-Raphson).

Anche se questo ha delle stranezze, dove S (n ^ 2 - 1) sarà sempre √ (n ^ 2), ma generalmente sarà molto preciso. In alcuni casi più grandi, ciò può avere una precisione> 99,99%.

Ingresso e uscita

Prenderai un numero in qualsiasi formato conveniente.

Esempi

Formato: Ingresso -> Uscita

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

specificazioni

  • L'output deve essere arrotondato almeno al centesimo più vicino (ovvero se la risposta è 47.2851, è possibile output 47.29)

  • L'output non deve avere zeri seguenti e un punto decimale se la risposta è un numero intero (ad es. 125,00 può essere emesso anche come 125 e 125,0)

  • Non è necessario supportare alcun numero inferiore a 1.

  • Non è necessario supportare input non interi. (es. 1.52 ecc ...)

Regole

Sono vietate le scappatoie standard .

Questo è un codice-golf , quindi vince la risposta più breve in byte.

code-golf  math  approximation 
— Stan Strum
fonte
— Stan Strum,
3
Nota:s + (x - s^2) / (2 * s) == (x + s^2) / (2 * s)
— JungHwan Min
Le mie soluzioni: Pyth , 25 byte ; 14 byte
— Stan Strum,
Deve essere preciso ad almeno 2 cifre?
— totalmente umano il
@totallyhuman Sì. 47.2851 può essere rappresentato come 47.28, ma non più impreciso.
— Stan Strum,

Risposte:

2

Gelatina ,  8  7 byte

-1 byte grazie alla formula matematica semplificata di Olivier Grégoire - vedi la risposta Java .

÷ƽ+ƽH

Provalo online!

Come?

÷ƽ+ƽ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
fonte
7 byte: la ÷ƽ+ƽHprima volta che provo a usare Jelly, quindi potrei sbagliarmi. Vorrei sapere come conservare ƽ, per non ripeterlo. Ciò potrebbe salvare un altro byte.
— Olivier Grégoire,
Grazie @ OlivierGrégoire! ƽɓ÷⁹+Hnon ricalcolare la radice intera, ma è anche 7. ɓavvia una nuova catena diadica con argomenti scambiati e quindi ⁹fa riferimento all'argomento corretto di quella catena (cioè il risultato di ƽ). ƽɓ÷+⁹Hfunzionerebbe anche qui.
— Jonathan Allan,
4

Haskell , 34 byte

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

Provalo online!

Spiegazione nello pseudocodice imperativo:

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

Java (OpenJDK 8) , 32 byte

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

Provalo online!

spiegazioni

Il codice è equivalente a questo:

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

La matematica dietro:

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
fonte
Questo non sembra gestire le specifiche: l'output deve essere arrotondato almeno al centesimo più vicino
— Ayb4btu,
2
Bene, è arrotondato a un valore inferiore al centesimo più vicino, quindi è totalmente valido.
— Olivier Grégoire,
Ah, capisco, il mio malinteso.
— Ayb4btu,
4

Python 2 , 47 ... 36 byte

-3 byte grazie a @JungHwanMin
-1 byte grazie a @HyperNeutrino
-2 byte grazie a @JonathanFrech
-3 byte grazie a @ OlivierGrégoire

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

Provalo online!

— OVS
fonte
-2 byte: s+(x-s*s)/s/2a(x+s*s)/s/2
— JungHwan Min
-2 byte usando una funzione
— HyperNeutrino,
@HyperNeutrino Ottengo solo -1 byte
— ovs il
Oh scusa ho cancellato accidentalmente un personaggio dopo il test e poi ho contato i byte dopo: P sì, solo -1
— HyperNeutrino
Non puoi omettere +.0e sostituire /s/2con /2./s, salvando due byte?
— Jonathan Frech,
3

R, 43 byte 29 byte

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

Grazie a @Giuseppe per la nuova equazione e aiuto nel golf di 12 byte con la soluzione di divisione intera. Scambiando la chiamata di funzione per la scansione, ho giocato a golf un altro paio di byte.

Provalo online!

— marchio
fonte
1
35 byte ; più in generale, è possibile utilizzare il campo "header" di TIO e inserire a f <- per assegnare la funzione. Ma comunque, bella soluzione, assicurati di leggere Suggerimenti per giocare a golf in R quando ne hai la possibilità!
— Giuseppe,
1
— Giuseppe,
2

JavaScript (ES7), 22 byte

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

Non abbiamo davvero bisogno di una variabile intermedia, quindi questa può effettivamente essere riscritta come:

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

Casi test

Mostra snippet di codice

— Arnauld
fonte
2

AWK , 47 44 38 byte

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

Provalo online!

NOTA: il TIO like ha 2 byte extra per \nrendere l'output più bello. :)

È come imbrogliare un po 'per usare sqrt per trovare la radice quadrata, quindi ecco una versione con qualche byte in più che non lo fa.

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

Provalo online!

— Robert Benson
fonte
1
bene si potrebbe dire che questo è AWKward. Mi mostrerò. modifica: originariamente avevo pianificato di evitare la domanda usando sqrt, ma ci sono troppe risposte e mi commetto un errore se la cambio in modo che la mia idea originale funzioni.
— Stan Strum,
I giochi di parole "AWK" sono divertenti :)
— Robert Benson,
invece di sqrt($1)te puoi usare$1^.5
— Cabbie407,
Grazie @ Cabbie407 non so perché non ci abbia pensato.
— Robert Benson,
1
Prego. Alcune altre cose: non è necessario \nper ottenere l'output, printf in awk non ha bisogno di parentesi e la formula può essere abbreviata s/2+$1/s/2, il che si traduce in {s=int($1^.5);printf"%.2f",s/2+$1/s/2}. Scusate se questo commento sembra maleducato.
— Cabbie407,
1

Racchetta , 92 byte

Grazie a @JungHwan Min per il suggerimento nella sezione commenti

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

Provalo online!

Ungolfed

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

PowerShell , 54 byte

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

Provalo online! oppure Verifica alcuni casi di test

Prende input $xe quindi fa esattamente ciò che è richiesto. La |?parte trova il numero intero massimo che, quando è quadrato, è -lessenziale rispetto eall'input $x, quindi eseguiamo i calcoli richiesti. L'output è implicito.

— AdmBorkBork
fonte
Wow. Non sono mai stato in grado di comprendere come le persone giochino a golf in Windows Powershell
— Stan Strum il
@StanStrum Non sei solo, lol. : D
— AdmBorkBork,
1

Buccia , 9 byte

½Ṡ§+K/(⌊√

Provalo online!

C'è ancora qualcosa di brutto in questa risposta, ma non riesco a trovare una soluzione più breve.

Spiegazione

Sto implementando un passaggio dell'algoritmo di Newton (che è effettivamente equivalente a quello proposto in questa domanda)

½Ṡ§+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
fonte
Penso che tu voglia la vera divisione, piuttosto che÷
— H.Piz il
@ H.PWiz whoops, lo faccio, grazie. Era un residuo di un esperimento per trovare altre soluzioni
— Leone,
1

Pyt , 11 10 byte

←Đ√⌊Đ↔⇹/+₂

Spiegazione

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
fonte
Ho appena visto questo ed è stato un buon minuto fino a quando ho capito che non è Pyth. Bella risposta.
— Stan Strum,
Sì, è un po 'di lingua a cui sto pensando da un po' e ho appena deciso di fare davvero.
— mudkip201
ToS è il top di gamma ... e se sì, cos'è SoS?
— Stan Strum,
ToS è in cima allo stack e SoS è il secondo in pila
— mudkip201
Bene, vedrò se riesco ad approfondire questa lingua; Mi piace!
— Stan Strum,
1

Via Lattea , 17 14 byte

-3 byte usando la formula di Olivier Grégoire

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

Provalo online!

Spiegazione

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
fonte
non dovrebbe essere piano anziché cemento?
— mudkip201,
@ mudkip201 Aggiornato, grazie
— ovs
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.