谐波级数总和

给定级数’a’的第一个元素，则元素’d’和级数’n’的项数之间的共同差异为，其中$n, d, a \in [1, 100000]$ 。任务是使用以上信息生成谐波级数。
例子：

Input : a = 12, d = 12, n = 5 
Output : Harmonic Progression :
         1/12 1/24 1/36 1/48 1/60 

         Sum of the generated harmonic 
         progression : 0.19
         
         Sum of the generated harmonic 
         progression using approximation :0.19    

算术级数：在算术级数(AP)或算术序列中，是一个数字序列，其连续项之间的差是恒定的。
谐波级数：谐波级数(或谐波序列)是通过取算术级数的倒数而形成的级数。
现在，我们需要生成这种谐波级数。我们甚至必须计算所生成序列的总和。
1.生成HP或1 / AP是一项简单的任务。 AP中的第N个项= a +(n-1)d。使用此公式，我们可以轻松生成序列。
2.计算此进度或序列的总和可能是一项耗时的任务。我们既可以在生成此序列时进行迭代，也可以使用一些近似值，并得出一个公式，该公式可以为我们提供精确到小数点后一位的值。下面是一个近似公式。

Sum = 1/d (ln(2a + (2n – 1)d) / (2a – d))

有关以上公式的详细信息，请参考brilliant.org。
下面是上述公式的实现。

C++

// C++ code to generate Harmonic Progression
// and calculate the sum of the progression.
#include 
using namespace std;
 
// Function that generates the harmonic progression
// and calculates the sum of its elements by iterating.
double generateAP(int a, int d, int n, int AP[])
{
    double sum = 0;
    for (int i = 1; i <= n; i++)
    {
 
        // HP = 1/AP
        // In AP, ith term is calculated by a+(i-1)d;
        AP[i] = (a + (i - 1) * d);
 
        // Calculating the sum.
        sum += (double)1 / (double)((a + (i - 1) * d));
    }
    return sum;
}
 
// Function that uses riemenn sum method to calculate
// the approximate sum of HP in O(1) time complexity
double sumApproximation(int a, int d, int n)
{
    return log((2 * a + (2 * n - 1) * d) /
                            (2 * a - d)) / d;
}
 
// Driver code
int main()
{
    int a = 12, d = 12, n = 5;
    int AP[n + 5] ;
     
    // Generating AP from the above data
    double sum = generateAP(a, d, n, AP);
 
    // Generating HP from the generated AP
    cout<<"Harmonic Progression :"<

---

Java

// Java code to generate Harmonic Progression
// and calculate the sum of the progression.
import java.util.*;
import java.lang.*;
 
class GeeksforGeeks {
 
    // Function that generates the harmonic progression
    // and calculates the sum of its elements by iterating.
    static double generateAP(int a, int d, int n, int AP[])
    {
        double sum = 0;
        for (int i = 1; i <= n; i++) {
 
            // HP = 1/AP
            // In AP, ith term is calculated by a+(i-1)d;
            AP[i] = (a + (i - 1) * d);
 
            // Calculating the sum.
            sum += (double)1 / (double)((a + (i - 1) * d));
        }
        return sum;
    }
 
    // Function that uses riemenn sum method to calculate
    // the approximate sum of HP in O(1) time complexity
    static double sumApproximation(int a, int d, int n)
    {
 
        return Math.log((2 * a + (2 * n - 1) * d) /
                                 (2 * a - d)) / d;
    }
 
    public static void main(String args[])
    {
        int a = 12, d = 12, n = 5;
        int AP[] = new int[n + 5];
         
        // Generating AP from the above data
        double sum = generateAP(a, d, n, AP);
 
        // Generating HP from the generated AP
        System.out.println("Harmonic Progression :");
        for (int i = 1; i <= n; i++)
            System.out.print("1/" + AP[i] + " ");
        System.out.println();
        String str = "";
        str = str + sum;
        str = str.substring(0, 4);
 
        System.out.println("Sum of the generated" +
                  " harmonic progression : " + str);
        sum = sumApproximation(a, d, n);
 
        str = "";
        str = str + sum;
        str = str.substring(0, 4);
        System.out.println("Sum of the generated " +
           "harmonic progression using approximation : "
                                              + str);
    }
}

Python3

# Python3 code to generate Harmonic Progression
# and calculate the sum of the progression.
import math
 
# Function that generates the harmonic
# progression and calculates the sum of
# its elements by iterating.
n = 5;
AP = [0] * (n + 5);
 
def generateAP(a, d, n):
    sum = 0;
    for i in range(1, n + 1):
         
        # HP = 1/AP
        # In AP, ith term is calculated
        # by a+(i-1)d;
        AP[i] = (a + (i - 1) * d);
 
        # Calculating the sum.
        sum += float(1) / float((a + (i - 1) * d));
    return sum;
 
# Function that uses riemenn sum method to calculate
# the approximate sum of HP in O(1) time complexity
def sumApproximation(a, d, n):
 
        return math.log((2 * a + (2 * n - 1) * d) /
                                 (2 * a - d)) / d;
 
# Driver Code
a = 12;
d = 12;
#n = 5;
 
# Generating AP from the above data
sum = generateAP(a, d, n);
 
# Generating HP from the generated AP
print("Harmonic Progression :");
for i in range(1, n + 1):
    print("1 /", AP[i], end = " ");
print("");
str1 = "";
str1 = str1 + str(sum);
str1 = str1[0:4];
 
print("Sum of the generated harmonic",
               "progression :", str1);
sum = sumApproximation(a, d, n);
 
str1 = "";
str1 = str1 + str(sum);
str1 = str1[0:4];
print("Sum of the generated harmonic",
      "progression using approximation :", str1);
 
# This code is contributed by mits

C#

// C# code to generate Harmonic
// Progression and calculate
// the sum of the progression.
using System;
 
class GFG
{
    // Function that generates
    // the harmonic progression
    // and calculates the sum of
    // its elements by iterating.
    static double generateAP(int a, int d,
                             int n, int []AP)
    {
        double sum = 0;
        for (int i = 1; i <= n; i++)
        {
 
            // HP = 1/AP
            // In AP, ith term is
            // calculated by a+(i-1)d;
            AP[i] = (a + (i - 1) * d);
 
            // Calculating the sum.
            sum += (double)1 /
                   (double)((a + (i - 1) * d));
        }
        return sum;
    }
 
    // Function that uses riemenn
    // sum method to calculate
    // the approximate sum of HP
    // in O(1) time complexity
    static double sumApproximation(int a,
                                   int d, int n)
    {
 
        return Math.Log((2 * a +
                        (2 * n - 1) * d) /
                        (2 * a - d)) / d;
    }
 
    // Driver code
    static void Main()
    {
        int a = 12, d = 12, n = 5;
        int []AP = new int[n + 5];
         
        // Generating AP from
        // the above data
        double sum = generateAP(a, d, n, AP);
 
        // Generating HP from
        // the generated AP
        Console.WriteLine("Harmonic Progression :");
        for (int i = 1; i <= n; i++)
            Console.Write("1/" + AP[i] + " ");
        Console.WriteLine();
        String str = "";
        str = str + sum;
        str = str.Substring(0, 4);
 
        Console.WriteLine("Sum of the generated" +
                " harmonic progression : " + str);
        sum = sumApproximation(a, d, n);
 
        str = "";
        str = str + sum;
        str = str.Substring(0, 4);
        Console.WriteLine("Sum of the generated " +
        "harmonic progression using approximation : "
                                            + str);
    }
}
 
// This code is contributed by
// ManishShaw(manishshaw1)

Javascript

 
// JavaScript code to generate Harmonic Progression
// and calculate the sum of the progression.
 
    // Function that generates the harmonic progression
    // and calculates the sum of its elements by iterating.
    function generateAP(a, d, n, AP)
    {
        let sum = 0;
        for (let i = 1; i <= n; i++) {
   
            // HP = 1/AP
            // In AP, ith term is calculated by a+(i-1)d;
            AP[i] = (a + (i - 1) * d);
   
            // Calculating the sum.
            sum += 1 / ((a + (i - 1) * d));
        }
        return sum;
    }
   
    // Function that uses riemenn sum method to calculate
    // the approximate sum of HP in O(1) time complexity
    function sumApproximation(a, d, n)
    {
   
        return Math.log((2 * a + (2 * n - 1) * d) /
                                 (2 * a - d)) / d;
    }
 
// Driver code   
          
        let a = 12, d = 12, n = 5;
        let AP = [];
           
        // Generating AP from the above data
        let sum = generateAP(a, d, n, AP);
   
        // Generating HP from the generated AP
        document.write("Harmonic Progression :" + "<br/>");
        for (let i = 1; i <= n; i++)
            document.write("1/" + AP[i] + " ");
        document.write("<br/>");
        let str = "";
        str = str + sum;
        str = str.substring(0, 4);
   
        document.write("Sum of the generated" +
                  " harmonic progression : " + str + "<br/>");
        sum = sumApproximation(a, d, n);
   
        str = "";
        str = str + sum;
        str = str.substring(0, 4);
        document.write("Sum of the generated " +
           "harmonic progression using approximation : "
                                              + str + "<br/>");
 
             

输出：

Harmonic Progression :
1/12 1/24 1/36 1/48 1/60 
Sum of the generated harmonic progression : 0.19
Sum of the generated harmonic progression using approximation :0.19