19
\$\begingroup\$

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

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 , so the shortest code in bytes wins!

Improve this question
\$\endgroup\$
7
  • \$\begingroup\$ Could you give us some testcases? \$\endgroup\$
    – user41805
    May 28, 2017 at 9:50
  • 2
    \$\begingroup\$ What precision is required? Exact output is generally only possible as a fraction, but in many languages that will have to be separate numbers for numerator and denominator. Can we output a)a float, b)a fraction or integer pair c)either? \$\endgroup\$
    – Level River St
    May 28, 2017 at 9:52
  • 2
    \$\begingroup\$ @Arjun The harmonic series grows to infinity so it will get hard to meet 10 decimal places as the number gets into the thousands and millions. I would go for significant figures rather than decimal places, and I see no need to be so precise. 5 significant figures should be enough. so 9.9999E10 rather than 99999999999.9999999999 \$\endgroup\$
    – Level River St
    May 28, 2017 at 10:17
  • \$\begingroup\$ Can we go over 5 significant figures? \$\endgroup\$
    – Erik the Outgolfer
    May 28, 2017 at 10:25
  • \$\begingroup\$ By the way, it's known that the harmonic sequence does not contain any integers other than the initial a_1 = 1. (Idea of proof that a_n is not an integer for n>1: let 2^k be the largest power of 2 not exceeding n; then 2^k divides the denominator of a_n.) \$\endgroup\$
    – Greg Martin
    May 28, 2017 at 19:53

42 Answers 42

Reset to default
1
2
9
\$\begingroup\$

Python 3, 27 bytes

h=lambda n:n and 1/n+h(n-1)
Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ 0-indexing or 1-indexing? \$\endgroup\$
    – Arjun
    May 28, 2017 at 11:29
  • 2
    \$\begingroup\$ Throws RuntimeError when handling input greater than the recursion limit, 1000 by default. \$\endgroup\$
    – sagiksp
    May 28, 2017 at 15:04
  • \$\begingroup\$ you can do sys.setrecursionlimit(473755252663) but the stack will eventually overflow quite easily \$\endgroup\$
    – cat
    May 29, 2017 at 4:31
  • \$\begingroup\$ @Arjun it's 1-indexed \$\endgroup\$
    – shooqie
    May 29, 2017 at 20:23
8
\$\begingroup\$

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))

Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ From what I've seen of other posts, you can remove f= from your answer to save 2 bytes. \$\endgroup\$
    – Rick Hitchcock
    May 28, 2017 at 10:44
  • 1
    \$\begingroup\$ @RickHitchcock I cannot remove f= because the function is recursive and it references itself in f(--a). But if this was not a recursive solution, I would have been able to do that \$\endgroup\$
    – user41805
    May 28, 2017 at 10:45
  • \$\begingroup\$ Ah, makes sense! Save one byte with f=a=>a&&1/a+f(--a). \$\endgroup\$
    – Rick Hitchcock
    May 28, 2017 at 10:49
  • \$\begingroup\$ @RickHitchcock Nice one! \$\endgroup\$
    – user41805
    May 28, 2017 at 10:52
6
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
0
6
\$\begingroup\$

Mathematica, 21 20 16 bytes

This solution is 1-indexed.

Sum[1./i,{i,#}]&
Improve this answer
\$\endgroup\$
10
  • \$\begingroup\$ It is 1-indexing \$\endgroup\$
    – ZaMoC
    May 28, 2017 at 11:31
  • 1
    \$\begingroup\$ > You must not use a built-in to calculate the partial sum of the first n elements. (Yeah, it's for you Mathematica!) \$\endgroup\$
    – MCCCS
    May 28, 2017 at 11:32
  • 4
    \$\begingroup\$ OP means I can't use HarmonicNumber[#] & \$\endgroup\$
    – ZaMoC
    May 28, 2017 at 11:35
  • 4
    \$\begingroup\$ And one can further shorten to Tr[1./Range@#]&. \$\endgroup\$
    – Greg Martin
    May 28, 2017 at 19:56
  • 2
    \$\begingroup\$ @Ian Mathematica may display 5 sig fig, but the function returns machine-precision numbers (52 binary bits or just under 16 decimal digits of precision) \$\endgroup\$
    – LLlAMnYP
    May 30, 2017 at 9:12
5
\$\begingroup\$

PHP, 33 Bytes

1-indexing 

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

Try it online!

Improve this answer
\$\endgroup\$
0
5
\$\begingroup\$

Pari/GP, 18 bytes

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

1-indexing.

Try it online!

Improve this answer
\$\endgroup\$
0
5
\$\begingroup\$

CJam, 11 bytes

1.ri,:)f/:+

Try it online!

1-indexed.

Improve this answer
\$\endgroup\$
0
5
\$\begingroup\$

Japt -x, 8 6 5 3 bytes

õpJ

With some thanks to ETHproductions

Try it online

Improve this answer
\$\endgroup\$
6
  • \$\begingroup\$ 0-indexing or 1-indexing? \$\endgroup\$
    – Arjun
    May 28, 2017 at 11:27
  • \$\begingroup\$ I think you can save a byte with õ x@1/X \$\endgroup\$
    – ETHproductions
    May 28, 2017 at 12:25
  • \$\begingroup\$ ...and another couple bytes by using XpJ instead of 1/X :-) \$\endgroup\$
    – ETHproductions
    May 28, 2017 at 12:27
  • \$\begingroup\$ Thanks, @ETHproductions :) I twigged those as soon as I walked away. \$\endgroup\$
    – Shaggy
    May 28, 2017 at 12:45
  • \$\begingroup\$ Actually I don't think you even need the _ due to auto-functions. I should really write that tip :P (I should have time today or tomorrow, due to it being Memorial Day) \$\endgroup\$
    – ETHproductions
    May 28, 2017 at 14:50
4
\$\begingroup\$

Jelly, 3 bytes

İ€S

Try it online!

1-indexed.

Explanation:

İ€S Main link, monadic
İ€         1 / each one of [1..n]
  S Sum of
Improve this answer
\$\endgroup\$
0
4
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ You can use W instead of -1. \$\endgroup\$
    – Erik the Outgolfer
    May 28, 2017 at 12:24
  • \$\begingroup\$ @EriktheOutgolfer has outgolfed himself :-) \$\endgroup\$
    – Luis Mendo
    May 28, 2017 at 13:04
  • \$\begingroup\$ @LuisMendo I like my name, it's just a name. And yes I outgolfed myself in the process of helping a fellow golfer golf even further. \$\endgroup\$
    – Erik the Outgolfer
    May 28, 2017 at 13:10
  • \$\begingroup\$ @Erik It was meant as a joke. Thanks for the help \$\endgroup\$
    – Luis Mendo
    May 28, 2017 at 13:57
3
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

R, 15 bytes

sum(1/1:scan())

Try it online!

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ Thanks @Christopher for the formatting. With that, the duplication of backslash was no longer necessary. \$\endgroup\$
    – avl42
    May 28, 2017 at 20:30
  • \$\begingroup\$ No problem! It looks better \$\endgroup\$
    – user63187
    May 28, 2017 at 21:30
3
\$\begingroup\$

05AB1E, 3 bytes

LzO

Try it online!

1-indexed.

Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

Pyth, 5 bytes

scL1S

Try it here.

1-indexed.

Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

Husk, 3 bytes

ṁ\ḣ

Try it online!

Output is a fraction.

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

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!

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ 2 bytes \$\endgroup\$
    – lyxal
    May 18, 2021 at 2:07
2
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

C, 54 bytes

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

Uses 1-indexed numbers.

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Haskell, 21 bytes

f n=sum$map(1/)[1..n]
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Brachylog, 6 bytes

⟦₁/₁ᵐ+

Try it online!

This is 1-indexed.

Explanation

⟦₁         Range [1, …, Input]
    ᵐ      Map:
  /₁         Inverse
     +     Sum
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Pyt, 3 bytes

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

Try it online!

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Scala, 47 bytes

Try it online!

def h(n:Int):Double=if(n==0)0 else 1.0/n+h(n-1)
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Thunno 2 S, 2 bytes

RỊ

Try it online!

Explanation

RỊ  # Implicit input
R   # One range
 Ị  # Reciprocal
    # Take the sum
    # Implicit output
Improve this answer
\$\endgroup\$
0
\$\begingroup\$

C (gcc), 35 bytes

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

Try it online!

Improve this answer
\$\endgroup\$
1
2

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.