Определение

В математике гармоническая последовательность относится к последовательности, в которой

т.е. n- ^й член последовательности равен обратной величине n .

Вступление

В этой задаче, учитывая положительное целое число n в качестве входных данных, выведите частичную сумму первых n членов гармонической последовательности.

вход

Вам будет дано положительное целое число (в диапазоне чисел, поддерживаемых вашим языком). Это могут быть подписанные и неподписанные (зависит от вас), поскольку для задания требуются только положительные целые числа.

Вы можете принять входные данные любым способом, кроме предположения, что они присутствуют в предопределенной переменной. Чтение из файла, терминала, модального окна ( prompt()в JavaScript) и т. Д. Разрешено. Также возможно использование ввода в качестве аргумента функции.

Выход

Ваша программа должна вывести сумму первых n слагаемых гармонической последовательности в виде числа с плавающей запятой (или целого числа, если выходные данные равномерно делятся на 1) с точностью до 5 значащих цифр, где n относится к входным данным. Чтобы передать то же самое в математическом жаргоне, вам нужно вычислить

где n относится к входу.

Вы можете выводить любым способом, кроме записи выходных данных в переменную. Запись на экран, в терминал, файл, модальное окно ( alert()в JavaScript) и т. Д. Разрешена. Вывод в виде returnзначения функции также допускается.

Дополнительные правила

• Номер ввода может быть либо 0-индексирован, либо 1-индексирован. Вы должны указать это в своем посте.

• Вы не должны использовать встроенную функцию для вычисления частичной суммы первых n элементов. (Да, это для вас Mathematica!)

• Вы не должны злоупотреблять типами собственных чисел, чтобы тривиализировать проблему .

• Стандартные лазейки применяются.

Тестовые случаи

Тестовые случаи предполагают, что вход будет 1 проиндексирован

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

Критерий победы

Это код-гольф , поэтому выигрывает самый короткий код в байтах!

Желе , 3 байта

İ€S

Попробуйте онлайн!

1-индексироваться.

Объяснение:

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

Python 3, 27 байт

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

JavaScript, 19 18 байт

1 байт сохранен благодаря @RickHitchcock

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

Это 1-индексированный.

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

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

APL (Dyalog) , 5 байтов

+/÷∘⍳

Попробуйте онлайн!

Вы можете добавить ⎕PP←{number}в заголовок, чтобы изменить точность {number}.

Это 1-индексированный.

объяснение

+/÷∘⍳                     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 байт

Это решение 1-проиндексировано.

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

PHP, 33 байта

1 индексация

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

Попробуйте онлайн!

Пари / ГП , 18 байт

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

1 индексации.

Попробуйте онлайн!

CJam , 11 байт

1.ri,:)f/:+

Попробуйте онлайн!

1-индексироваться.

Japt -x , 8 6 5 3 байта

õpJ

С некоторой благодарностью ETHproductions

Попробуйте онлайн

CJam , 11 10 байт

1 байт удален благодаря Эрику

ri),{W#+}*

При этом используется индексирование на основе 1.

Попробуйте онлайн!

объяснение

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 байтов

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

Исходное решение, 22 байта

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

Эти решения предполагают ввод с 1 индексом.

R 15 байт

sum(1/1:scan())

Попробуйте онлайн!

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!