C++ 幂运算的前n位

如何确定指数运算（ab）的前n位

---

在这种情况下，使用幻数12,13,4：

#include <sstream>
#include <iomanip>
#include <cmath>

double a = 12;
int b = 13;
double result = std::pow(a,b);

std::stringstream strVal;
strVal.setf( ios::fixed, ios::floatfield );
strVal << result;
std::string output(strVal.str().substr(0,4));

intVal=1069

编辑：

---

这适用于结果不会溢出的任何组合，从编程角度来说，最简单的方法是使用stringstream将索引结果转换为字符串，然后取n个最有效（即左）字符

如果您想要一种没有字符串的方式，那么这将起作用：

#include <iostream>
#include <sstream>
#include <math.h>

using namespace std;

double nDigExp( double a, double b, int n )
{
    stringstream ss;
    ss.setf( ios::fixed, ios::floatfield );
    ss << pow(a,b);
    double ret;
    for ( int i = 0; i < n; ++i) ret = (10 * ret) + (ss.get() - '0'); // Yeuch!!
    return ret;
}

int main( )
{
    double result = nDigExp( 12, 13, 4 );

    cout << result << endl;

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
双nDigExp（双a，双b，整数n）
{
细流ss；
setf（ios:：fixed，ios:：floatfield）；
ss通过以下迭代计算ab：

a1=a1，

a2=a2，

…

ai=ai，

…

ab=ab

你有ai+1=ai×a。计算每个ai并不精确。问题是ab的相对误差小于a相对误差的n倍。

您希望得到小于10-n的最终相对误差。因此，每个步骤的相对误差可能是。请删除每个步骤的最后数字

例如，a=2，b=16，n=1。最终相对误差为10-n=0.1。每一步的相对误差为0.1/16>0.001。因此，每一步有3位数字很重要。如果n=2，则必须保存4位数字。常见规则：在每一步保存[n+log10 b]位

2（1）、4（2）、8（3）、16（4）、32（5）、64（6）、128（7）、256（8）、512（9）、1024（10）→ 102，

204 (11), 408 (12), 816 (13), 1632 (14) → 163326（15），652（16）

答:六,

该算法具有O（b）的竞争性。但是很容易将其更改为O（logb）
另一个解决方案，使用log10：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(int argc, char **argv) {
       int a = 12;
       int b = 13;
       int n = 4;
       double x, y;

       x = b * log10(a);
       y = floor(pow(10, x - floor(x) + n - 1));
       printf("Result: %d\n", (int)y);

       return EXIT_SUCCESS;
}

#包括
#包括
#包括
int main（int argc，字符**argv）{
INTA=12；
int b=13；
int n=4；
双x，y；
x=b*log10（a）；
y=楼层（pow（10，x-楼层（x）+n-1））；
printf（“结果：%d\n”，（int）y）；
返回退出成功；
}
n=9k=3n^n=387420489，答案应该是387


这和@RC在他的代码中所做的是一样的。
谢谢你，RC，我只是展示了你的代码的数学表示。我看到了，但是我没有清晰的图片。CLD有人简单地阐述了。在Mas.StasExchange上这不是更好吗？我在这里没有看到一个编程问题。@马克B：考虑到它被标记的语言，以及代码“SNPrTNTF < /代码>或C++等价物”的事实。可能是一种不需要自己编写算法的可能实现，我认为这个问题完全适用于此。@R问题没有说明允许您将自己限制为可由
double
表示的一组值，我认为它们可能是任意的。开发适当的算法hm只生成第一个
n
数字更适合math.stackexchange。我以前从编程的角度问过类似的数学问题（）而且从来没有人质疑过它是否离题。即使对于大数字，只要结果不溢出，这是否正确？
double
？我怀疑是这样，但作为完整答案的一部分，它值得讨论。@R..-很好的一点，编辑为使用
long double
，并添加注释
long double
，很可能是相同的Windows上的s
double
。对代码是否会受到浮点不精确性的影响进行一些分析，总比在代码上使用更大的类型来掩盖问题要好。@R..-它与运行库的pow函数一样精确，不是吗？我是否遗漏了要点？除非系统的浮点到十进制转换n比任何规范要求的都好，即使
pow（a，b）
是可精确表示的（如果
a
是2的幂，则始终如此），它也会因
n>十进制而失败。我不确定是否还有其他故障情况。我认为只要
n
明显小于
DECIMAL\u DIG
，就可以了。每个步骤的相对误差是（10^（-n））/b，这意味着如何推导它？您能解释一下吗？
#include <iostream>
#include <sstream>
#include <math.h>

using namespace std;

double nDigExp( double a, double b, int n )
{
    stringstream ss;
    ss.setf( ios::fixed, ios::floatfield );
    ss << pow(a,b);
    double ret;
    for ( int i = 0; i < n; ++i) ret = (10 * ret) + (ss.get() - '0'); // Yeuch!!
    return ret;
}

int main( )
{
    double result = nDigExp( 12, 13, 4 );

    cout << result << endl;

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(int argc, char **argv) {
       int a = 12;
       int b = 13;
       int n = 4;
       double x, y;

       x = b * log10(a);
       y = floor(pow(10, x - floor(x) + n - 1));
       printf("Result: %d\n", (int)y);

       return EXIT_SUCCESS;
}