Définition

En mathématiques, la séquence harmonique fait référence à une séquence où

c'est-à-dire que le n ^ème terme de la séquence est égal à l'inverse de n .

introduction

Dans ce défi, étant donné un entier positif n en entrée, sortez la somme partielle des n premiers termes de la séquence harmonique.

Contribution

Vous recevrez un entier positif (dans la plage de nombres pris en charge par votre langue). Il peut s'agir de Signé et de Non signé (dépend de vous), car le défi ne nécessite que des entiers positifs.

Vous pouvez prendre l'entrée de n'importe quelle manière, sauf en supposant qu'elle soit présente dans une variable prédéfinie. La lecture à partir d'un fichier, d'un terminal, d'une fenêtre modale ( prompt()en JavaScript), etc. est autorisée. Prendre l'entrée comme argument de fonction est également autorisé.

Production

Votre programme doit sortir la somme des n premiers termes de la séquence harmonique sous forme de flottant (ou entier si la sortie est divisible par 1) avec une précision de 5 chiffres significatifs, où n se réfère à l'entrée. Pour transmettre la même chose dans le jargon mathématique, vous devez calculer

où n fait référence à l'entrée.

Vous pouvez sortir de n'importe quelle manière, sauf écrire la sortie dans une variable. L'écriture sur écran, terminal, fichier, fenêtre modale ( alert()en JavaScript), etc. est autorisée. La sortie en tant que returnvaleur de fonction est également autorisée.

Règles supplémentaires

• Le numéro d'entrée peut être indexé 0 ou indexé 1. Vous devez le préciser dans votre message.

• Vous ne devez pas utiliser de fonction intégrée pour calculer la somme partielle des n premiers éléments. (Ouais, c'est pour toi Mathematica!)

• Vous ne devez pas abuser des types de numéros natifs pour banaliser le problème .

• Les échappatoires standard s'appliquent.

Cas de test

Les cas de test supposent que l'entrée est indexée 1

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

Critère gagnant

Il s'agit de code-golf , donc le code le plus court en octets gagne!

Gelée , 3 octets

İ€S

Essayez-le en ligne!

1 indexé.

Explication:

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

Python 3, 27 octets

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

JavaScript, 19 18 octets

1 octet enregistré grâce à @RickHitchcock

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

Ceci est indexé 1.

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

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

APL (Dyalog) , 5 octets

+/÷∘⍳

Essayez-le en ligne!

Vous pouvez ajouter ⎕PP←{number}à l'en-tête pour changer la précision en {number}.

Ceci est indexé 1.

Explication

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

Mathematica, 21 20 16 octets

Cette solution est indexée 1.

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

PHP, 33 octets

1-indexation

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

Essayez-le en ligne!

Pari / GP , 18 octets

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

1-indexation.

Essayez-le en ligne!

CJam , 11 octets

1.ri,:)f/:+

Essayez-le en ligne!

1 indexé.

Japt -x , 8 6 5 3 octets

õpJ

Merci à ETHproductions

Essayez-le en ligne

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

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.

R, 15 bytes

sum(1/1:scan())

Try it online!

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.

05AB1E, 3 bytes

LzO

Try it online!

1-indexed.

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

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

Pyth, 5 bytes

scL1S

Try it here.

1-indexed.

C, 54 bytes

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

Uses 1-indexed numbers.

Brachylog, 6 bytes

⟦₁/₁ᵐ+

Try it online!

This is 1-indexed.

Explanation

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

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

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

Haskell, 21 bytes

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

C (gcc), 35 bytes

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

Try it online!

Braingolf, 20 bytes [non-competing]

VR1-1[1,!/M,$_1+]v&+

This won't actually work due to braingolf's inability to work with floats, however the logic is correct.

Explanation:

VR1-1[1,!/M,$_1+]v&+   Implicit input
VR                     Create new stack and return to main stack
  1-                   Decrement input
    1                  Push 1
     [..........]      Loop, always runs once, then decrements first item on stack at ]
                       Breaks out of loop if first item on stack reaches 0
      1,!/             Push 1, swap last 2 values, and divide without popping
                       Original values are kept on stack, and result of division is pushed
          M,$_         Move result of division to next stack, then swap last 2 items and
                       Silently pop last item (1)
              1+       Increment last item on stack
                 v&+   Move to next stack, sum entire stack 
                       Implicit output of last item on current stack

Here's a modified interpreter that supports floats. First argument is input.

Tcl, 61 bytes

proc h {x s\ 0} {time {set s [expr $s+1./[incr i]]} $x;set s}

Try it online!