Question

这里的问题是仅使用FOR循环得到幂的总和（m ^ 0 + m ^ 1 + m ^ 2 + m ^ 3 .... + m ^ n）。意思是，不使用任何其他循环以及Math.pow（）;

甚至可能吗？到目前为止，我只能努力获得m ^ n，但其余的不是。

    public static void main(String[] args){
    Scanner scn = new Scanner(System.in);
    int total  = 1;

    System.out.print("Enter value of m: ");
    int m = scn.nextInt(); 
    System.out.print("Enter value of n: ");
    int n = scn.nextInt();

        for (int i = 1; i <= n; i++){   
        total * m;
        }
    System.out.print(total);
}

假设m = 8;并且n = 4;

我给了'1,2,3,4'这是我需要的，但是我无法为我提供动力。

如果有人可以指导我如何做到这一点会很好，因为我对Java知识有限，似乎无法向前发展。

提前致谢！

Answer 1

你可能想要像这样重写它：

m^0 + m^1 + m^2 + m^3.... + m^n = 1 + m * (1 + m * (1 + m * (.... ) ) )

你可以在一个for循环中完成。

这应该可以胜任（见评论中的解释）：

public long count(long m, int pow) {
  long result = 1;
  for(int i = 0;i<pow; i++) {
    result*=m +1;
  }
  return result;
}

Answer 2

你可以嵌套循环。使用一个来计算功率，用另一个来计算它们。

Answer 3

你可以在下面做：

int mul = 1;
total = 1;
for(int i=1;i<=n;i++) {
    mul *= m;
    total += mul;
}
System.out.println(total);

Answer 4

您还可以使用几何系列的公式：

Sum[i = k..k+n](a^i) = (a^k - a^(k+n+1)) / (1 - a)
                     = a^k * (1 - a^(n+1)) / (1 - a)

有了这个，实现可以在单个for循环（或2个简单for循环）中完成：使用O（n）简单循环，或使用O（log n）{{ 3}}

然而，缺点是数据类型必须能够保持至少(1 - a^(n+1))，而通常总结只需要结果适合数据类型。

Answer 5

您可以使用单个循环，即O（N）而不是嵌套循环，即O（N ^ 2）

long total = 1, power = m
for (int i = 1; i <= n; i++){   
    total += power;
    power *= m;
}
System.out.print(total);

Answer 6

这是解决方案：

for(int i=0;i<n;i++){
temp=1;
for(int j=0;j<=i;j++){
    temp *= m;
}
total += temp;
}
System.out.println(total+1);

Answer 7

您可以使用自己的pow函数轻松计算能力，例如：

private static long power(int a, int b) {
    if (b < 0) {
        throw new UnsupportedOperationException("Negative powers not supported.");
    }
    if (b == 0) {
        return 1;
    }
    if (b == 1) {
        return a;
    }
    return a * power(a, b - 1);
}

然后简单地遍历所有值并添加它们：

long out = 0;
for (int i = 0; i <= n; ++i) {
    out += power(m, i);
}
System.out.println(out);

我想补充一点，这是一个经典的动态编程问题，因为m^n是m * m^(n-1)。因此，我会添加先前计算的权限的缓存，以便您不必重新计算。

private static Map<Integer, Long> powers;

public static void main(String args[]) {
    int m = 4;
    int n = 4;
    powers = new HashMap<>();
    long out = 0;
    for (int i = 0; i <= n; ++i) {
        out += power(m, i);
    }
    System.out.println(out);
    System.out.println(powers);
}

private static long power(int a, int b) {
    if (b < 0) {
        throw new UnsupportedOperationException("Negative powers not supported.");
    }
    if (b == 0) {
        return 1;
    }
    if (b == 1) {
        return a;
    }
    Long power = powers.get(b);
    if (power == null) {
        power = a * power(a, b - 1);
        powers.put(b, power);
    }
    return power;
}

此缓存计算值，以便您每次只计算 next 倍数。

仅使用For-Loops的两个整数的幂的总和

7 个答案: