Geschichte

Ich habe also ein Buch, das ich mit nichts als anderen Büchern von meinem Tisch trennen möchte. Ich möchte wissen, wie viele Bücher ich brauche, um dies mit Buchlängen zu erreichen .$n$

Hier ist eine Visualisierung, die mein Freund bei Wolfram für mich gezeichnet hat:

Weitere Informationen zum Thema in Wolfram und Wikipedia .

Herausforderung

Geben Sie bei einer Ganzzahleingabe , wie viele Bücher erforderlich sind, damit das oberste Buch Buchlänge horizontal von der Tabelle entfernt ist. oder Suchen Sie den kleinsten ganzzahligen Wert von für die Eingabe von mit der folgenden Ungleichung. $n$$n$

$m$$n$

Bearbeiten: Verwenden Sie für Brüche mindestens einen IEEE-Gleitkommawert mit einfacher Genauigkeit. _{Entschuldigung für die Bearbeitungsaufforderung nach dem Posten}

_{( OEIS A014537 )}

Testfälle

 1          4
 2         31
 3        227
 5      12367
10  272400600

Oktave , 41 40 33 Bytes

Dank @Dennis 1 Byte gespart

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

Probieren Sie es online!

Erläuterung

Dies nutzt die Tatsache, dass Oberwellenzahlen durch eine logarithmische Funktion niedriger begrenzt werden können.

Der >=Vergleich kann auch durch ersetzt werden, >da harmonische Zahlen keine ganzen Zahlen sein können (danke, @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)

Probieren Sie es online!

Schale , 8 Bytes

V≥⁰∫m\İ0

Probieren Sie es online!

Da Husk nach Möglichkeit rationale Zahlen verwendet, gibt es keine Fließkomma-Probleme

Erläuterung

      İ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

Eine rekursive Funktion, die ziemlich früh ausfällt.

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

Probieren Sie es online aus

Haskell, 38 Bytes

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

Schnell , 65 Bytes

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

Probieren Sie es 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}

Probieren Sie es online!

Rohe Gewalt!

Javascript (ES6), 34 Byte

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

Ungolfed

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

Testfälle

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>

Gelee , 8 Bytes

RİSH:ð1#

Das ist sehr langsam.

Probieren Sie es online!

Haskell, 71 49 48 Bytes

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

@BMO hat mir satte 22 Bytes erspart!

Julia 0,6 , 30 27 Bytes

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

Probieren Sie es online!

Funktioniert nur bis zu n = 6, da Julia keine Tail Call Optimierung hat.

-3 Bytes dank Dennis .

TI-BASIC, 27 Bytes

Fordert den Benutzer zur Eingabe auf und zeigt die Ausgabe beim Beenden an. Hinweis: ^Ist⁻¹ das ^-1 (inverse) Token.

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

05AB1E , 11 Bytes

XµN·zODI›}N

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Extrem langsam.

Pyth , 10 Bytes

fgscL1STyQ

Probieren Sie es online!

Japt , 12 Bytes

Die gleiche Länge, aber etwas effizienter als die rekursive Option.

@T¨(Uµ½÷X}a1

Versuch es

Erläuterung

@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 dank frownyfrog

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

Probieren Sie es online!

ursprüngliche Antwort

Luis Antwort in J:

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

Ungolfed

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

Meist neugierig, ob es drastisch verbessert werden kann ( Husten Paging Meilen)

Erläuterung

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

Probieren Sie es online!

PHP, 35 Bytes

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

Führen Sie es mit der CLI aus:

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

Wolfram Language (Mathematica) , 40 Byte

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

Probieren Sie es online!

Java 8, 49 Bytes

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

Erläuterung:

Probieren Sie es online aus. (Zeitüberschreitung für oben genannte Testfälle 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

Die letzte Zeile ist eine unbenannte Lambda-Funktion, die die Anzahl der Buchlängen und die Anzahl der benötigten Bücher zurückgibt. Probieren Sie es online!

Erläuterung

Der einzige numerische Datentyp, den tinylisp hat, sind Ganzzahlen. Daher berechnen wir die harmonische Reihe als Bruch, indem wir Zähler und Nenner verfolgen. Bei jedem SchrittN der Zähler, Dist der Nenner und kist der Summenindex. Wir wollen, dass die neue Teilsumme N/D + 1/koder ist (N*k + D)/(D*k). Wir rekursieren also mit einem neuen Zähler von N*K + D, einem neuen Nenner von D*kund einem neuen Index von k+1.

Die Rekursion sollte anhalten, sobald die Teilsumme größer oder gleich #der gewünschten Anzahl von Buchlängen ist. Zu diesem Zeitpunkt sind wir ein Buch zu weit gegangen und kehren zurück k-1. Die Bedingung ist 1/2 * N/D < #; N < D*#*2Wenn wir den Nenner multiplizieren, erhalten wir , was die golferischste Art ist, ihn zu schreiben.

Die rekursive Hilfsfunktion _führt alle diese Berechnungen durch. Die Hauptfunktion ist lediglich ein einargumentigen wrapper dass Anrufe _mit den richtigen Startwerten für k,N , und D.