Definição

Em Matemática, Sequência Harmônica se refere a uma sequência em que

ou seja, o n ^° termo da sequência iguala o recíproco de n .

Introdução

Nesse desafio, dado um número inteiro positivo n como entrada, produza a soma parcial dos primeiros n termos da sequência harmônica.

Entrada

Você receberá um número inteiro positivo (dentro do intervalo de números suportados pelo seu idioma). Pode ser assinado e não assinado (depende de você), pois o desafio requer apenas números inteiros positivos.

Você pode receber a entrada de qualquer maneira, exceto assumindo que ela esteja presente em uma variável predefinida. A leitura do arquivo, terminal, janela modal ( prompt()em JavaScript) etc. é permitida. Tomando a entrada como argumento de função também é permitido.

Resultado

Seu programa deve gerar a soma dos primeiros n termos da Sequência Harmônica como float (ou inteiro se a saída for igualmente divisível por 1) com precisão de 5 algarismos significativos, em que n se refere à entrada. Para transmitir o mesmo no jargão matemático, você precisa calcular

onde n se refere à entrada.

Você pode produzir de qualquer maneira, exceto gravar a saída em uma variável. alert()É permitido escrever na tela, terminal, arquivo, janela modal ( em JavaScript) etc. A saída como returnvalor da função também é permitida.

Regras adicionais

• O número de entrada pode ser indexado em 0 ou 1. Você deve especificar isso em sua postagem.

• Você não deve usar um built-in para calcular a soma parcial dos primeiros n elementos. (Sim, é para você Mathematica!)

• Você não deve abusar dos tipos de números nativos para banalizar o problema .

• Aplicam-se brechas padrão .

Casos de teste

Os Casos de Teste supõem que a entrada seja 1 indexada

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

Critério vencedor

Isso é código-golfe , então o código mais curto em bytes vence!

Geléia , 3 bytes

İ€S

Experimente online!

1 indexado.

Explicação:

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

Python 3, 27 bytes

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

JavaScript, 19 18 bytes

1 byte salvo graças a @RickHitchcock

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

Isso é indexado em 1.

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

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

APL (Dyalog) , 5 bytes

+/÷∘⍳

Experimente online!

Você pode adicionar ⎕PP←{number}ao cabeçalho para alterar a precisão para{number} .

Isso é indexado em 1.

Explicação

+/÷∘⍳                     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 bytes

Esta solução é 1 indexada.

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

PHP, 33 bytes

Indexação 1

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

Experimente online!

Pari / GP , 18 bytes

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

Indexação 1.

Experimente online!

CJam , 11 bytes

1.ri,:)f/:+

Experimente online!

1 indexado.

Japonês -x , 8 6 5 3 bytes

õpJ

Com alguns agradecimentos à ETHproductions

Experimente online

CJam , 11 10 bytes

1 byte removido graças a Erik, o agente externo

ri),{W#+}*

Isso usa indexação baseada em 1.

Experimente online!

Explicação

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)

Solução original, 22 bytes

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

Esses solutos assumem entrada indexada em 1.

R , 15 bytes

sum(1/1:scan())

Experimente online!

Tcl 38 bytes

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

Esse é um hack muito sujo, e as chamadas recursivas passam cadeias literais como "5-1-1-1 ..." até que sejam avaliadas como 0.

05AB1E , 3 bytes

LzO

Experimente online!

1 indexado.

MATL, 5 bytes

:l_^s

Esta solução usa indexação baseada em 1.

Experimente no MATL Online

Explicação

    % 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

Axioma, 45 34 bytes

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

1-indexado; Ele possui o argumento um número inteiro positivo (PI) e retorna "Qualquer" que o sys converta (ou não converta) para o tipo útil para a próxima função arg (finalmente parece ver os exemplos abaixo)

(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

Pitão, 5 bytes

scL1S

Experimente aqui.

1 indexado.

C, 54 bytes

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

Usa números indexados em 1.

Braquilog , 6 bytes

⟦₁/₁ᵐ+

Experimente online!

Isso é indexado em 1.

Explicação

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

QBIC , 13 bytes

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

Explicação

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

Experimente online!

Exemplo de programa completo e como funciona

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;}

Experimente online!

Braingolf, 20 bytes [não concorrente]

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

Na verdade, isso não funcionará devido à incapacidade do braingolf de trabalhar com carros alegóricos, no entanto, a lógica está correta.

Explicação:

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

Aqui está um intérprete modificado que suporta flutuadores. O primeiro argumento é entrada.

Tcl, 61 bytes

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

Experimente online!