Question

我刚刚对鳕鱼进行了编码采访

我被要求实施以下内容，但我无法在20分钟内完成，现在我在这里从这个社区获得想法

编写一个函数public int whole_cubes_count ( int A,int B )，它应返回

范围内的整个多维数据集

例如，如果A = 8且B = 65，则范围内的所有可能立方体都是2 ^ 3 = 8,3 ^ 3 = 27和4 ^ 3 = 64，因此该函数应返回计数3

我无法弄清楚如何将数字识别为整个多维数据集。我该如何解决这个问题？

A和B的范围可以从[-20000到20000]

这就是我试过的

import java.util.Scanner;
class Solution1 {
  public int whole_cubes_count ( int A,int B ) {
      int count =0;

    while(A<=B)
    {
        double v = Math.pow(A, 1 / 3); // << What goes here?
        System.out.println(v);
        if (v<=B)
            {
            count=count+1;
            }
        A =A +1;
    }
    return count ;
  }

  public static void main(String[] args) 
  {
    System.out.println("Enter 1st Number");
    Scanner scan = new Scanner(System.in);
    int s1 = scan.nextInt();
    System.out.println("Enter 2nd Number");
    //Scanner scan = new Scanner(System.in);
    int s2 = scan.nextInt();
    Solution1 n = new Solution1();
     System.out.println(n.whole_cubes_count (s1,s2));
  }
}

Answer 1

对于积极的立方体：

i = 1
while i^3 < max
    ++i

类似于负立方体，但在比较中具有绝对值。

为了使这更加通用，在i和i^3 >= min都为正的情况下，您需要找到min max的值。min如果max和{{1}}都是否定的，则类似的解决方案有效。

Answer 2

沮丧和肮脏，这就是我说的。

如果你只有20分钟，那么他们不应该期待超级优化的代码。所以不要尝试。发挥系统的限制，只说+20,000到-20,000作为范围。你知道立方体值必须在27以内，因为27 * 27 * 27 = 19683。

public int whole_cubes_count(int a, int b) {
    int count = 0;
    int cube;
    for (int x = -27; x <= 27; x++) {
        cube = x * x * x;
        if ((cube >= a) && (cube <= b))
            count++;
    }
    return count;
}

Answer 3

嗯，它可以用O（1）复杂度计算，我们需要找到适合该范围的最大立方体，以及最小的立方体。所有介于两者之间的人显然也会在里面。

def n_cubes(A, B):
    a_cr = int(math.ceil(cube_root(A)))
    b_cr = int(math.floor(cube_root(B)))

    if b_cr >= a_cr:
        return b_cr - a_cr + 1
    return 0

确保您的cube_root返回实际多维数据集的整数。作为要点的完整解决方案https://gist.github.com/tymofij/9035744

Answer 4

int countNoOfCubes(int a, int b) {
        int count = 0;
        for (int startsCube = (int) Math.ceil(Math.cbrt(a)); Math.pow(
                startsCube, 3.0) <= b; startsCube++) {
            count++;
        }
        return count;
    }

Answer 5

@Tim建议的解决方案比@Erick提供的解决方案快，特别是当A ... B范围增加时。让我在这里引用github的理由： “人们可以注意到任何x> y的x³>y³（称为单调函数）因此，对于任何位于∛A≤x≤∛B的x，立方体拟合：A≤x³≤B

因此，要获得位于A..B内的立方体数量，您可以简单地计算∛A和∛B之间的整数数。两个数字之间的整数是它们的区别。“

看起来完全正确，不是吗？它适用于任何动力，不仅适用于立方体。这是我的java的cube_root方法的端口：

/*
 * make sure your cube_root returns integers for actual cubes
 */
static double cubeRoot(int x) {
    //negative number cannot be raised to a fractional power
    double res = Math.copySign(Math.pow(Math.abs(x), (1.0d/3)) , x);
    long rounded_res = symmetricRound(res);
    if (rounded_res * rounded_res * rounded_res == x)
        return rounded_res;
    else
        return res;
}

private static long symmetricRound( double d ) {
    return d < 0 ? - Math.round( -d ) : Math.round( d );
}

我知道java中的Math.cbrt，但是使用Math.pow方法很容易为其他指数推广解决方案。

采访：在两个整数范围之间找到整个多维数据集

5 个答案: