Partial Sum of Harmonic Sequence!

Question

Definition

In Mathematics, Harmonic Sequence refers to a sequence where

$$a_n = \frac 1 n$$

i.e. the \$n_{th}\$ term of the sequence equals the reciprocal of \$n\$.

---

Introduction

In this challenge, given a positive integer \$n\$ as input, output the Partial Sum of first \$n\$ terms of the Harmonic Sequence.

---

Input

You'll be given a positive integer (within the range of numbers supported by your language). It can be either of Signed and Unsigned (depends on you), since the challenge requires only positive integers.

You can take the input in any way except assuming it to be present in a predefined variable. Reading from file, terminal, modal window (prompt() in JavaScript) etc. is allowed. Taking the input as function argument is allowed as well.

---

Output

Your program should output the sum of the first \$n\$ terms of the Harmonic Sequence as a float (or integer if the output is evenly divisible by 1) with precision of 5 significant figures, where \$n\$ refers to the input. To convey the same in Mathematical jargon, you need to compute

$$\sum_{i=1}^n \frac 1 i$$

where \$n\$ refers to the input.

You can output in any way except writing the output to a variable. Writing to screen, terminal, file, modal window (alert() in JavaScript) etc. is allowed. Outputting as function return value is allowed as well.

---

Additional Rules

• The input number can be either of 0-indexed or 1-indexed. You must specify that in your post.

• You must not use a built-in to calculate the partial sum of the first \$n\$ elements. (Yeah, it's for you Mathematica!)

• You must not abuse native number types to trivialize the problem.

• Standard Loopholes apply.

---

Test Cases

The Test Cases assume the input to be 1-indexed

Input     Output
1         1
2         1.5
3         1.8333
4         2.0833
5         2.2833

---

Winning Criterion

This is code-golf, so the shortest code in bytes wins!

Answer 1

Python 3, 27 bytes

h=lambda n:n and 1/n+h(n-1)

Answer 2

JavaScript, 19 18 bytes

1 byte saved thanks to @RickHitchcock

f=a=>a&&1/a+f(--a)

This is 1-indexed.

f=a=>a&&1/a+f(--a)

for(i=0;++i<10;)console.log(f(i))

Answer 3

APL (Dyalog), 5 bytes

+/÷∘⍳

Try it online!

You can add ⎕PP←{number} to the header to change the precision to {number}.

This is 1-indexed.

Explanation

+/÷∘⍳                     Right argument; n
    ⍳                     Range; 1 2 ... n
  ÷                       Reciprocal; 1/1 1/2 ... 1/n
+/                        Sum; 1/1 + 1/2 + ... + 1/n

Answer 4

Mathematica, 21 20 16 bytes

This solution is 1-indexed.

Sum[1./i,{i,#}]&

Answer 5

PHP, 33 Bytes

1-indexing

for(;$i++<$argn;)$s+=1/$i;echo$s;

Try it online!

Answer 6

Pari/GP, 18 bytes

n->sum(i=1,n,1./i)

1-indexing.

Try it online!

Answer 7

CJam, 11 bytes

1.ri,:)f/:+

Try it online!

1-indexed.

Answer 8

Japt -x, 8 6 5 3 bytes

õpJ

With some thanks to ETHproductions

Try it online

Answer 9

Jelly, 3 bytes

İ€S

Try it online!

1-indexed.

Explanation:

İ€S Main link, monadic
İ€         1 / each one of [1..n]
  S Sum of

Answer 10

CJam, 11 10 bytes

1 byte removed thanks to Erik the outgolfer

ri),{W#+}*

This uses 1-based indexing.

Try it online!

Explanation

ri            e# Read integer, n
  )           e# Increment by 1: gives n+1
   ,          e# Range: gives [0 1 2 ... n]
    {   }*    e# Fold this block over the array
     W#       e# Inverse of a number
       +      e# Add two numbers

Answer 11

Haskell, 20 bytes

f 0=0
f n=1/n+f(n-1)

Original solution, 22 bytes

f n=sum[1/k|k<-[1..n]]

These solutios assumes 1-indexed input.

Answer 12

R, 15 bytes

sum(1/1:scan())

Try it online!

Answer 13

Tcl 38 bytes

proc h x {expr $x?1./($x)+\[h $x-1]:0}

That's a very dirty hack, and the recursive calls pass literal strings like "5-1-1-1..." until it evaluates to 0.

Answer 14

05AB1E, 3 bytes

LzO

Try it online!

1-indexed.

Answer 15

Axiom, 45 34 bytes

f(x:PI):Any==sum(1./n,n=1..x)::Any

1-Indexed; It has argument one positive integer(PI) and return "Any" that the sys convert (or not convert) to the type useful for next function arg (at last it seems so seeing below examples)

(25) -> [[i,f(i)] for i in 1..9]
   (25)
   [[1,1.0], [2,1.5], [3,1.8333333333 333333333], [4,2.0833333333 333333333],
    [5,2.2833333333 333333333], [6,2.45], [7,2.5928571428 571428572],
    [8,2.7178571428 571428572], [9,2.8289682539 682539683]]
                                                      Type: List List Any
(26) -> f(3000)
   (26)  8.5837498899 591871142
                                        Type: Union(Expression Float,...)
(27) -> f(300000)
   (27)  13.1887550852 056117
                                        Type: Union(Expression Float,...)
(29) -> f(45)^2
   (29)  19.3155689383 88117644
                                                   Type: Expression Float

Answer 16

Pyth, 5 bytes

scL1S

Try it here.

1-indexed.

Answer 17

Husk, 3 bytes

ṁ\ḣ

Try it online!

Output is a fraction.

Answer 18

Vyxal, 3 bytes

ɾĖ∑

Lame answer, but range -> reciprocal -> sum -> implicit out, same as jelly

Try it Online!

Vyxal s, 2 bytes

ɾĖ

2 Bytes w/ -s from @lyxal, -s sums the stack

Try it Online!

Answer 19

MATL, 5 bytes

:l_^s

This solution uses 1-based indexing.

Try it at MATL Online

Explanation

    % Implicitly grab input (N)
:   % Create an array from [1...N]
l_^ % Raise all elements to the -1 power (take the inverse of each)
s   % Sum all values in the array and implicitly display the result

Answer 20

C, 54 bytes

i;float f(n){float s;for(i=n+1;--i;s+=1./i);return s;}

Uses 1-indexed numbers.

Answer 21

Haskell, 21 bytes

f n=sum$map(1/)[1..n]

Answer 22

Brachylog, 6 bytes

⟦₁/₁ᵐ+

Try it online!

This is 1-indexed.

Explanation

⟦₁         Range [1, …, Input]
    ᵐ      Map:
  /₁         Inverse
     +     Sum

Answer 23

QBIC, 13 bytes

[:|c=c+1/a]?c

Explanation

[ |        FOR a = 1 to
 :            the input n
   c=c+    Add to c (starts off as 0)
   1/a     the reciprocal of the loop iterator
]          NEXT
?c         PRINT c

Answer 24

Gol><>, 8 bytes

F1LP,+|B

Try it online!

Example full program & How it works

1AGIE;GN
F1LP,+|B

1AGIE;GN
1AG       Register row 1 as function G
   IE;    Take input as int, halt if EOF
      GN  Call G and print the result as number
          Repeat indefinitely

F1LP,+|B
F     |   Repeat n times...
 1LP,       Compute 1 / (loop counter + 1)
     +      Add
       B  Return

Answer 25

Rust, 36 bytes

|n|(1..=n).map(|n|1./n as f64).sum()

Try it online!

Input is an integer, if the input is <=0 the output is zero, and inputting one gets one.

Answer 26

J, 9 bytes

1#.1%1+i.

I'm only posting this because I think it looks really pretty.

Attempt This Online!

1#.1%1+i.
       i.  NB. range 0..n-1
     1+    NB. add 1
   1%      NB. 1 divided by each element
1#.        NB. sum the result

Answer 27

Pyt, 3 bytes

ř⅟Ʃ
        implicit input
ř       produces a list containing 1 to n
 ⅟      takes the reciprocals
  Ʃ     sums the list
        (implicit print)

Try it online!

Answer 28

Scala, 47 bytes

Try it online!

def h(n:Int):Double=if(n==0)0 else 1.0/n+h(n-1)

Answer 29

Thunno 2 S, 2 bytes

RỊ

Try it online!

Explanation

RỊ  # Implicit input
R   # One range
 Ị  # Reciprocal
    # Take the sum
    # Implicit output

Answer 30

C (gcc), 35 bytes

float f(n){return n?1./n+f(--n):0;}

Try it online!