将Python代码的素数和转换为Java代码

基本上，我需要帮助将以下Python代码翻译成Java

在过去的一天里，我试图学习一点Python，以便转换它，但有些事情我不明白。我试图用Java实现它，但仍然不起作用。如果看不到“正确的”Java翻译，我就看不到我的算法哪里出错了，转换哪里出错了。代码使用动态规划来计算小于

n

的所有素数之和。如果我没有弄错的话，“assert”是java“while”but的同义词。。不完全确定。特别是我不确定后面的三行。其余的我想我可以改变。因此，如果有人能帮助我将这段代码转换成Java，我将不胜感激，因为我无法翻译所有代码，即使这是一段相当短的代码。谢谢

def SOP（n）：
r=int（n**0.5）
断言r*r n
V=[n//i代表范围（1，r+1）内的i]
V+=列表（范围（V[-1]-1,0，-1））
S={i:i*（i+1）//2-1表示V}
对于范围（2，r+1）内的p：
如果S[p]>S[p-1]：
sp=S[p-1]
p2=p*p
对于v中的v：
如果v

我尝试的Java代码：

public static long sumOfAllPrimesBelowLimit (long n)
    {
        long r = (long) Math.sqrt(n);
        ArrayList <Long> S = new ArrayList<Long>();

        while (r*r<=n&&(r+1)*(r+1)>n)
        {
            ArrayList <Long> V = new ArrayList <Long> ();
            for (long i = 1;i<=r+1;i++)
                V.add(n/i);

            // V += list(range(V[-1]-1,0,-1)) - I don't know what this means at all

            for (long i:V)
                S.add(i*(i+1)/2-1);
            for (int p=2;p<=r+1;p++)
                if (S.get(p)>S.get(p-1))
                {
                    long sp=S.get(p-1);
                    long p2 = p*p;
                    for (long v:V)
                    {
                        if (v<p2)
                        {
                            break;
                        }
                        S.add((int) v, S.get((int) v)-p*(S.get((int) (v/p))-sp));
                    }
                }
        }
        return S.get((int) n);
    }

public静态长sumOfAllPrimesBelowLimit（长n）
{
long r=（long）Math.sqrt（n）；
ArrayList S=新的ArrayList（）；
while（r*rn）
{
ArrayList V=新的ArrayList（）；
for（long i=1；i
assert
是Java
assert
的同义词（如果不满足，就会抛出错误）。Python有一个
while
循环，其工作方式与Java的
while
循环相同

这就是说，这里有一些Java。在我目前的情况下，我没有办法测试这一点，而且我已经有一段时间没有使用Java了，但它应该或多或少可以工作。您可能需要在
int
和
Integer
之间进行一些强制转换（或者用
long
s，idk替换所有内容），但是您的编译器/堆栈跟踪应该告诉您在哪里

public int SOP(int n) {
    // r = int(n**0.5)
    int r = (int) Math.sqrt(n);                                 
    //  assert r*r <= n and (r+1)**2 > n
    if(!(r * r <= n && (r+1) * (r+1) > n))
        throw new IllegalArgumentException("Assertion error");
    // V = [n//i for i in range(1,r+1)]
    ArrayList<Integer> V = new ArrayList<Integer>();
    for(int i = 1; i < r+1; i++)
        V.add(n / i);
    //V += list(range(V[-1]-1,0,-1))
    for(int i = V[V.size()-1]; i > 0; i--)
        V.add(i);
    // S = {i:i*(i+1)//2-1 for i in V}
    HashMap<Integer, Integer> S = new HashMap<Integer, Integer>();
    for(int i : V)
         S.put(i, (i*(i+1)/2 - 1));
    // for p in range(2,r+1):
    for(int p = 2; p < r+1; p++ {
        // if S[p] > S[p-1]: 
        if S.get(p) > S.get(p-1) {
            // sp = S[p-1]
            int sp = S.get(p-1);
            // p2 = p*p
            int p2 = p * p;
            // for v in V:
            for(int v : V) {
                // if v < p2: break
                if(v < p2)
                    break;
                // S[v] -= p*(S[v//p] - sp)
                S.put(v, S.get(v) - p*(S.get(v/p)-sp));
            }
        }
    }
    // return S[n]
    return S.get(n);
}

公共内部SOP（内部n）{
//r=int（n**0.5）
int r=（int）Math.sqrt（n）；
//断言r*r n
如果（！（r*r n））
抛出新的IllegalArgumentException（“断言错误”）；
//V=[n//i代表范围（1，r+1）内的i]
ArrayList V=新的ArrayList（）；
对于（int i=1；i0；i--）
五.添加（i）；
//S={i:i*（i+1）//2-1表示V}
HashMap S=新的HashMap（）；
对于（int i:V）
S.put（i，（i*（i+1）/2-1））；
//对于范围（2，r+1）内的p：
对于（int p=2；pS[p-1]：
如果S.get（p）>S.get（p-1）{
//sp=S[p-1]
int sp=S.get（p-1）；
//p2=p*p
int p2=p*p；
//对于v中的v：
对于（int v:v）{
//如果v


也就是说，这个算法有些迟钝。如果是我，我只需要编写一个
is_prime（）
函数，然后从
0
到
n
进行计数，并添加已完成的部分。后一步可以在python的一行中完成，在Java中不需要这么多。
您能在这里发布您尝试的翻译吗？当然，这有点混乱。现在就包括在内。@sweerit有效！非常感谢！不要该算法的优越性在于它是次线性的。它在某种程度上基于erathosthenes的筛选，并在地板函数上使用dirichlet卷积来降低次线性时间的复杂性。使用
是_prime（）
即使限制为
10^8
，函数也需要很长时间才能完成。此算法大约在一分钟内完成
10^12
。再次感谢！