Scrivi la tua funzione di radice quadrata
https://stackoverflow.com/questions/1623375
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Come si scrive la propria funzione per trovare la radice quadrata più accurata di un numero intero?
Dopo aver cercato su Google, ho trovato this (archiviato dal suo link originale ), ma prima non l'ho capito completamente e, in secondo luogo, è anche approssimativo.
Assumi la radice quadrata come intero più vicino (alla radice effettiva) o float.
Soluzione
Il seguente piano calcola (sqrt (N)) per N > 0:
x = 2^ceil(numbits(N)/2)
loop:
y = floor((x + floor(N/x))/2)
if y >= x
return x
x = y
Questa è una versione del metodo di Newton fornita nell'amplificatore Crandall &; Pomerance, & Quot; Numeri primi: una prospettiva computazionale & Quot ;. Il motivo per cui dovresti usare questa versione è che le persone che sanno cosa stanno facendo hanno dimostrato che converge esattamente al piano della radice quadrata, ed è semplice, quindi la probabilità di commettere un errore di implementazione è piccola. È anche veloce (anche se è possibile costruire un algoritmo ancora più veloce, ma farlo correttamente è molto più complesso). Una ricerca binaria correttamente implementata può essere più veloce per N molto piccola, ma lì puoi anche usare una tabella di ricerca.
Per arrotondare all'intero più vicino , basta calcolare t = floor (sqrt (4N)) usando l'algoritmo sopra. Se è impostato il bit meno significativo di t, scegliere x = (t + 1) / 2; altrimenti scegliere t / 2. Si noti che questo arrotonda per eccesso su un pareggio; potresti anche arrotondare per difetto (o arrotondare per pareggiare) osservando se il resto è diverso da zero (ovvero se t ^ 2 == 4N).
Nota che non è necessario utilizzare l'aritmetica in virgola mobile. In effetti, non dovresti. Questo algoritmo dovrebbe essere implementato interamente usando numeri interi (in particolare, le funzioni floor () indicano semplicemente che dovrebbe essere usata la normale divisione di numeri interi).
Altri suggerimenti
A seconda delle esigenze, è possibile utilizzare una semplice strategia di divisione e conquista. Non convergerà velocemente come altri metodi, ma potrebbe essere molto più facile da capire per un principiante. Inoltre, poiché è un algoritmo O (log n) (dimezza lo spazio di ricerca per ogni iterazione), il caso peggiore per un float a 32 bit sarà di 32 iterazioni.
Diciamo che vuoi la radice quadrata di 62.104. Scegli un valore a metà tra 0 e quello e lo piazza. Se il quadrato è più alto del tuo numero, devi concentrarti su numeri inferiori al punto medio. Se è troppo basso, concentrati su quelli più alti.
Con la vera matematica, potresti continuare a dividere lo spazio di ricerca in due per sempre (se non ha una radice quadrata razionale). In realtà, i computer finiranno per rimanere senza precisione e avrai la tua approssimazione. Il seguente programma C illustra il punto:
#include <stdio.h>
#include <stdlib.h>
int main (int argc, char *argv[]) {
float val, low, high, mid, oldmid, midsqr;
int step = 0;
// Get argument, force to non-negative.
if (argc < 2) {
printf ("Usage: sqrt <number>\n");
return 1;
}
val = fabs (atof (argv[1]));
// Set initial bounds and print heading.
low = 0;
high = mid = val;
oldmid = -1;
printf ("%4s %10s %10s %10s %10s %10s %s\n",
"Step", "Number", "Low", "High", "Mid", "Square", "Result");
// Keep going until accurate enough.
while (fabs(oldmid - mid) >= 0.00001) {
oldmid = mid;
// Get midpoint and see if we need lower or higher.
mid = (high + low) / 2;
midsqr = mid * mid;
printf ("%4d %10.4f %10.4f %10.4f %10.4f %10.4f ",
++step, val, low, high, mid, midsqr);
if (mid * mid > val) {
high = mid;
printf ("- too high\n");
} else {
low = mid;
printf ("- too low\n");
}
}
// Desired accuracy reached, print it.
printf ("sqrt(%.4f) = %.4f\n", val, mid);
return 0;
}
Ecco un paio di prove, quindi spero che tu abbia un'idea di come funzioni. Per 77:
pax> sqrt 77
Step Number Low High Mid Square Result
1 77.0000 0.0000 77.0000 38.5000 1482.2500 - too high
2 77.0000 0.0000 38.5000 19.2500 370.5625 - too high
3 77.0000 0.0000 19.2500 9.6250 92.6406 - too high
4 77.0000 0.0000 9.6250 4.8125 23.1602 - too low
5 77.0000 4.8125 9.6250 7.2188 52.1104 - too low
6 77.0000 7.2188 9.6250 8.4219 70.9280 - too low
7 77.0000 8.4219 9.6250 9.0234 81.4224 - too high
8 77.0000 8.4219 9.0234 8.7227 76.0847 - too low
9 77.0000 8.7227 9.0234 8.8730 78.7310 - too high
10 77.0000 8.7227 8.8730 8.7979 77.4022 - too high
11 77.0000 8.7227 8.7979 8.7603 76.7421 - too low
12 77.0000 8.7603 8.7979 8.7791 77.0718 - too high
13 77.0000 8.7603 8.7791 8.7697 76.9068 - too low
14 77.0000 8.7697 8.7791 8.7744 76.9893 - too low
15 77.0000 8.7744 8.7791 8.7767 77.0305 - too high
16 77.0000 8.7744 8.7767 8.7755 77.0099 - too high
17 77.0000 8.7744 8.7755 8.7749 76.9996 - too low
18 77.0000 8.7749 8.7755 8.7752 77.0047 - too high
19 77.0000 8.7749 8.7752 8.7751 77.0022 - too high
20 77.0000 8.7749 8.7751 8.7750 77.0009 - too high
21 77.0000 8.7749 8.7750 8.7750 77.0002 - too high
22 77.0000 8.7749 8.7750 8.7750 76.9999 - too low
23 77.0000 8.7750 8.7750 8.7750 77.0000 - too low
sqrt(77.0000) = 8.7750
Per 62.104:
pax> sqrt 62.104
Step Number Low High Mid Square Result
1 62.1040 0.0000 62.1040 31.0520 964.2267 - too high
2 62.1040 0.0000 31.0520 15.5260 241.0567 - too high
3 62.1040 0.0000 15.5260 7.7630 60.2642 - too low
4 62.1040 7.7630 15.5260 11.6445 135.5944 - too high
5 62.1040 7.7630 11.6445 9.7037 94.1628 - too high
6 62.1040 7.7630 9.7037 8.7334 76.2718 - too high
7 62.1040 7.7630 8.7334 8.2482 68.0326 - too high
8 62.1040 7.7630 8.2482 8.0056 64.0895 - too high
9 62.1040 7.7630 8.0056 7.8843 62.1621 - too high
10 62.1040 7.7630 7.8843 7.8236 61.2095 - too low
11 62.1040 7.8236 7.8843 7.8540 61.6849 - too low
12 62.1040 7.8540 7.8843 7.8691 61.9233 - too low
13 62.1040 7.8691 7.8843 7.8767 62.0426 - too low
14 62.1040 7.8767 7.8843 7.8805 62.1024 - too low
15 62.1040 7.8805 7.8843 7.8824 62.1323 - too high
16 62.1040 7.8805 7.8824 7.8815 62.1173 - too high
17 62.1040 7.8805 7.8815 7.8810 62.1098 - too high
18 62.1040 7.8805 7.8810 7.8807 62.1061 - too high
19 62.1040 7.8805 7.8807 7.8806 62.1042 - too high
20 62.1040 7.8805 7.8806 7.8806 62.1033 - too low
21 62.1040 7.8806 7.8806 7.8806 62.1038 - too low
22 62.1040 7.8806 7.8806 7.8806 62.1040 - too high
23 62.1040 7.8806 7.8806 7.8806 62.1039 - too high
sqrt(62.1040) = 7.8806
Per 49:
pax> sqrt 49
Step Number Low High Mid Square Result
1 49.0000 0.0000 49.0000 24.5000 600.2500 - too high
2 49.0000 0.0000 24.5000 12.2500 150.0625 - too high
3 49.0000 0.0000 12.2500 6.1250 37.5156 - too low
4 49.0000 6.1250 12.2500 9.1875 84.4102 - too high
5 49.0000 6.1250 9.1875 7.6562 58.6182 - too high
6 49.0000 6.1250 7.6562 6.8906 47.4807 - too low
7 49.0000 6.8906 7.6562 7.2734 52.9029 - too high
8 49.0000 6.8906 7.2734 7.0820 50.1552 - too high
9 49.0000 6.8906 7.0820 6.9863 48.8088 - too low
10 49.0000 6.9863 7.0820 7.0342 49.4797 - too high
11 49.0000 6.9863 7.0342 7.0103 49.1437 - too high
12 49.0000 6.9863 7.0103 6.9983 48.9761 - too low
13 49.0000 6.9983 7.0103 7.0043 49.0598 - too high
14 49.0000 6.9983 7.0043 7.0013 49.0179 - too high
15 49.0000 6.9983 7.0013 6.9998 48.9970 - too low
16 49.0000 6.9998 7.0013 7.0005 49.0075 - too high
17 49.0000 6.9998 7.0005 7.0002 49.0022 - too high
18 49.0000 6.9998 7.0002 7.0000 48.9996 - too low
19 49.0000 7.0000 7.0002 7.0001 49.0009 - too high
20 49.0000 7.0000 7.0001 7.0000 49.0003 - too high
21 49.0000 7.0000 7.0000 7.0000 49.0000 - too low
22 49.0000 7.0000 7.0000 7.0000 49.0001 - too high
23 49.0000 7.0000 7.0000 7.0000 49.0000 - too high
sqrt(49.0000) = 7.0000
Un metodo semplice (ma non molto veloce) per calcolare la radice quadrata di X:
squareroot(x)
if x<0 then Error
a = 1
b = x
while (abs(a-b)>ErrorMargin)
a = (a+b)/2
b = x/a
endwhile
return a;
Esempio: squareroot (70000)
a b
1 70000
35001 2
17502 4
8753 8
4381 16
2199 32
1116 63
590 119
355 197
276 254
265 264
Come puoi vedere, definisce un limite superiore e uno inferiore per la radice quadrata e restringe il limite fino a quando la sua dimensione non è accettabile.
Esistono metodi più efficienti, ma questo illustra il processo ed è facile da capire.
Fai solo attenzione a impostare Errormargin su 1 se usi numeri interi altrimenti hai un ciclo infinito.
Vorrei sottolineare un metodo estremamente interessante per calcolare una radice quadrata inversa 1 / sqrt (x) che è una leggenda nel mondo del design del gioco perché è incredibilmente veloce. Oppure aspetta, leggi il seguente post:
http://betterexplained.com/articles/understanding-quakes -fast-dell'inverso del quadrato-radice /
PS: so che vuoi solo la radice quadrata ma l'eleganza del sisma ha superato ogni resistenza da parte mia :)
A proposito, l'articolo sopra menzionato parla anche della noiosa approssimazione di Newton-Raphson da qualche parte.
Naturalmente è approssimativo; è così che funziona la matematica con numeri in virgola mobile.
Comunque, il modo standard è con il metodo di Newton . È quasi come usare la serie di Taylor, l'altro modo che mi viene subito in mente.
Calcola radice quadrata con precisione arbitraria in Python
#!/usr/bin/env python
import decimal
def sqrt(n):
assert n > 0
with decimal.localcontext() as ctx:
ctx.prec += 2 # increase precision to minimize round off error
x, prior = decimal.Decimal(n), None
while x != prior:
prior = x
x = (x + n/x) / 2 # quadratic convergence
return +x # round in a global context
decimal.getcontext().prec = 80 # desirable precision
r = sqrt(12345)
print r
print r == decimal.Decimal(12345).sqrt()
Output:
111.10805551354051124500443874307524148991137745969772997648567316178259031751676
True
È una domanda di intervista comune posta da Facebook, ecc. Non credo sia una buona idea usare il metodo di Newton in un'intervista. E se l'intervistatore ti chiedesse il meccanismo del metodo di Newton quando non lo capisci davvero?
Ho fornito una soluzione binaria basata sulla ricerca in Java che credo tutti possano capire.
public int sqrt(int x) {
if(x < 0) return -1;
if(x == 0 || x == 1) return x;
int lowerbound = 1;
int upperbound = x;
int root = lowerbound + (upperbound - lowerbound)/2;
while(root > x/root || root+1 <= x/(root+1)){
if(root > x/root){
upperbound = root;
} else {
lowerbound = root;
}
root = lowerbound + (upperbound - lowerbound)/2;
}
return root;
}
Puoi testare il mio codice qui: leetcode: sqrt (x)
Trovato un ottimo articolo su Integer Square radici .
Questa è una versione leggermente migliorata che presenta lì:
unsigned long sqrt(unsigned long a){
int i;
unsigned long rem = 0;
unsigned long root = 0;
for (i = 0; i < 16; i++){
root <<= 1;
rem = (rem << 2) | (a >> 30);
a <<= 2;
if(root < rem){
root++;
rem -= root;
root++;
}
}
return root >> 1;
}
Ecco un modo per ottenere una radice quadrata usando la trigonometria. Non è l'algoritmo più veloce in assoluto, ma è preciso. Il codice è in javascript:
var n = 5; //number to get the square root of
var icr = ((n+1)/2); //intersecting circle radius
var sqrt = Math.cos(Math.asin((icr-1)/icr))*icr; //square root of n
alert(sqrt);
Esiste un algoritmo che ho studiato a scuola che puoi usare per calcolare radici quadrate esatte (o con precisione arbitrariamente grande se la radice è un numero irrazionale). È decisamente più lento degli algoritmi di Newton ma è esatto. Diciamo che vuoi calcolare la radice quadrata di 531.3025
La prima cosa è dividere il numero a partire dal punto decimale in gruppi di 2 cifre:
{5} {31}. {30} {25}
Poi:
1) Trova la radice quadrata più vicina per il primo gruppo che è più piccola o uguale alla radice quadrata effettiva del primo gruppo: sqrt ({5}) & Gt; = 2. Questa radice quadrata è la prima cifra della tua risposta finale. Indichiamo le cifre che abbiamo già trovato della nostra radice quadrata finale come B. Quindi al momento B = 2.
2) Quindi calcola la differenza tra {5} e B ^ 2: 5 - 4 = 1.
3) Per tutti i successivi gruppi di 2 cifre, procedi come segue:
Moltiplica il resto per 100, quindi aggiungilo al secondo gruppo: 100 + 31 = 131.
Trova X - la cifra successiva della tua radice, in modo che 131 & Gt; = ((B * 20) + X) * X. X = 3. 43 * 3 = 129 & Lt; 131. Ora B = 23. Anche perché non ci sono più gruppi di 2 cifre a sinistra dei punti decimali, hai trovato tutte le cifre intere della radice finale.
4) Ripeti lo stesso per {30} e {25}. Quindi hai:
{30}: 131 - 129 = 2. 2 * 100 + 30 = 230 & Gt; = (23 * 2 * 10 + X) * X - & Gt; X = 0 - & Gt; B = 23,0
{25}: 230-0 = 230. 230 * 100 + 25 = 23025. 23025 & Gt; = (230 * 2 * 10 + X) * X - & Gt; X = 5 - & Gt; B = 23,05
Risultato finale = 23.05.
L'algoritmo sembra complicato in questo modo ma è molto più semplice se lo fai su carta usando la stessa notazione che usi per & Quot; long division & Quot; hai studiato a scuola, tranne per il fatto che non fai divisione ma invece calcola la radice quadrata.
La prima cosa che mi viene in mente è: questo è un buon posto per usare la ricerca binaria (ispirato a questo fantastico tutorial .)
Per trovare la radice quadrata di vaule, stiamo cercando number in (1..value) dove il predittore
è vero per la prima volta. Il predittore che stiamo scegliendo è number * number - value > 0.00001.
double square_root_of(double value)
{
assert(value >= 1);
double lo = 1.0;
double hi = value;
while( hi - lo > 0.00001)
{
double mid = lo + (hi - lo) / 2 ;
std::cout << lo << "," << hi << "," << mid << std::endl;
if( mid * mid - value > 0.00001) //this is the predictors we are using
{
hi = mid;
} else {
lo = mid;
}
}
return lo;
}
// Fastest way I found, an (extreme) C# unrolled version of:
// http://www.hackersdelight.org/hdcodetxt/isqrt.c.txt (isqrt4)
// It's quite a lot of code, basically a binary search (the "if" statements)
// followed by an unrolled loop (the labels).
// Most important: it's fast, twice as fast as "Math.Sqrt".
// On my pc: Math.Sqrt ~35 ns, sqrt <16 ns (mean <14 ns)
private static uint sqrt(uint x)
{
uint y, z;
if (x < 1u << 16)
{
if (x < 1u << 08)
{
if (x < 1u << 04) return x < 1u << 02 ? x + 3u >> 2 : x + 15u >> 3;
else
{
if (x < 1u << 06)
{ y = 1u << 03; x -= 1u << 04; if (x >= 5u << 02) { x -= 5u << 02; y |= 1u << 02; } goto L0; }
else
{ y = 1u << 05; x -= 1u << 06; if (x >= 5u << 04) { x -= 5u << 04; y |= 1u << 04; } goto L1; }
}
}
else // slower (on my pc): .... y = 3u << 04; } goto L1; }
{
if (x < 1u << 12)
{
if (x < 1u << 10)
{ y = 1u << 07; x -= 1u << 08; if (x >= 5u << 06) { x -= 5u << 06; y |= 1u << 06; } goto L2; }
else
{ y = 1u << 09; x -= 1u << 10; if (x >= 5u << 08) { x -= 5u << 08; y |= 1u << 08; } goto L3; }
}
else
{
if (x < 1u << 14)
{ y = 1u << 11; x -= 1u << 12; if (x >= 5u << 10) { x -= 5u << 10; y |= 1u << 10; } goto L4; }
else
{ y = 1u << 13; x -= 1u << 14; if (x >= 5u << 12) { x -= 5u << 12; y |= 1u << 12; } goto L5; }
}
}
}
else
{
if (x < 1u << 24)
{
if (x < 1u << 20)
{
if (x < 1u << 18)
{ y = 1u << 15; x -= 1u << 16; if (x >= 5u << 14) { x -= 5u << 14; y |= 1u << 14; } goto L6; }
else
{ y = 1u << 17; x -= 1u << 18; if (x >= 5u << 16) { x -= 5u << 16; y |= 1u << 16; } goto L7; }
}
else
{
if (x < 1u << 22)
{ y = 1u << 19; x -= 1u << 20; if (x >= 5u << 18) { x -= 5u << 18; y |= 1u << 18; } goto L8; }
else
{ y = 1u << 21; x -= 1u << 22; if (x >= 5u << 20) { x -= 5u << 20; y |= 1u << 20; } goto L9; }
}
}
else
{
if (x < 1u << 28)
{
if (x < 1u << 26)
{ y = 1u << 23; x -= 1u << 24; if (x >= 5u << 22) { x -= 5u << 22; y |= 1u << 22; } goto La; }
else
{ y = 1u << 25; x -= 1u << 26; if (x >= 5u << 24) { x -= 5u << 24; y |= 1u << 24; } goto Lb; }
}
else
{
if (x < 1u << 30)
{ y = 1u << 27; x -= 1u << 28; if (x >= 5u << 26) { x -= 5u << 26; y |= 1u << 26; } goto Lc; }
else
{ y = 1u << 29; x -= 1u << 30; if (x >= 5u << 28) { x -= 5u << 28; y |= 1u << 28; } }
}
}
}
z = y | 1u << 26; y /= 2; if (x >= z) { x -= z; y |= 1u << 26; }
Lc: z = y | 1u << 24; y /= 2; if (x >= z) { x -= z; y |= 1u << 24; }
Lb: z = y | 1u << 22; y /= 2; if (x >= z) { x -= z; y |= 1u << 22; }
La: z = y | 1u << 20; y /= 2; if (x >= z) { x -= z; y |= 1u << 20; }
L9: z = y | 1u << 18; y /= 2; if (x >= z) { x -= z; y |= 1u << 18; }
L8: z = y | 1u << 16; y /= 2; if (x >= z) { x -= z; y |= 1u << 16; }
L7: z = y | 1u << 14; y /= 2; if (x >= z) { x -= z; y |= 1u << 14; }
L6: z = y | 1u << 12; y /= 2; if (x >= z) { x -= z; y |= 1u << 12; }
L5: z = y | 1u << 10; y /= 2; if (x >= z) { x -= z; y |= 1u << 10; }
L4: z = y | 1u << 08; y /= 2; if (x >= z) { x -= z; y |= 1u << 08; }
L3: z = y | 1u << 06; y /= 2; if (x >= z) { x -= z; y |= 1u << 06; }
L2: z = y | 1u << 04; y /= 2; if (x >= z) { x -= z; y |= 1u << 04; }
L1: z = y | 1u << 02; y /= 2; if (x >= z) { x -= z; y |= 1u << 02; }
L0: return x > y ? y / 2 | 1u : y / 2;
}
usa la ricerca binaria
public class FindSqrt {
public static void main(String[] strings) {
int num = 10000;
System.out.println(sqrt(num, 0, num));
}
private static int sqrt(int num, int min, int max) {
int middle = (min + max) / 2;
int x = middle * middle;
if (x == num) {
return middle;
} else if (x < num) {
return sqrt(num, middle, max);
} else {
return sqrt(num, min, middle);
}
}
}
In generale la radice quadrata di un numero intero (come 2, ad esempio) può solo essere approssimata (non a causa di problemi con l'aritmetica in virgola mobile, ma perché sono numeri irrazionali che non possono essere calcolato esattamente).
Certo, alcune approssimazioni sono migliori di altre. Voglio dire, ovviamente, che il valore 1.732 è una migliore approssimazione alla radice quadrata di 3, rispetto a 1,7
Il metodo usato dal codice al link che hai fornito funziona prendendo una prima approssimazione e usandola per calcolare un'approssimazione migliore .
Questo si chiama Metodo di Newton e puoi ripetere il calcolo con ogni nuova approssimazione fino a quando non è abbastanza preciso per te.
In effetti deve essere in qualche modo per decidere quando interrompere la ripetizione o funzionerà per sempre.
Di solito ti fermi quando la differenza tra approssimazioni è inferiore a un valore che decidi.
EDIT: non credo che ci possa essere un'implementazione più semplice delle due che hai già trovato.
L'inverso, come dice il nome, ma a volte " abbastanza vicino " è " abbastanza vicino " ;; una lettura interessante comunque.
Una soluzione semplice che può gestire radice quadrata mobile e precisione arbitraria usando la ricerca binaria
codificato in rubino
include Math
def sqroot_precision num, precision
upper = num
lower = 0
middle = (upper + lower)/2.0
while true do
diff = middle**2 - num
return middle if diff.abs <= precision
if diff > 0
upper = middle
else diff < 0
lower = middle
end
middle = (upper + lower)/2.0
end
end
puts sqroot_precision 232.3, 0.0000000001
Diciamo che stiamo cercando di trovare la radice quadrata di 2, e tu ce l'hai una stima di 1,5. Diremo a = 2 e x = 1.5. Per calcolare una stima migliore, divideremo una per x. Questo dà un nuovo valore y = 1.333333. Tuttavia, non possiamo considerarlo come la nostra prossima stima (perché no?). Dobbiamo fare una media con la stima precedente. Quindi la nostra prossima stima, xx sarà (x + y) / 2 o 1.416666.
Double squareRoot(Double a, Double epsilon) {
Double x = 0d;
Double y = a;
Double xx = 0d;
// Make sure both x and y != 0.
while ((x != 0d || y != 0d) && y - x > epsilon) {
xx = (x + y) / 2;
if (xx * xx >= a) {
y = xx;
} else {
x = xx;
}
}
return xx;
}
Epsilon determina quanto deve essere precisa l'approssimazione. La funzione dovrebbe restituire la prima approssimazione x ottiene che soddisfa abs (x * x - a) & Lt; epsilon, dove abs (x) è il valore assoluto di x.
square_root(2, 1e-6)
Output: 1.4142141342163086
Beh, ci sono già alcune risposte, ma ecco la mia È il codice più semplice (per me), ecco il algoritmo per questo.
E codice in Python 2.7:
from __future__ import division
val = 81
x = 10
def sqr(data,x):
temp = x - ( (x**2 - data)/(2*x))
if temp == x:
print temp
return
else:
x = temp
return sqr(data,x)
#x =temp
#sqr(data,x)
sqr(val,x)
Per calcolare la radice quadrata di un numero con l'aiuto della funzione integrata
# include"iostream.h"
# include"conio.h"
# include"math.h"
void main()
{
clrscr();
float x;
cout<<"Enter the Number";
cin>>x;
float squreroot(float);
float z=squareroot(x);
cout<<z;
float squareroot(int x)
{
float s;
s = pow(x,.5)
return(s);
}
