Historia

Así que tengo un libro que quiero separar de mi mesa con nada más que otros libros. Quiero saber cuántos libros necesito para lograr esto con longitudes de libros.$n$

Aquí hay una visualización que mi amigo de Wolfram dibujó para mí:

Más información sobre el tema en Wolfram y Wikipedia .

Reto

Dado un número entero de entrada , salida de cuántos libros necesarios para el libro de arriba a ser n extensión de un libro fuera de la mesa horizontal. o Encuentre el valor entero más pequeño de m para la entrada n en la siguiente desigualdad. m ∑ i = 1$n$$n$

$m$$n$

Editar: para fracciones, use al menos un punto flotante de precisión simple IEEE. _{perdón por el desafío de edición después de publicar}

_{( OEIS A014537 )}

Casos de prueba

 1          4
 2         31
 3        227
 5      12367
10  272400600

Octava , 41 40 33 bytes

1 byte guardado gracias a @Dennis

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

Pruébalo en línea!

Explicación

Esto utiliza el hecho de que los números armónicos pueden estar limitados por una función logarítmica.

Además, la >=comparación se puede reemplazar >porque los números armónicos no pueden ser enteros (¡gracias, @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)

Pruébalo en línea!

Casco , 8 bytes

V≥⁰∫m\İ0

Pruébalo en línea!

Dado que Husk usa números racionales cuando puede, esto no tiene problemas de coma flotante

Explicación

      İ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

Una función recursiva, por lo que terminará bastante temprano.

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

Pruébalo en línea

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

Pruébalo en línea!

Sin golf

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}

Pruébalo en línea!

¡Fuerza bruta!

Javascript (ES6), 34 bytes

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

Sin golf

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

Casos de prueba

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>

Jalea , 8 bytes

RİSH:ð1#

Esto es muy lento

Pruébalo en línea!

Haskell, 71 49 48 bytes

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

¡@BMO me ahorró la friolera de 22 bytes!

Julia 0.6 , 30 27 bytes

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

Pruébalo en línea!

Solo funciona n = 6, porque Julia no tiene una optimización de llamadas de cola.

-3 bytes gracias a Dennis .

TI-BASIC, 27 bytes

Solicita al usuario la entrada y muestra la salida al finalizar. Nota: ⁻¹es el token ^-1 (inverso).

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

05AB1E , 11 bytes

XµN·zODI›}N

Pruébalo en línea!

Explicación

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

Pyth , 10 bytes

f!>Qsmc1yh

Pruébalo en línea!

Extremadamente lento

Pyth , 10 bytes

fgscL1STyQ

Pruébalo en línea!

Japt , 12 bytes

La misma longitud que, pero un poco más eficiente que la opción recursiva.

@T¨(Uµ½÷X}a1

Intentalo

Explicación

@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 gracias a frownyfrog

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

Pruébalo en línea!

respuesta original

La respuesta de Luis en J:

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

Sin golf

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

Principalmente curioso por ver si se puede mejorar drásticamente ( tos millas de paginación para la )

Explicación

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

Pruébalo en línea!

PHP, 35 bytes

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

Ejecútelo usando la 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]⌉&

Pruébalo en línea!

Java 8, 49 bytes

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

Explicación:

Pruébalo en línea. (Se agota el tiempo de espera para los casos de prueba anteriores 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

La última línea es una función lambda sin nombre que toma el número de libros y devuelve el número de libros necesarios. Pruébalo en línea!

Explicación

El único tipo de datos numéricos que tiene tinylisp son los enteros, por lo que calculamos la serie armónica como una fracción haciendo un seguimiento del numerador y el denominador. En cada paso, Nes el numerador, Des el denominador y kes el índice de suma. Queremos que la nueva suma parcial sea N/D + 1/k, o (N*k + D)/(D*k). Por lo tanto, recurrimos con un nuevo numerador de N*K + D, un nuevo denominador de D*ky un nuevo índice dek+1 .

La recursión debería detenerse una vez que la suma parcial sea mayor o igual que #el número deseado de libros. En este punto, hemos ido un libro demasiado lejos, así que volvemos k-1. La condicion es 1/2 * N/D < #; multiplicando el denominador, obtenemosN < D*#*2 , que es la forma más elegante de escribirlo.

La función auxiliar recursiva _hace todos estos cálculos; la función principal es simplemente un argumento de un envoltorio que las llamadas _con los valores de partida correctos para k, Ny D.