Definición

En matemáticas, la secuencia armónica se refiere a una secuencia donde

es decir, el n ^ésimo término de la secuencia es igual a la recíproca de n .

Introducción

En este desafío, dado un entero positivo n como entrada, genera la suma parcial de los primeros n términos de la secuencia armónica.

Entrada

Se le dará un número entero positivo (dentro del rango de números admitidos por su idioma). Puede ser con o sin signo (depende de usted), ya que el desafío solo requiere enteros positivos.

Puede tomar la entrada de cualquier manera, excepto suponiendo que esté presente en una variable predefinida. prompt()Se permite la lectura desde un archivo, terminal, ventana modal ( en JavaScript), etc. Tomar la entrada como argumento de función también está permitido.

Salida

Su programa debería generar la suma de los primeros n términos de la secuencia armónica como flotante (o entero si la salida es divisible por 1) con precisión de 5 cifras significativas, donde n se refiere a la entrada. Para transmitir lo mismo en la jerga matemática, debe calcular

donde n se refiere a la entrada.

Puede generar resultados de cualquier manera, excepto escribir el resultado en una variable. Se permite escribir en la pantalla, terminal, archivo, ventana modal ( alert()en JavaScript), etc. La salida como returnvalor de función también está permitida.

Reglas Adicionales

• El número de entrada puede ser 0 indexado o 1 indexado. Debes especificar eso en tu publicación.

• No debe usar un incorporado para calcular la suma parcial de los primeros n elementos. (¡Sí, es para ti Mathematica!)

• No debe abusar de los tipos de números nativos para trivializar el problema .

• Se aplican lagunas estándar .

Casos de prueba

Los casos de prueba suponen que la entrada está indexada en 1

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

Criterio ganador

Este es el código de golf , por lo que gana el código más corto en bytes.

Jalea , 3 bytes

İ€S

Pruébalo en línea!

1 indexado.

Explicación:

İ€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 guardado gracias a @RickHitchcock

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

Esto es 1 indexado.

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

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

APL (Dyalog) , 5 bytes

+/÷∘⍳

Pruébalo en línea!

Puedes añadir ⎕PP←{number} al encabezado para cambiar la precisión a {number}.

Esto es 1 indexado.

Explicación

+/÷∘⍳                     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 solución está 1 indexada.

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

PHP, 33 bytes

1-indexación

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

Pruébalo en línea!

Pari / GP , 18 bytes

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

1-indexación.

Pruébalo en línea!

CJam , 11 bytes

1.ri,:)f/:+

Pruébalo en línea!

1 indexado.

Japt -x , 8 6 5 3 bytes

õpJ

Con algunas gracias a ETHproductions

Pruébalo en línea

CJam , 11 10 bytes

1 byte eliminado gracias a Erik el outgolfer

ri),{W#+}*

Esto usa indexación basada en 1.

Pruébalo en línea!

Explicación

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)

Solución original, 22 bytes.

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

Estas soluciones suponen una entrada indexada 1.

R , 15 bytes

sum(1/1:scan())

Pruébalo en línea!

Tcl 38 bytes

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

Ese es un truco muy sucio, y las llamadas recursivas pasan cadenas literales como "5-1-1-1 ..." hasta que se evalúa a 0.

05AB1E , 3 bytes

LzO

Pruébalo en línea!

1 indexado.

MATL, 5 bytes

:l_^s

Esta solución utiliza indexación basada en 1.

Pruébalo en MATL Online

Explicación

    % 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; Tiene un argumento un número entero positivo (PI) y devuelve "Any" que el sistema convierte (o no convierte) al tipo útil para la siguiente función arg (al final parece que sí, ver los ejemplos a continuación)

(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!