História

Então, eu tenho um livro que quero separar da minha mesa com nada além de outros livros. Quero saber quantos livros eu preciso para conseguir isso com um comprimento de livros.$n$

Aqui está uma visualização que meu amigo da Wolfram desenhou para mim:

Mais informações sobre o tópico em Wolfram e Wikipedia .

Desafio

Dada uma entrada inteira , imprima quantos livros são necessários para que o livro superior fique com comprimento de livro da tabela horizontalmente. ou Encontre o menor valor inteiro de para a entrada na seguinte desigualdade. $n$$n$

n m ∑ i = 1$m$$n$

Editar: para frações, use pelo menos um ponto flutuante de precisão única IEEE. _{desculpe pelo desafio de edição após a postagem}

_{( OEIS A014537 )}

Casos de teste

 1          4
 2         31
 3        227
 5      12367
10  272400600

Oitava , 41 40 33 bytes

1 byte salvo graças a @Dennis

@(n)find(cumsum(.5./(1:9^n))>n,1)

Experimente online!

Explicação

Isso usa o fato de que os números harmônicos podem ser delimitados por uma função logarítmica.

Além disso, a >=comparação pode ser substituída por, >porque os números harmônicos não podem ser inteiros (obrigado, @Dennis!).

@(n)                                   % Anonymous function of n
                     1:9^n             % Range [1 2 ... 9^n]
                .5./(     )            % Divide .5 by each entry
         cumsum(           )           % Cumulative sum
                            >n         % Is each entry greater than n?
    find(                     ,1)      % Index of first true entry

Python 3 , 35 bytes

f=lambda n,k=2:n>0and-~f(n-1/k,k+2)

Experimente online!

Casca , 8 bytes

V≥⁰∫m\İ0

Experimente online!

Como Husk usa números racionais quando pode, isso não tem problemas de ponto flutuante

Explicação

      İ0    The infinite list of positive even numbers
    m\      Reciprocate each
   ∫        Get the cumulative sum
V           Find the index of the first element
 ≥⁰         that is greater than or equal to the input

JavaScript, 30 bytes

Uma função recursiva, para que ela surja muito cedo.

f=(n,x=0)=>n>0?f(n-.5/++x,x):x

Experimente online

Haskell, 38 bytes

k!n|n<=0=0|x<-n-1/(2*k)=1+(k+1)!x
(1!)

Rápido , 65 bytes

func f(n:Double){var i=0.0,s=i;while s<n{i+=1;s+=0.5/i};print(i)}

Experimente online!

Ungolfed

func f(n:Double) {
  var i = 0.0, s = 0.0
  while s < n {
    i += 1;
    s += 0.5 / i
  }
  print(i)
}

R , 39 bytes

function(n){while((F=F+.5/T)<n)T=T+1;T}

Experimente online!

Força Bruta!

Javascript (ES6), 34 bytes

n=>eval("for(i=0;n>0;n-=.5/i)++i")

Ungolfed

n => {
    for(i = 0; n > 0; ++i)
        n -= .5 / i
    return i;
}

Casos de teste

f=n=>eval("for(i=0;n>0;n-=.5/i)++i")

<button onclick="console.log(f(1))">Run for n = 1</button>
<button onclick="console.log(f(2))">Run for n = 2</button>
<button onclick="console.log(f(3))">Run for n = 3</button>
<button onclick="console.log(f(5))">Run for n = 5</button>
<button onclick="console.log(f(10))">Run for n = 10</button>

Gelatina , 8 bytes

RİSH:ð1#

Isso é muito lento.

Experimente online!

Haskell, 71 49 48 bytes

f x=length.fst.span(<x).scanl(+)0$(0.5/)<$>[1..]

A @BMO me salvou 22 bytes!

Julia 0.6 , 30 27 bytes

<(n,i=1)=n>0?n-.5/i<i+1:i-1

Experimente online!

Só funciona n = 6, porque Julia não tem otimização de chamada de cauda.

-3 bytes graças a Dennis .

TI-BASIC, 27 bytes

Solicita entrada ao usuário e exibe a saída na finalização. Nota: ⁻¹é o token ^-1 (inverso).

Input N
1
Repeat 2N≤Σ(I⁻¹,I,1,Ans
Ans+1
End
Ans

05AB1E , 11 bytes

XµN·zODI›}N

Experimente online!

Explicação

Xµ       }    # loop until counter is 1
  N·z         # push 1/(2*N)
     O        # sum the stack
      DI›     # break if the sum is greater than the input
          N   # push N

Pitão , 10 bytes

f!>Qsmc1yh

Experimente online!

Extremamente lento.

Pitão , 10 bytes

fgscL1STyQ

Experimente online!

Japonês , 12 bytes

O mesmo comprimento, mas um pouco mais eficiente que, a opção recursiva.

@T¨(Uµ½÷X}a1

Tente

Explicação

@T¨(Uµ½÷X}a1
                 :Implicit input of integer U
@        }a1     :Return the first number X >=1 that returns truthy when passed through the following function
 T               :Zero
  ¨              :Greater than or equal to
    Uµ           :Decrement U by...
      ½÷X        :0.5 divided by X

J, 22 bytes

-6 bytes graças ao frownyfrog

I.~0+/\@,1%2*1+[:i.9&^

Experimente online!

resposta original

A resposta de Luis em J:

1+]i.~[:<.[:+/\1%2*1+[:i.9&^

Ungolfed

1 + ] i.~ [: <. [: +/\ 1 % 2 * 1 + [: i. 9&^

Principalmente curioso para ver se ele pode ser melhorado drasticamente ( tosse paging miles)

Explicação

1 +      NB. 1 plus... 
] i.~    NB. find the index of the arg in...
[: <.    NB. the floor of...
[: +/\   NB. the sumscan of...
1 %      NB. the reciprical of...
2 *      NB. two times...
1 +      NB. 1 plus...
[: i.    NB.  the integers up to 
9&^      NB. 9 raised to the power of the arg

Experimente online!

PHP, 35 bytes

while($argv[1]>$s+=.5/++$i);echo$i;

Execute-o usando a CLI:

$ php -d error_reporting=0 -r 'while($argv[1]>$s+=.5/++$i);echo$i;' 5

Wolfram Language (Mathematica) , 40 bytes

⌈x/.NSolve[HarmonicNumber@x==2#,x]⌉&

Experimente online!

Java 8, 49 bytes

n->{float r=0,s=0;for(;s<n;)s+=.5f/++r;return r;}

Explicação:

Experimente online. (Tempo limite para os casos de teste acima n=7.)

n->{             // Method with integer parameter and float return-type
  float r=0,     //  Result-float, starting at 0
        s=0;     //  Sum-float, starting at 0
  for(;s<n;)     //  Loop as long as the sum is smaller than the input
    s+=.5f/++r;  //   Increase the sum by `0.5/(r+1)`,
                 //   by first increasing `r` by 1 with `r++`
  return r;}     //  Return the result-float

tinylisp , 98 bytes

(load library
(d _(q((k # N D)(i(l N(* D # 2))(_(inc k)#(+(* N k)D)(* D k))(dec k
(q((#)(_ 1 # 0 1

A última linha é uma função lambda sem nome que pega o número de comprimentos de livros e retorna o número de livros necessários. Experimente online!

Explicação

O único tipo de dado numérico tinylisp é o número inteiro; portanto, calculamos a série harmônica como uma fração, acompanhando o numerador e o denominador. Em cada etapa, Né o numerador, Dé o denominador e ké o índice da soma. Queremos que a nova soma parcial seja N/D + 1/k, ou (N*k + D)/(D*k). Assim, recorremos a um novo numerador de N*K + D, um novo denominador de D*ke um novo índice de k+1.

A recursão deve parar quando a soma parcial for maior ou igual ao #número desejado de comprimentos de livros. Neste ponto, já fomos longe demais em um livro, então voltamos k-1. A condição é 1/2 * N/D < #; multiplicando o denominador, obtemos N < D*#*2, que é a maneira mais divertida de escrevê-lo.

A função auxiliar recursiva _faz todos esses cálculos; a principal função é apenas um de um argumento invólucro que as chamadas _com os valores iniciais corretos para k, N, e D.