Java 如何计算和系列1+；1/2…+；1/n

我很难非递归地找到这个级数的和 到目前为止，我已经：

public static double sum_nr(int n) {
    int result = 0;
    for (int i = 1; i<=n; i++)
    {
        result=result+1/(i+1);
    }
    return result;
}

public static void main(String[] args){ 
    int n= 4;
    System.out.println("Calculation for sum_nr(n) " + n + " is "+ sum_nr(n));
}    

public静态双和编号（int n）{
int结果=0；
对于（int i=1；i整数除法将导致0个结果。对于变量
结果
应使用
float
/
double
而不是
int
，整数除法将导致0个结果。对于变量
结果
整数除法应使用
float
/
double
而不是
int
er除法将导致0个结果。对于变量
结果
整数除法将导致0个结果。对于变量
结果
你应该使用
float
/
double
而不是
int
。我认为这不是因为我们选择正确的类型。您正在进行整数除法，而不是使用浮点类型

public static double sum_nr(int n) {
    double result = 0;
    for (double i = 0; i < n; i++)
    {
        result=result+1.0/(i+1);
    }
    return result;
}

public静态双和编号（int n）{
双结果=0；
for（双i=0；i
我认为这是因为没有使用正确的类型。您使用的是整数除法，而不是浮点类型

public static double sum_nr(int n) {
    double result = 0;
    for (double i = 0; i < n; i++)
    {
        result=result+1.0/(i+1);
    }
    return result;
}

public静态双和编号（int n）{
双结果=0；
for（双i=0；i
我认为这是因为没有使用正确的类型。您使用的是整数除法，而不是浮点类型

public static double sum_nr(int n) {
    double result = 0;
    for (double i = 0; i < n; i++)
    {
        result=result+1.0/(i+1);
    }
    return result;
}

public静态双和编号（int n）{
双结果=0；
for（双i=0；i
我认为这是因为没有使用正确的类型。您使用的是整数除法，而不是浮点类型

public static double sum_nr(int n) {
    double result = 0;
    for (double i = 0; i < n; i++)
    {
        result=result+1.0/(i+1);
    }
    return result;
}

public静态双和编号（int n）{
双结果=0；
for（双i=0；i
result=result+1/（i+1）；将始终给出0，因为i是一个整数。将i值赋给一个浮点并使用该值

float result=0f；//将结果声明为float too或double for（int）
i=1；iresult=result+1/（i+1）；当i是一个整数时，将始终给出0。将i值赋给一个浮点并使用它

float result=0f；//将结果声明为float too或double for（int）
i=1；iresult=result+1/（i+1）；当i是一个整数时，将始终给出0。将i值赋给一个浮点并使用它

float result=0f；//将结果声明为float too或double for（int）
i=1；iresult=result+1/（i+1）；当i是一个整数时，将始终给出0。将i值赋给一个浮点并使用它

float result=0f；//将结果声明为float too或double for（int）
i=1；i和其他人说的一样，但他们的答案并不完整

public static double sum_nr(int n) {
    float result = 0;
    for (int i = 1; i<=n; i++){
        result=result+1/((float)i+1);
    }
    return result;
}

public静态双和编号（int n）{
浮动结果=0；
因为（inti=1；i和其他人说的一样，但他们的答案并不完整

public static double sum_nr(int n) {
    float result = 0;
    for (int i = 1; i<=n; i++){
        result=result+1/((float)i+1);
    }
    return result;
}

public静态双和编号（int n）{
浮动结果=0；
因为（inti=1；i和其他人说的一样，但他们的答案并不完整

public static double sum_nr(int n) {
    float result = 0;
    for (int i = 1; i<=n; i++){
        result=result+1/((float)i+1);
    }
    return result;
}

public静态双和编号（int n）{
浮动结果=0；
因为（inti=1；i和其他人说的一样，但他们的答案并不完整

public static double sum_nr(int n) {
    float result = 0;
    for (int i = 1; i<=n; i++){
        result=result+1/((float)i+1);
    }
    return result;
}

public静态双和编号（int n）{
浮动结果=0；
对于（inti=1；i你所指的序列是，有一个封闭的近似形式

H(n) = ln(n) + gamma + 1/(2n) - 1/(12n^2)

其中gamma是Euler-Mascheroni常数。请参阅

在Java中，这里有一些代码可以正确计算并显示随着
n
的增长近似值与实际值的差异。它将逐渐变小：

constant double EULER_MASCHERONI = 0.57721566490153286060651209008240243104215933593992;

public static double approximateHarmonicSummation(int n) {
    return Math.log(n) + EULER_MASCHERONI + 0.5 * n - 1.0 / (12.0 * Math.pow(n, 2));
}

public static double sum_nr(int n) {
    double result = 0;
    for (double i = 0; i < n; i++) {
        result += 1.0 / (i + 1);
    }
    return result;
}

public static void main(String[] args) {
    double approx = 0.0;
    double actual = 0.0;
    for (int n = 0; n < 1000; n++) {
       approx = approximateHarmonicSummation(n);
       actual = sum_nr(n);
       System.out.println("Calculation for approximation of sum_nr(n) " + n + " is "+ approx);
       System.out.println("Calculation of sum_nr(n) " + n + " is "+ actual);
       System.out.printlin("Difference = " + (actual - approx) + "\n");
    }
} 

constant double EULER_MASCHERONI=0.57721566490153286060651209008240243104215933992；
公共静态双近似谐波和（int n）{
返回Math.log（n）+EULER_MASCHERONI+0.5*n-1.0/（12.0*Math.pow（n，2））；
}
公共静态双和编号（整数n）{
双结果=0；
for（双i=0；i

希望这会有所帮助。
您所指的系列是。这有一个封闭的近似形式

H(n) = ln(n) + gamma + 1/(2n) - 1/(12n^2)

其中gamma是Euler-Mascheroni常数。请参阅

在Java中，这里有一些代码可以正确计算并显示随着
n
的增长近似值与实际值的差异。它将逐渐变小：

constant double EULER_MASCHERONI = 0.57721566490153286060651209008240243104215933593992;

public static double approximateHarmonicSummation(int n) {
    return Math.log(n) + EULER_MASCHERONI + 0.5 * n - 1.0 / (12.0 * Math.pow(n, 2));
}

public static double sum_nr(int n) {
    double result = 0;
    for (double i = 0; i < n; i++) {
        result += 1.0 / (i + 1);
    }
    return result;
}

public static void main(String[] args) {
    double approx = 0.0;
    double actual = 0.0;
    for (int n = 0; n < 1000; n++) {
       approx = approximateHarmonicSummation(n);
       actual = sum_nr(n);
       System.out.println("Calculation for approximation of sum_nr(n) " + n + " is "+ approx);
       System.out.println("Calculation of sum_nr(n) " + n + " is "+ actual);
       System.out.printlin("Difference = " + (actual - approx) + "\n");
    }
} 

constant double EULER_MASCHERONI=0.57721566490153286060651209008240243104215933992；
公共静态双近似谐波和（int n）{
返回Math.log（n）+EULER_MASCHERONI+0.5*n-1.0/（12.0*Math.pow（n，2））；
}
公共静态双和编号（整数n）{
双结果=0；
for（双i=0；i

希望这会有所帮助。
您所指的系列是。这有一个封闭的近似形式

H(n) = ln(n) + gamma + 1/(2n) - 1/(12n^2)

伽马在哪里