Sword se réfère à la question de l'offre 16-la puissance entière de la valeur

Puissance entière

Titre: Implémenter la fonction double Power (double base, int exposant),
trouver la base à l'exposant puissance. N'utilisez pas les fonctions de bibliothèque et n'avez pas besoin de prendre en compte de grands nombres

Parce qu'il n'est pas nécessaire de considérer de grands nombres, cela semble très simple, il suffit de faire la somme.

double Power(double base,int exponent)
{
    
    
	double result=1.0;
	for(int i=0;i<=exponent;++i)
		result*=result;
	return result;
}

Mais il y a un problème sérieux: que dois-je faire si l'exposant d'entrée est inférieur à 1 (0 et négatif)? De toute évidence, le code ci-dessus ne prend pas en compte

Après réflexion, le code est le suivant:

bool g_InvalidInput=false;

double Power(double base,int exponent)
{
    
    
	g_InvalidInput=false;
	
	if(equal(base,0.0) && exponent<0)
	{
    
    
		g_InvalidInput=true;
		return 0.0;
	}
	
	unsigned int absExponent=(unsigned int)(exponent);
	if(exponent<0)
		absExponent=(unsigned int)(-exponent);
	
	double result=PowerWithUnsignedExponent(base,absExponent)
	if(exponent<0)
		result=1.0/result;
	return result;
}

double PowerWithUnsignedExponent(double base,unsigned int exponent)
{
    
    
	double result=1.0;
	for(int i=1;i<=exponent;++i)
		result*=base;
	return result;
}

Bien qu'il y ait une réponse correcte, vous constaterez que cette efficacité est trop faible. Existe-t-il un moyen simple?
Bien sûr qu'il y en a!

Imaginez ceci: si notre objectif est de trouver un nombre à la 32e puissance, si nous connaissons sa 16e puissance, alors placez-le à la 16e puissance. 16 peut être carré à la 8e puissance ...

En d'autres termes, nous pouvons utiliser la formule suivante pour trouver la n-ième puissance de a:

Cette formule est facilement implémentée par récursivité. Le nouveau code PowerWithUnsignedExponent est le suivant:

PowerWithUnsignedExponent(double base,unsigned int exponent)
{
    
    
	if(exponent==0)
		return 1;
	if(exponent==1)
		return base;
	
	double result=PowerWithUnsignedExponent(base,expnent>>1);
result*=result;
if(exponent & 0x1==1)
	return*=base;
return result;
}

Ainsi, vous pouvez obtenir un code efficace

Le code complet est le suivant:

double Power(double base, int exponent)
{
    
    
    g_InvalidInput = false;

    if (equal(base, 0.0) && exponent < 0)
    {
    
    
        g_InvalidInput = true;
        return 0.0;
    }

    unsigned int absExponent = (unsigned int) (exponent);
    if (exponent < 0)
        absExponent = (unsigned int) (-exponent);

    double result = PowerWithUnsignedExponent(base, absExponent);
    if (exponent < 0)
        result = 1.0 / result;

    return result;
}

double PowerWithUnsignedExponent(double base, unsigned int exponent)
{
    
    
    if (exponent == 0)
        return 1;
    if (exponent == 1)
        return base;

    double result = PowerWithUnsignedExponent(base, exponent >> 1);
    result *= result;
    if ((exponent & 0x1) == 1)
        result *= base;

    return result;
}

bool equal(double num1, double num2)
{
    
    
    if ((num1 - num2 > -0.0000001) && (num1 - num2 < 0.0000001))
        return true;
    else
        return false;
}

—————————————————————————————————————————
Livre de référence "Sword Finger Offer》