Die Alternating Harmonic Series ist eine bekannte konvergente Serie.

"Klar" ist es offensichtlich, dass es zum natürlichen log von 2 konvergiert. Oder tut es?

Da die Reihe nicht absolut konvergent ist , kann ich sie durch einfaches Umstellen der Begriffe an alles heranführen, was ich will. Angenommen, ich möchte, dass die Reihe zu e konvergiert . Alles, was ich tun müsste, ist Folgendes:

Wenn Sie das Muster nicht verstanden haben, gibt es kein offensichtliches. So funktioniert das:

1. Betrachten Sie die Terme der alternierenden harmonischen Reihen als positive und negative Terme.
2. Addieren Sie gerade genug positive Begriffe, um unser Ziel zu übertreffen (e). (aka sum > target)
3. Subtrahieren Sie den nächsten negativen Term.
4. Gehen Sie zurück zu 2.

Beachten Sie, dass Sie in Schritt 2, falls vorhanden sum == target, einen weiteren positiven Term hinzufügen sollten.

Daraus können wir eine mit jeder Zahl verbundene Sequenz wie folgt definieren:

• Folgen Sie dem obigen Algorithmus
• Geben Sie für jeden positiven Term 1 aus.
• Geben Sie für jeden negativen Term 0 aus.

Nennen wir diese Sequenz das "Harmonische Bitmuster" einer Zahl. Zum Beispiel beginnt der HBP von e wie folgt:

1, 1, 1, 1, <32 times>, 0, 1, 1, <54 times>, 0, 1, 1, ...

Ihre Herausforderung:

Sie erhalten:

• ein rationales Eingabeziel im Bereich [-10, 10] (Anmerkung: sogar 10 über die harmonische Reihe nimmt viele Millionen von Begriffen zu erreichen). Dies kann eine Dezimalzahl sein (aka 1.1) oder Sie können eine rationale direkt nehmen (aka 12/100)
• ein positiver int n- Eingang, der die Anzahl der auszugebenden Terme des harmonischen Bitmusters angibt.

Es wird erwartet, dass Sie das genaue harmonische Bitmuster des Ziels mit der angegebenen Anzahl von Begriffen ausgeben . Sie können durch Leerzeichen getrennte Werte, durch Kommas getrennte Werte, keine Trennung usw. ausgeben. Nur solange das Muster von 0 und 1 gut sichtbar ist und mit gleichmäßiger Trennung von links nach rechts gelesen wird.

Testfälle

>>> 0, 1
1
>>> 0, 2
10
>>> 0, 7
1000010
>>> 1, 10
1101011011
>>> 1.01, 3
110
>>> 1.01, 24
110101101101101101101101
>>> 2.71, 32
11111111111111111111111111111111
>>> 2.71, 144
111111111111111111111111111111110111111111111111111111111111111111111111111111111111111101111111111111111111111111111111111111111111111111111111
>>> -9.8, 100
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Beachten Sie, dass da -9.8so groß ist, die erste 1Ausgabe irgendwo um den 149496620dritten Term erfolgt (der über Gleitkommazahlen berechnet wurde, sodass der Wert möglicherweise nicht genau ist).

Perl, 69 Bytes

use bigrat;$s+=.5/($s>$ARGV[$_=0]?-++$n:++$p-++$_/2),print for 1..pop

Übernimmt Eingaben als Befehlszeilenargumente.

Erklärung : bigratAktiviert Brüche überall für genaue Berechnungen. $sist die aktuelle Summe von Begriffen, $ARGV[0]ist der Zielwert pop(gleich wie $ARGV[1]) stellt die Anzahl von Begriffen dar $pund $nstellt die positive und negative Anzahl von Begriffen dar . $_ist entweder 1oder0 abhängig davon, ob ein positiver oder ein negativer Term hinzugefügt wurde.

Haskell, 92 91 90 Bytes

import Data.Ratio
f=(.h 0 1 2).take
h a p q z|a>z=0:h(a-1%q)p(q+2)z|1<2=1:h(a+1%p)(p+2)q z

Anwendungsbeispiel: f 24 1.01 -> [1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1].

hBildet das unendliche Bitmuster, indem vier Parameter mitgeführt werden: aist die aktuelle Summe. pist der Nenner des nächsten positiven Terms qfür negative Terms. zist die Zielnummer.fStartet alles und kürzt das Ergebnis auf Länge n.

Edit: @Zgarb hat ein zu speicherndes Byte gefunden. Vielen Dank!

Python 3, 128 124 Bytes

from fractions import*
F=Fraction
*c,s=2,1,0
t=F(input())
for i in'x'*int(input()):w=s<=t;s+=F(w*2-1,c[w]);c[w]+=2;print(+w)

Dies nutzt Pythons FractionKlasse.

from fractions import* 
F=Fraction
*c,s=2,1,0                # c = [2, 1]. s = 0
                          # c is my positive/negative term counter, s is the sum
t=F(input())              # input a fraction
for i in'x'*int(input()): # Do this for for the chosen number of terms, as per the spec
  w=s<=t;                 # "w" or which one do we choose? Positive or negative?
  s+=F(w*2-1,c[w]);       # w*2-1 gives 1 if w else -1. Gives 1 if we need to add, else -1
  c[w]+=2;                # Increment the coefficient we chose
  print(+w)               # Output that. The +w coerces the bool to an int.