C#的标准库是否有一种简单的方法来检查一个数字是否是另一个数字的幂？

我想看看是否有一个好方法来确定，给定

int

s

b

和

n

，是否存在一个int

a

这样的

a^n=b

。换句话说，这比我在下面写的糟糕的解决方案更有效

private static bool HasBase(int b, int n)
{
    for(int a = 1; a <= int.MaxValue; ++a)
    {
        int pow = Power(a, n);
        if(pow == b)
            return true;
        else if(pow > b)
            return false;
    }
    return false;   
}

private static int Power(int a, int n) 
{
    return Enumerable.Range(a, n).Aggregate(1, (prev, cur) => prev * cur);
}

private static bool HasBase（int b，int n）
{
对于（INTA=1；AB）
返回false；
}
返回false；
}
专用静态整数功率（整数a、整数n）
{
返回可枚举范围（a，n）.聚合（1，（上一个，当前）=>上一个*cur）；
}

它有Math.log（double，double）函数，可以在第二个数字的底部找到第一个数字的日志。如果这是一个整体，那么它就是一种力量。例如，如果我想知道x是否是2的幂，我可以写：

bool isAPower = (Decimal)(Math.Log(x,2))%1==0;

换句话说，取x的对数基数2，如果除以1，则求余数。如果mod为0，则为真；如果不是0，则为假

它有Math.log（double，double）函数，它在第二个数字的底部查找第一个数字的日志。如果这是一个整体，那么它就是一种力量。例如，如果我想知道x是否是2的幂，我可以写：

bool isAPower = (Decimal)(Math.Log(x,2))%1==0;

---

换句话说，取x的对数基数2，如果除以1，则求余数。如果mod为0，则为真；如果不是0，则为假

您可以找到

b

的所有因子，并检查同一因子是否只重复

n

或

xn

次。因为

x^n*y^n=（xy）^n=a^n

或

x^（2n）=（xx）^n=a^n

public static bool HasBase(int b, int n)
{
    // find all factors of b
    var factors = new List<int>();
    var dividers = Enumerable.Range(2, (int)Math.Round(Math.Sqrt(b) + 1)).GetEnumerator();
    dividers.MoveNext();
    while (true)
    {
        if (b % dividers.Current != 0)
        {
            if (dividers.MoveNext())
                continue;
            else
                break;
        }

        b /= dividers.Current;
        factors.Add(dividers.Current);
    }

    // if the base of each power can be divided by 3, a^n=b should be true.
    return multiples
        .GroupBy(x => x)
        .All(g => g.Count() % 3 == 0)
}

publicstaticboolhasbase（intb，intn）
{
//找出b的所有因子
var factors=新列表（）；
var dividers=Enumerable.Range（2，（int）Math.Round（Math.Sqrt（b）+1））.GetEnumerator（）；
dividers.MoveNext（）；
while（true）
{
如果（b%分压器电流！=0）
{
if（dividers.MoveNext（））
继续；
其他的
打破
}
b/=分压器。电流；
因子。添加（除数。当前值）；
}
//如果每个幂的基数可以除以3，则a^n=b应为真。
返回倍数
.GroupBy（x=>x）
.All（g=>g.Count（）%3==0）
}

您可以找到

b

的所有因子，并检查同一因子是否只重复

n

或

xn

次。因为

x^n*y^n=（xy）^n=a^n

或

x^（2n）=（xx）^n=a^n

public static bool HasBase(int b, int n)
{
    // find all factors of b
    var factors = new List<int>();
    var dividers = Enumerable.Range(2, (int)Math.Round(Math.Sqrt(b) + 1)).GetEnumerator();
    dividers.MoveNext();
    while (true)
    {
        if (b % dividers.Current != 0)
        {
            if (dividers.MoveNext())
                continue;
            else
                break;
        }

        b /= dividers.Current;
        factors.Add(dividers.Current);
    }

    // if the base of each power can be divided by 3, a^n=b should be true.
    return multiples
        .GroupBy(x => x)
        .All(g => g.Count() % 3 == 0)
}

publicstaticboolhasbase（intb，intn）
{
//找出b的所有因子
var factors=新列表（）；
var dividers=Enumerable.Range（2，（int）Math.Round（Math.Sqrt（b）+1））.GetEnumerator（）；
dividers.MoveNext（）；
while（true）
{
如果（b%分压器电流！=0）
{
if（dividers.MoveNext（））
继续；
其他的
打破
}
b/=分压器。电流；
因子。添加（除数。当前值）；
}
//如果每个幂的基数可以除以3，则a^n=b应为真。
返回倍数
.GroupBy（x=>x）
.All（g=>g.Count（）%3==0）
}

原始问题的标题和正文之间存在差异。假设文本正确，OP希望找到给定的

a

、

b

和

X^a==b

。这里有一个粗略的算法可以做到这一点，但它不是完美的整数。当使用任何内置数学函数执行此类计算时，浮点错误总是会突然出现。唯一的替代方法是执行一些计算密集型循环

// given
int value = ...;
int power = ...;

// calculate the [power]th root of [value]
var root = value >= 0
    ? Math.Pow(value, 1d / power)
    : Math.Abs(power % 2) == 1
        ? -Math.Pow(-value, 1d / power)
        : Double.NaN;

// determine if [root] is an int
var root_is_int = Math.Abs(root - Math.Round(root)) <= Double.Epsilon;

//给定
int值=。。。；
整数幂=。。。；
//计算[值]的[幂]次方
变量根=值>=0
? 功率（数值，1d/功率）
：Math.Abs（功率%2）==1
? -数学功率（-值，1d/功率）
：Double.NaN；
//确定[root]是否为int
var root_is_int=Math.Abs（root-Math.Round（root））原始问题的标题和文本之间存在差异。假设文本正确，OP希望找到给定的
a
、
b
和
X^a==b
。这里有一个粗略的算法可以做到这一点，但它不是完美的整数。当使用任何内置数学函数执行此类计算时，浮点错误总是会突然出现。唯一的替代方法是执行一些计算密集型循环

// given
int value = ...;
int power = ...;

// calculate the [power]th root of [value]
var root = value >= 0
    ? Math.Pow(value, 1d / power)
    : Math.Abs(power % 2) == 1
        ? -Math.Pow(-value, 1d / power)
        : Double.NaN;

// determine if [root] is an int
var root_is_int = Math.Abs(root - Math.Round(root)) <= Double.Epsilon;

//给定
int值=。。。；
整数幂=。。。；
//计算[值]的[幂]次方
变量根=值>=0
? 功率（数值，1d/功率）
：Math.Abs（功率%2）==1
? -数学功率（-值，1d/功率）
：Double.NaN；
//确定[root]是否为int
var root_is_int=Math.Abs（root-Math.Round（root））简短回答，否。以下是一些数学示例，其中包含了执行此任务的有效算法：Math.Pow？我是一个数学失败者，考虑到我的职业生涯，我觉得很讽刺，但我相信这就是你想要的？标准图书馆里没有太多类似的东西，但当然你不必像这样粗暴地对待它。你也应该更加小心，很多这些能力都会溢出，这可能会给你带来误判。@Trey这是在计算根，而不是能力。OP希望在等式
a^n=b
中计算
a
，而不是
b
。lol谢谢，我应该回到课堂：-）简短的回答，不。这里有一些数学示例，有一些有效的算法来完成这项任务：math.Pow？我是一个数学失败者，考虑到我的职业生涯，我觉得很讽刺，但我相信这就是你想要的？标准图书馆里没有太多类似的东西，但当然你不必像这样粗暴地对待它。你也应该更加小心，很多这些能力都会溢出，这可能会给你带来误判。@Trey这是在计算根，而不是能力。OP希望在方程式
a^n=b
中计算
a
，而不是
b
。lol谢谢，我应该回到课堂：-）或者使用OP的函数
私有静态bool HasBase（int