Seria Alternating Harmonic to dobrze znana seria konwergentna.

„Oczywiście”, oczywiste jest, że zbiega się on z logarytmem naturalnym 2. Czy to prawda?

Ponieważ seria nie jest absolutnie zbieżna , po prostu zmieniając warunki, mogę sprawić, że zbliży się do wszystkiego, co chcę. Załóżmy, że chcę, aby seria była zbieżna do e . Wszystko, co musiałbym zrobić, to:

Jeśli nie złapałeś wzoru, nie ma oczywistego. Oto jak to działa:

1. Rozważ warunki przemiennego szeregu harmonicznych w kategoriach dodatnich i ujemnych.
2. Dodaj razem tylko tyle pozytywnych warunków, aby przekroczyć nasz cel (e). (aka sum > target)
3. Odejmij następny ujemny termin.
4. Wróć do 2.

Pamiętaj, że w kroku 2, jeśli my sum == target, powinieneś dodać kolejny pozytywny termin.

Na tej podstawie możemy zdefiniować sekwencję związaną z każdą liczbą w następujący sposób:

• Postępuj zgodnie z powyższym algorytmem
• Dla każdego pozytywnego składnika wynik 1.
• Dla każdego ujemnego warunku wyjście 0.

Nazwijmy tę sekwencję „harmonicznym wzorem bitowym” liczby. Na przykład HBP e zaczyna się od:

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

Twoje wyzwanie:

Dostaniesz:

• racjonalny cel wejściowy w zakresie [-10, 10] (uwaga: nawet osiągnięcie 10 za pomocą szeregu harmonicznych zajmuje wiele milionów terminów). Może to być po przecinku (aka 1.1) lub możesz wziąć wymierne bezpośrednio (aka 12/100)
• dodatnie wejście int n , określające liczbę terminów Harmonijnego Wzorca Bitowego do wysłania.

Oczekuje się, że wyświetlisz dokładny Harmonijny Wzór Bitowy celu na określoną liczbę terminów. Możesz wyświetlać wartości rozdzielone spacjami, rozdzielone przecinkami, bez separacji itp .; tak długo, jak wzór zer i jedynek jest wyraźnie widoczny i odczytywany od lewej do prawej ze spójnym rozdziałem.

Przypadki testowe

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

Zauważ, że ponieważ -9.8jest tak duży, pierwszy, 1który byłby wyprowadzony, znajduje się gdzieś w pobliżu 149496620tego wyrażenia (który został obliczony za pomocą liczb zmiennoprzecinkowych, więc wartość może nie być dokładna).

Perl, 69 bajtów

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

Pobiera dane wejściowe jako argumenty wiersza poleceń.

Objaśnienie : bigratumożliwia ułamki wszędzie dla dokładnych obliczeń. $sjest bieżącą sumą terminów, $ARGV[0]jest wartością docelową,pop (taką samą jak $ARGV[1]) reprezentuje liczbę terminów $pi $nreprezentuje dodatnią i ujemną liczbę terminów. $_jest albo 1i 0w zależności od tego, czy pozytywny lub negatywny termin dodano.

Haskell, 92 91 90 bajtów

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

Przykład użycia: 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].

hbuduje nieskończony wzór bitowy, przenosząc cztery parametry wokół: ajest bieżącą sumą. pjest mianownikiem następnego terminu pozytywnego qdla warunków ujemnych. zjest liczbą docelową. furuchamia wszystko i skraca wynik do długościn .

Edycja: @Zgarb znalazł bajt do zapisania. Dzięki!

Python 3, 128 124 bajtów

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)

Wykorzystuje to Fractionklasę Pythona .

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.