Program to find the Nth Harmonic Number

Given a number N. The task is to find the Nth Harmonic Number.
Let the nth harmonic number be H_n.
The harmonic series is as follows: 
 

H₁ = 1 
H₂ = H₁ + 1/2 
H₃ = H₂ + 1/3 
H₄ = H₃ + 1/4 
. 
. 
. 
H_n = H_n-1 + 1/n 
 

Examples: 
 

Input : N = 5
Output : 2.45

Input : N = 9
Output : 2.71786

The idea is to traverse from H1 and then consecutively keep finding H2 from H1, H3 from H2 ..... and so on.
Below is the program to find N-th Harmonic Number:
 

// CPP program to find N-th Harmonic Number

#include <iostream>
using namespace std;

// Function to find N-th Harmonic Number
double nthHarmonic(int N)
{
    // H1 = 1
    float harmonic = 1.00;

    // loop to apply the formula 
    // Hn = H1 + H2 + H3 ... + Hn-1 + Hn-1 + 1/n
    for (int i = 2; i <= N; i++) {
        harmonic += (float)1 / i;
    }

    return harmonic;
}

// Driver Code
int main()
{
    int N = 8;
    
    cout<<nthHarmonic(N);
    
    return 0;
}

// Java program to find N-th Harmonic Number

import java.io.*;

class GFG {
    
// Function to find N-th Harmonic Number
static double nthHarmonic(int N)
{
    // H1 = 1
    float harmonic = 1;

    // loop to apply the formula 
    // Hn = H1 + H2 + H3 ... + Hn-1 + Hn-1 + 1/n
    for (int i = 2; i <= N; i++) {
        harmonic += (float)1 / i;
    }

    return harmonic;
}

// Driver Code

    public static void main (String[] args) {
            int N = 8;
    
    System.out.print(nthHarmonic(N));
    
    }
}
// This code is contributed 
// by ajit

# Python3 program to find 
# N-th Harmonic Number

# Function to find N-th Harmonic Number 
def nthHarmonic(N) :

    # H1 = 1 
    harmonic = 1.00

    # loop to apply the formula 
    # Hn = H1 + H2 + H3 ... + 
    # Hn-1 + Hn-1 + 1/n 
    for i in range(2, N + 1) :
        harmonic += 1 / i

    return harmonic
    
# Driver code     
if __name__ == "__main__" :

    N = 8
    print(round(nthHarmonic(N),5))

# This code is contributed by ANKITRAI1

// C# program to find N-th Harmonic Number
using System;

class GFG 
{
    
// Function to find N-th Harmonic Number
static double nthHarmonic(int N)
{
    // H1 = 1
    float harmonic = 1;

    // loop to apply the formula 
    // Hn = H1 + H2 + H3 ... + 
    // Hn-1 + Hn-1 + 1/n
    for (int i = 2; i <= N; i++)
    {
        harmonic += (float)1 / i;
    }

    return harmonic;
}

// Driver Code
static public void Main ()
{
    int N = 8;
    
    Console.Write(nthHarmonic(N));
}
}

// This code is contributed 
// by Raj

<?php
// PHP program to find 
// N-th Harmonic Number

// Function to find N-th
// Harmonic Number
function nthHarmonic($N)
{
    // H1 = 1
    $harmonic = 1.00;

    // loop to apply the formula 
    // Hn = H1 + H2 + H3 ... + 
    // Hn-1 + Hn-1 + 1/n
    for ($i = 2; $i <= $N; $i++) 
    {
        $harmonic += (float)1 / $i;
    }

    return $harmonic;
}

// Driver Code
$N = 8;
echo nthHarmonic($N);
    
// This code is contributed 
// by Shivi_Aggarwal
?>

<script>


// Javascript program to find
// N-th Harmonic Number

// Function to find N-th
// Harmonic Number
function nthHarmonic(N)
{
    // H1 = 1
    let harmonic = 1.00;

    // loop to apply the formula
    // Hn = H1 + H2 + H3 ... +
    // Hn-1 + Hn-1 + 1/n
    for (let i = 2; i <= N; i++)
    {
        harmonic += parseFloat(1) / i;
    }

    return harmonic;
}

// Driver Code

let N = 8;
document.write( nthHarmonic(N).toFixed(5));

// This code is contributed by bobby

</script>

2.71786

Time Complexity: O(N)

Auxiliary Space: O(1) as using constant space, since no extra space has been taken.

Approach 2: Dynamic Programming:

The DP approach is better than the simple iterative approach because it avoids recomputing the sum from scratch every time. In the simple iterative approach, we add each term of the harmonic series from 1 to N one by one in every iteration. This means that we perform N-1 additions in total, which can be time-consuming for large values of N.

we only need to perform N-1 additions once and store the results in the harmonic vector. Then, we can simply access the N-th Harmonic number from the vector in constant time, which is much faster than recomputing the sum from scratch every time.

#include <iostream>
#include <vector>
using namespace std;

// Function to find N-th Harmonic Number
double nthHarmonic(int N)
{
// H1 = 1
vector<double> harmonic(N+1);
harmonic[1] = 1.0;
  // loop to apply the formula
// Hn = H1 + H2 + H3 ... + Hn-1 + Hn-1 + 1/n
for (int i = 2; i <= N; i++) {
    harmonic[i] = harmonic[i-1] + (double)1 / i;
}

return harmonic[N];
}

// Driver Code
int main()
{
int N = 8;
  cout<<nthHarmonic(N);

return 0;
}

import java.util.*;

public class HarmonicNumber {
    // Function to find N-th Harmonic Number
    public static double nthHarmonic(int N) {
        // H1 = 1
        List<Double> harmonic = new ArrayList<>();
        harmonic.add(0.0);  // Add a dummy value to align with the C++ vector indexing
        harmonic.add(1.0);

        // loop to apply the formula
        // Hn = H1 + H2 + H3 ... + Hn-1 + Hn-1 + 1/n
        for (int i = 2; i <= N; i++) {
            harmonic.add(harmonic.get(i-1) + 1.0 / i);
        }

        return harmonic.get(N);
    }

    // Driver Code
    public static void main(String[] args) {
        int N = 8;
        System.out.println(nthHarmonic(N));
    }
}

def nthHarmonic(N):
    # H1 = 1
    harmonic = [0.0]*(N+1)
    harmonic[1] = 1.0

    # loop to apply the formula
    # Hn = H1 + H2 + H3 ... + Hn-1 + Hn-1 + 1/n
    for i in range(2, N+1):
        harmonic[i] = harmonic[i-1] + 1.0 / i

    return harmonic[N]

# Driver Code
N = 8
print(nthHarmonic(N))

using System;

class HarmonicNumber {
    // Function to find N-th Harmonic Number
    static double nthHarmonic(int N) {
        // H1 = 1
        double[] harmonic = new double[N+1];
        harmonic[1] = 1.0;

        // loop to apply the formula
        // Hn = H1 + H2 + H3 ... + Hn-1 + Hn-1 + 1/n
        for (int i = 2; i <= N; i++) {
            harmonic[i] = harmonic[i-1] + 1.0 / i;
        }

        return harmonic[N];
    }

    // Driver Code
    static void Main(string[] args) {
        int N = 8;
        Console.WriteLine(nthHarmonic(N));
    }
}

// Function to find N-th Harmonic Number
function nthHarmonic(N) {
    // H1 = 1
    const harmonic = new Array(N + 1);
    harmonic[1] = 1.0;
    // loop to apply the formula
    // Hn = H1 + H2 + H3 ... + Hn-1 + Hn-1 + 1/n
    for (let i = 2; i <= N; i++) {
        harmonic[i] = harmonic[i - 1] + (1 / i);
    }

    return harmonic[N];
}

// Driver Code
const N = 8;
console.log(nthHarmonic(N));

2.71786

Time Complexity: O(N)

Auxiliary Space: O(1)