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

Sequência harmônica Soma parcial dos primeiros n termos

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!

code-golf math sequence

— Arjun
fonte

Você poderia nos dar alguns casos de teste?

— Kritixi Lithos

2

Que precisão é necessária? Geralmente, a saída exata é possível apenas como uma fração, mas em muitos idiomas que precisam ser números separados para numerador e denominador. Podemos produzir a) um float, b) uma fração ou um número inteiro c) também?

— Nível River St

2

@Arjun A série harmônica cresce até o infinito, tornando difícil encontrar 10 casas decimais à medida que o número chega aos milhares e milhões. Eu usaria números significativos em vez de casas decimais, e não vejo necessidade de ser tão preciso. 5 números significativos devem ser suficientes. então, em 9.9999E10vez de99999999999.9999999999

— Level River St

Podemos ultrapassar 5 números significativos?

— Erik the Outgolfer

A propósito, sabe-se que a sequência harmônica não contém nenhum número inteiro além do inicial a_1 = 1. (Idéia de prova de que a_n não é um número inteiro para n> 1: seja 2 ^ k a maior potência de 2 que não exceda n; então 2 ^ k divide o denominador de a_n.)

— Greg Martin

4

Geléia , 3 bytes

İ€S

Experimente online!

1 indexado.

Explicação:

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

— Erik, o Outgolfer
fonte

9

Python 3, 27 bytes

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

— shooqie
fonte

Indexação 0 ou indexação 1?

— Arjun 28/05

2

Lança RuntimeErrorao manipular a entrada maior que o limite de recursão, 1000 por padrão.

— sagiksp

você pode fazer, sys.setrecursionlimit(473755252663)mas a pilha acabará transbordando facilmente

— cat

@Arjun é 1-indexado

— shooqie

8

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

Expandir snippet

— Kritixi Lithos
fonte

Pelo que vi de outras postagens, você pode remover f=da sua resposta para economizar 2 bytes.

— Rick Hitchcock

1

@RickHitchcock Não consigo remover f=porque a função é recursiva e se refere a ela f(--a). Mas se isso não era uma solução recursiva, eu teria sido capaz de fazer isso

— Kritixi Lithos

Ah, faz sentido! Salve um byte com f=a=>a&&1/a+f(--a).

— Rick Hitchcock

@RickHitchcock Nice one!

— Kritixi Lithos

6

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

— Kritixi Lithos
fonte

6

Mathematica, 21 20 16 bytes

Esta solução é 1 indexada.

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

— J42161217
fonte

É uma indexação

— J42161217

1

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

— MCCCS

4

OP significa que não posso usar HarmonicNumber [#] &

— J42161217

4

E pode-se reduzir ainda mais Tr[1./Range@#]&.

— Greg Martin

2

@Ian Mathematica pode exibir 5 sig fig, mas a função retorna números máquina de precisão (52 bits binários ou um pouco menos de 16 dígitos decimais de precisão)

— LLlAMnYP

5

PHP, 33 bytes

Indexação 1

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

Experimente online!

— Jörg Hülsermann
fonte

5

Pari / GP , 18 bytes

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

Indexação 1.

Experimente online!

— alefalpha
fonte

5

CJam , 11 bytes

1.ri,:)f/:+

Experimente online!

1 indexado.

— Erik, o Outgolfer
fonte

5

Japonês `-x` , 8 6 5 3 bytes

õpJ

Com alguns agradecimentos à ETHproductions

Experimente online

— Shaggy
fonte

Indexação 0 ou indexação 1?

— Arjun 28/05

Eu acho que você pode salvar um byte comõ x@1/X

— ETHproductions

... e outro casal bytes usando XpJem vez de 1/X:-)

— ETHproductions

Obrigado, @ETHproductions :) Eu girei esses assim que me afastei.

— Shaggy

Na verdade, acho que você nem precisa das _funções automáticas. Eu realmente deveria escrever essa dica: P (I deve ter tempo hoje ou amanhã, devido a ser Memorial Day)

— ETHproductions

4

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

— Luis Mendo
fonte

Você pode usar em Wvez de -1.

— Erik the Outgolfer

@EriktheOutgolfer tem outgolfed si mesmo :-)

— Luis Mendo

@LuisMendo Eu gosto do meu nome, é apenas um nome. E sim, eu me superei no processo de ajudar ainda mais um jogador de golfe.

— Erik the Outgolfer

@ Erik Era para ser uma piada. Obrigado pela ajuda.

— Luis Mendo

3

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.

— Ryan McCleary
fonte

3

R , 15 bytes

sum(1/1:scan())

Experimente online!

— Nitrodon
fonte

3

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.

— avl42
fonte

Obrigado @Christopher pela formatação. Com isso, a duplicação da barra invertida não era mais necessária.

— avl42 28/05

Sem problemas! Parece melhor

— Christopher

3

05AB1E , 3 bytes

LzO

Experimente online!

1 indexado.

— Erik, o Outgolfer
fonte

2

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

— Suever
fonte

2

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

— RosLuP
fonte

2

Pitão, 5 bytes

scL1S

Experimente aqui.

1 indexado.

— Erik, o Outgolfer
fonte

1

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.

— Uriel
fonte

1

Braquilog , 6 bytes

⟦₁/₁ᵐ+

Experimente online!

Isso é indexado em 1.

Explicação

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

— Fatalizar
fonte

1

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

— steenbergh
fonte

1

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

— Bubbler
fonte

0

Haskell, 21 bytes

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

— Uri Goren
fonte

0

C (gcc) , 35 bytes

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

Experimente online!

— Giacomo Garabello
fonte

0

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.

— Skidsdev
fonte

0

Tcl, 61 bytes

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

Experimente online!

— sergiol
fonte

Soma parcial da sequência harmônica!

Definição

Introdução

Entrada

Resultado

Regras adicionais

Casos de teste

Critério vencedor

Geléia , 3 bytes

Python 3, 27 bytes

JavaScript, 19 18 bytes

APL (Dyalog) , 5 bytes

Explicação

Mathematica, 21 20 16 bytes

PHP, 33 bytes

Pari / GP , 18 bytes

CJam , 11 bytes

Japonês -x , 8 6 5 3 bytes

CJam , 11 10 bytes

Explicação

Haskell, 20 bytes

Solução original, 22 bytes

R , 15 bytes

Tcl 38 bytes

05AB1E , 3 bytes

MATL, 5 bytes

Axioma, 45 34 bytes

Pitão, 5 bytes

C, 54 bytes

Braquilog , 6 bytes

Explicação

QBIC , 13 bytes

Gol> <> , 8 bytes

Exemplo de programa completo e como funciona

Haskell, 21 bytes

C (gcc) , 35 bytes

Braingolf, 20 bytes [não concorrente]

Explicação:

Tcl, 61 bytes

Japonês `-x` , 8 6 5 3 bytes