📌  相关文章
📜  谐波级数总和

📅  最后修改于: 2021-04-29 12:56:04             🧑  作者: Mango

给定级数’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.计算此进度或序列的总和可能是一项耗时的任务。我们既可以在生成此序列时进行迭代,也可以使用一些近似值,并得出一个公式,该公式可以为我们提供精确到小数点后一位的值。下面是一个近似公式。

有关以上公式的详细信息,请参考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)


PHP


Javascript


输出:

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