Cómo escribir un programa para encontrar la raíz cuadrada de un número sin usar la función sqrt

Answer 1

El método de Newton Raphson se puede usar para encontrar la raíz cuadrada de un número (método de Newton)

[matemáticas] f (x) = x ^ 2 – N [/ matemáticas] donde N = Número cuya raíz cuadrada se va a obtener.

Tenemos que encontrar la raíz de f (x) = 0

Deje que [matemáticas] x_1 = \ frac {N} {2} [/ matemáticas]

[matemáticas] x_ {n + 1} = x_n – \ frac {f (x_n)} {f ‘(x_n)} [/ matemáticas]

Por lo tanto, [matemáticas] x_2 = x_1 – \ frac {f (x_1)} {f ‘(x_1)} [/ matemáticas]

Usando la función anterior, después de diferenciar se reducirá a

[matemáticas] x_2 = \ frac {x_1 + \ frac {N} {x_1}} {2} [/ matemáticas]

Del mismo modo, encuentre x3, x4, … Deténgase en el punto donde la diferencia absoluta entre el valor calculado actual y el valor anterior es muy inferior

raíz cuadrada doble (int num) {
doble x1 = (num * 1.0) / 2;
doble x2 = (x1 + (num / x1)) / 2;
while (abs (x1 – x2)> = 0.0000001) {
x1 = x2;
x2 = (x1 + (num / x1)) / 2;
}
retorno x2;
}

Answer 2

Esta es la mejor solución que ofrece 4 métodos para encontrar la raíz cuadrada sin usar la función sqrt: programa c para encontrar la raíz cuadrada de un número sin usar la función sqrt Además, lo que creo es que los métodos son únicos aquí y más cortos que otras soluciones que tengo visto
Método 1
#include
vacío principal()
{
flotador m, n;
flotador num;
n = 0.0001; // Esto se toma pequeño para que también podamos calcular hasta decimales
printf (“INGRESE UN NÚMERO:”);
scanf (“% f”, & num);

para (m = 0; m {
if ((m * m)> num)
{
m = mn; // Esto si () se usa para calcular el valor final tan pronto como el cuadrado del número excede
rotura; // el número luego deducimos el valor excedido y detenemos el procedimiento usando break; Este es nuestro valor final que se almacena en m;
}
}
printf (“%. 2f”, m);
getch ();
retorno 1;
}

Answer 3

La lógica simple es que si sigues sumando números impares, la cantidad de veces que agregues números impares será la raíz cuadrada de la suma de 1 a ese número impar
Por ejemplo
1 = 1 cuadrado de 1
1 + 3 = 4 cuadrados de 2, sumando dos veces
1 + 3 + 5 = 9 cuadrados de 3 sumando tres veces
aquí está mi código simple

#include
int main ()
{
largo largo int n, x = 0, cuenta = 0, i;
scanf (“% lld”, & n);
para (i = 1; x <= n; i + = 2)
{
x = x + i;
recuento ++;
}
printf (“% lld \ n”, cuenta);
devuelve 0;
}

Answer 4

El siguiente fragmento de código se aplica suponiendo que se incluyan todos los archivos de encabezado necesarios y que las variables se declaren adecuadamente; a es el número que tiene para encontrar la raíz cuadrada de cuya respuesta se almacena en b .

#include
#include
vacío principal()
{
int a;
flotador b;
printf (“Ingrese el número a enraizar”);
scanf (“% d”, & a);
para (i = 1; i {
si ((i * i)> a)
{
b = i-1;
rotura;
}
}
para (j = 1; j <6; j ++)
{
para (k = 1; k <= a; k ++)
{
if (pow (b + k * pow (10, -j), 2)> a)
{
b + = (k-1) * pow (10, -j);
rotura;
}
}
}
printf (“La raíz cuadrada es =% f”, b);
}

Este programa está escrito en C, pero la lógica seguirá siendo la misma. He usado una lógica muy simple que estoy bastante seguro de que la mayoría de la gente podrá entender. Si hubo una restricción en el uso de pow() , entonces deberá reemplazar la función con un bucle equivalente.

6 denota el número de lugares decimales, que se pueden ajustar según su necesidad.

¡Salud! 🙂

Answer 5

#include
int main ()
{
largo largo int n, x = 0, cuenta = 0, i;
scanf (“% lld”, & n);
para (i = 1; x <= n; i + = 2)
{
x = x + i;
recuento ++;
}
printf (“% lld \ n”, cuenta);
devuelve 0;
}

Answer 6

¡Oye!
Te sugiero que escribas tu propia función, como:
(El fragmento a continuación está en Python)

a = 2 ^ techo (numbits (N) / 2)
lazo:
b = piso ((a + piso (N / a)) / 2)
si b> = a
devolver un
a = b

Mientras tanto, puede probar algunas de las soluciones explicadas aquí o simplemente pasar por estas URL

Programa raíz @Square en C sin usar la función sqrt
@Redirect Notice
Espero que ayude. ¡¡Salud!!

Answer 7

Puede usar un bucle for simple para descubrir la raíz cuadrada de un número.
Deje ‘ e ‘ es la entrada

para (f = 1; f * f <= e; f ++)
{
si ((f * f) == e)
printf (“% d”, f);
}
esto imprimirá la raíz cuadrada de e .

Answer 8

Búsqueda binaria.

Defina f (x) = x ^ 2 – c.

Donde c es el número cuya raíz cuadrada quieres encontrar.
Use la búsqueda binaria para encontrar el valor de x donde esta función se acerca más a cero.
Si quieres que agregue más detalles, házmelo saber en los comentarios.

Answer 9

Podrías usar el método de Newton. Convino en que esto no producirá un valor tan preciso como lo haría la función sqrt, pero esta es su mejor opción.
Entonces, para encontrar la raíz cuadrada de un número x, debe comenzar con una suposición g, digamos 1. Ahora, con cada iteración, necesita hacer una suposición mejor promediando gy x / g.
Ahora defina un valor y, lo más pequeño posible y siga mejorando la suposición hasta que adivine ^ 2-x = y.
Aquí está el pseudocódigo para el algoritmo, comenzando con la conjetura como 1, que produce un resultado con una precisión de 0.0001.
procedimiento: doble sqrt (doble x)
{
precisión doble = 0.0001;
doble conjetura = 1;
while (absoluto (cuadrado (adivinar) -x)> = precisión)
hacer
{
adivinar = (adivinar + (x / adivinar)) / 2;
}
volver adivina;
}

Answer 10

Codifico este programa cuando mi CS HOD dio un desafío. Es más simple, comprensible y más corto y se calcula aproximadamente con 4-5 decimales. Descárgalo y échale un vistazo.

/ *
// Programa para calcular la raíz cuadrada sin usar la función sqrt ()
// más simple y más corto
// desarrollado el 15.03.16 por Vijay Purohit [correo electrónico protegido]
// probado y verificado en DEV C ++ 5.11 y corregido aproximadamente a 4-5 decimales
* /

#include
#include

principal()
{
flotador num, n;
int x;

printf (“Ingrese el número para calcular su raíz cuadrada:”);
scanf (“% f”, & num);

para (n = 1; n> 0; n = n + 0.00001)
{
if (abs (n * n) == num)

goto x;
}
X:
printf (“La raíz cuadrada de% .2f es:% .4f”, num, n);
getch ();
}

Answer 11

Queremos encontrar sqrt (N). Dejar
[matemáticas]
sqrt (N) = x
[/matemáticas]
Cuadrando ambos lados y reorganizando lo que tenemos,
[matemáticas]
x ^ 2 – N = 0
[/matemáticas]

Llamemos esto como
[matemáticas]
f (x) = x ^ 2 – N
[/matemáticas]

Ahora, todo lo que tiene que hacer es encontrar dónde convergerá ‘x’ utilizando técnicas como el método de Newton-Raphson.

Answer 12

#include

vacío principal()

{

int n; // el usuario ingresará d no.

temperatura de flotación, sqt;

printf (“Ingrese d no.”);

scanf (“% d”, & n);

sqt = n / 2;

temp = 0;

while (sqt! = temp)

{

temp = sqt;

sqt = (n / temp + temp) / 2;

}

printf (“la raíz cuadrada de% d es% f”, n, sqt);

}

Answer 13

He utilizado el método de Newton para resolver este problema.

#include

#include

int main ()

{

flotante n, Ea = 2, Es = 0.00000000000000000000000000001, c, a = 1;

printf (“ingrese un número para encontrar su raíz”);

scanf (“% f”, & n);

while (abs (Ea)> = Es)

{

c = a;

a = (a- (a * an) / (2 * a));

Ea = ((ac)) * 100 / a;

}

printf (“% f”, a);

}

Answer 14

Este método se usa para encontrar la raíz cuadrada de una función. Precisamente este es el método de Newton para encontrar la raíz cuadrada.
asumiremos que la raíz cuadrada es s.
s is less than square root of x and x/s is greater than square root of x. Averaging these two (till the answer comes the same in two iterations) will give us the answer.
PD: Esto no funcionará para encontrar la raíz cuadrada de un número menor que 1.

flotador sqrt (int x)
{
int anterior, k = 0;
int kmax = 1000;
flotador s = 1;
para (k = 0; k {
prev = s;
s = (s + x / s) / 2;
si (anterior == s)
{
rotura;
}
}
devoluciones;
}

Answer 15

Método de Newton-Raphson

def sqr3 (n):
… K = 1.0
… Mientras que ((k * k – n)> 0.0000000001 o (n – k * k)> 0.0000000001):
… K = (k + n / k) / 2
… volver k

Answer 16

Puedes usar la búsqueda binaria. Digamos que quieres encontrar la raíz cuadrada de n. (No es necesario que sea un cuadrado perfecto). Tome el límite superior como n + 1 y el límite inferior como 0 y aplique la búsqueda binaria.

largo largo sqrt (largo largo n)
{
largo largo bajo = 0;
largo largo alto = n + 1;
while (alto – bajo> 1)
{
largo largo medio = (bajo + alto) / 2;
if (medio * medio <= n)
bajo = medio;
más
alto = medio;
}

volver bajo;
}

Answer 17

Esta es una manera simple y pequeña de encontrar la raíz cuadrada. Si tiene algún problema de tiempo. puede reducir algunos bucles de forma cero y volver.

float square_root (valor flotante)

{

flotador m;

para (m = 0; m valor) se rompe;

retorno m-0.000001;

}

Answer 18

Tiene que hacerse a través de la factorización (y pruebas de divisibilidad) del número dado y aplicando condiciones para enteros positivos, enteros negativos y cero

Answer 19

El método de lápiz y papel para resolver raíces cuadradas se basa en (x + 1) ^ 2 = x ^ 2 + 2x + 1.

Necesita dividir repetidamente el 2x + 1