Récit

J'ai donc un livre que je veux séparer de ma table avec rien d'autre que d'autres livres. Je veux savoir de combien de livres ai-je besoin pour y parvenir avec longueurs de livre.$n$

Voici une visualisation que mon ami de Wolfram a dessinée pour moi:

Plus d'informations sur le sujet dans Wolfram et Wikipedia .

Défi

Étant donné une entrée entière , affichez le nombre de livres nécessaires pour que le livre supérieur soit longueur de livre de la table horizontalement. ou Trouvez la plus petite valeur entière de pour l'entrée dans l'inégalité suivante. $n$$n$

$m$$n$

Edit: pour les fractions, utilisez au moins un point flottant simple précision IEEE. _{désolé pour l'édition du défi après la publication}

_{( OEIS A014537 )}

Cas de test

 1          4
 2         31
 3        227
 5      12367
10  272400600

Octave , 41 40 33 octets

1 octet enregistré grâce à @Dennis

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

Essayez-le en ligne!

Explication

Cela utilise le fait que les nombres harmoniques peuvent être limités par une fonction logarithmique.

De plus, la >=comparaison peut être remplacée par >car les nombres harmoniques ne peuvent pas être des entiers pairs (merci, @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 octets

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

Essayez-le en ligne!

Husk , 8 octets

V≥⁰∫m\İ0

Essayez-le en ligne!

Étant donné que Husk utilise des nombres rationnels quand cela est possible, cela ne présente aucun problème de virgule flottante

Explication

      İ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 octets

Une fonction récursive donc ça va se casser assez tôt.

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

Essayez-le en ligne

Haskell, 38 octets

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

Swift , 65 octets

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

Essayez-le en ligne!

Non 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 octets

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

Essayez-le en ligne!

Force brute!

Javascript (ES6), 34 octets

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

Non golfé

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

Cas de test

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>

Gelée , 8 octets

RİSH:ð1#

C'est très lent.

Essayez-le en ligne!

Haskell, 71 49 48 octets

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

@BMO m'a sauvé un énorme 22 octets!

Julia 0,6 , 30 27 octets

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

Essayez-le en ligne!

Fonctionne uniquement jusqu'à n = 6, car Julia n'a pas d'optimisation d'appel de queue.

-3 octets grâce à Dennis .

TI-BASIC, 27 octets

Invite l'utilisateur à entrer et affiche la sortie à la fin. Remarque: ⁻¹est le jeton ^-1 (inverse).

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

05AB1E , 11 octets

XµN·zODI›}N

Essayez-le en ligne!

Explication

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 octets

f!>Qsmc1yh

Essayez-le en ligne!

Extrêmement lent.

Pyth , 10 octets

fgscL1STyQ

Essayez-le en ligne!

Japt , 12 octets

La même longueur que l'option récursive, mais légèrement plus efficace.

@T¨(Uµ½÷X}a1

Essayez-le

Explication

@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 octets

-6 octets grâce à frownyfrog

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

Essayez-le en ligne!

réponse originale

Réponse de Luis en J:

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

Non golfé

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

Généralement curieux de voir s'il peut être considérablement amélioré ( miles de recherche de toux )

Explication

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

Essayez-le en ligne!

PHP, 35 octets

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

Exécutez-le à l'aide de la CLI:

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

Wolfram Language (Mathematica) , 40 octets

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

Essayez-le en ligne!

Java 8, 49 octets

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

Explication:

Essayez-le en ligne. (Délai d'attente pour les cas de test ci-dessus 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 octets

(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 dernière ligne est une fonction lambda sans nom qui prend le nombre de longueurs de livre et renvoie le nombre de livres nécessaires. Essayez-le en ligne!

Explication

Le seul type de données numériques que possède tinylisp est les entiers, nous calculons donc la série harmonique sous forme de fraction en gardant une trace du numérateur et du dénominateur. À chaque étape, Nest le numérateur, Dle dénominateur et kl'indice de somme. Nous voulons que la nouvelle somme partielle soit N/D + 1/k, ou (N*k + D)/(D*k). Ainsi, nous récursions avec un nouveau numérateur de N*K + D, un nouveau dénominateur de D*ket un nouvel indice de k+1.

La récursivité doit s'arrêter une fois que la somme partielle est supérieure ou égale au #nombre de longueurs de livre souhaité. À ce stade, nous sommes allés un livre trop loin, alors nous revenons k-1. La condition est 1/2 * N/D < #; multipliant le dénominateur, nous obtenons N < D*#*2, qui est la façon la plus golfique de l'écrire.

La fonction d'aide récursive _effectue tous ces calculs; la fonction principale est simplement une enveloppe d' un argument selon lequel les appels _avec les valeurs de départ pour corriger k, NetD .