Suma parcial de secuencia armónica!

13

Definición

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

Harmonic Sequence Equation

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

Harmonic Sequence Partial Sum of first n terms

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


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 , por lo que gana el código más corto en bytes.

Arjun
fuente
¿Podrías darnos algunos casos de prueba?
Kritixi Lithos
2
¿Qué precisión se requiere? La salida exacta generalmente solo es posible como una fracción, pero en muchos idiomas tendrá que ser números separados para numerador y denominador. ¿Podemos generar a) un flotante, b) una fracción o un par entero c)?
Level River St
2
@Arjun La serie armónica crece hasta el infinito, por lo que será difícil encontrar 10 decimales a medida que el número llegue a miles y millones. Buscaría cifras significativas en lugar de decimales, y no veo la necesidad de ser tan preciso. 5 cifras significativas deberían ser suficientes. así que en 9.9999E10lugar de99999999999.9999999999
Level River St
¿Podemos superar 5 cifras significativas?
Erik the Outgolfer
Por cierto, se sabe que la secuencia armónica no contiene ningún número entero que no sea el inicial a_1 = 1. (Idea de prueba de que a_n no es un número entero para n> 1: que 2 ^ k sea la mayor potencia de 2 que no exceda n; entonces 2 ^ k divide el denominador de a_n.)
Greg Martin

Respuestas:

4

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
Erik el Outgolfer
fuente
9

Python 3, 27 bytes

h=lambda n:n and 1/n+h(n-1)
shooqie
fuente
0-indexación o 1-indexación?
Arjun
2
Se lanza RuntimeErrorcuando se maneja una entrada mayor que el límite de recursión, 1000 por defecto.
sagiksp
puede hacerlo, sys.setrecursionlimit(473755252663)pero la pila eventualmente se desbordará con bastante facilidad
cat
@Arjun está indexado 1
shooqie
8

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

Kritixi Lithos
fuente
Por lo que he visto de otras publicaciones, puede eliminar f=de su respuesta para guardar 2 bytes.
Rick Hitchcock
1
@RickHitchcock No puedo eliminar f=porque la función es recursiva y hace referencia a sí misma f(--a). Pero si esto no fuera una solución recursiva, podría haberlo hecho
Kritixi Lithos
Ah, tiene sentido! Ahorre un byte con f=a=>a&&1/a+f(--a).
Rick Hitchcock
@RickHitchcock ¡Buena!
Kritixi Lithos
6

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
Kritixi Lithos
fuente
6

Mathematica, 21 20 16 bytes

Esta solución está 1 indexada.

Sum[1./i,{i,#}]&
J42161217
fuente
Es indexación 1
J42161217
1
> No debe utilizar una función integrada para calcular la suma parcial de los primeros n elementos. (Sí, es para ti Mathematica!)
MCCCS
44
OP significa que no puedo usar HarmonicNumber [#] &
J42161217
44
Y uno puede acortar aún más Tr[1./Range@#]&.
Greg Martin
2
@Ian Mathematica puede mostrar 5 sig fig, pero la función devuelve números de precisión de máquina (52 bits binarios o un poco menos de 16 dígitos decimales de precisión)
LLlAMnYP
5

Japt -x , 8 6 5 3 bytes

õpJ

Con algunas gracias a ETHproductions

Pruébalo en línea

Lanudo
fuente
0-indexación o 1-indexación?
Arjun
Creo que puede guardar un byte conõ x@1/X
ETHproductions
... y otro par de bytes usando en XpJlugar de 1/X:-)
ETHproductions
Gracias, @ETHproductions :) Los tomé tan pronto como me alejé.
Shaggy
En realidad, no creo que necesites el _debido a las funciones automáticas. Realmente debería escribir ese consejo: P (debería tener tiempo hoy o mañana, debido a que es el Día de los Caídos)
ETHproductions
4

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
Luis Mendo
fuente
Puedes usar en Wlugar de -1.
Erik the Outgolfer
@EriktheOutgolfer se ha superado a sí mismo :-)
Luis Mendo
@LuisMendo Me gusta mi nombre, es solo un nombre. Y sí, me superé en el proceso de ayudar a un golfista compañero aún más.
Erik the Outgolfer
@Erik Fue una broma. Gracias por la ayuda
Luis Mendo
3

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.

Ryan McCleary
fuente
3

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.

avl42
fuente
Gracias @Christopher por el formateo. Con eso, la duplicación de la barra invertida ya no era necesaria.
avl42
¡No hay problema! Se ve mejor
Christopher
2

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
Suever
fuente
2

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
RosLuP
fuente
1

C, 54 bytes

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

Uses 1-indexed numbers.

Uriel
fuente
1

Brachylog, 6 bytes

⟦₁/₁ᵐ+

Try it online!

This is 1-indexed.

Explanation

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

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
steenbergh
fuente
1

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
Bubbler
fuente
0

Haskell, 21 bytes

f n=sum$map(1/)[1..n]
Uri Goren
fuente
0

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.

Skidsdev
fuente
0

Tcl, 61 bytes

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

Try it online!

sergiol
fuente