Các Xen kẽ Harmonic Dòng là một loạt hội tụ nổi tiếng.

"Rõ ràng", rõ ràng là nó hội tụ đến nhật ký tự nhiên của 2. Hay không?

Vì bộ truyện không hoàn toàn hội tụ , bằng cách sắp xếp lại các điều khoản, tôi có thể làm cho nó tiếp cận bất cứ điều gì tôi muốn. Giả sử tôi muốn chuỗi hội tụ đến e . Tất cả những gì tôi phải làm là đây:

Nếu bạn không bắt được mô hình, thì đó không phải là một mô hình rõ ràng. Đây là cách nó hoạt động:

1. Xem xét các điều khoản của loạt điều hòa xen kẽ về các điều khoản tích cực và tiêu cực.
2. Thêm các điều khoản tích cực vừa đủ để vượt quá mục tiêu của chúng tôi (e). (còn gọi là sum > target)
3. Trừ các thuật ngữ tiêu cực tiếp theo.
4. Quay trở lại 2.

Lưu ý rằng ở bước 2, nếu của chúng tôi sum == target, bạn nên thêm một thuật ngữ tích cực khác.

Từ đó, chúng ta có thể định nghĩa một chuỗi liên kết với mỗi số như sau:

• Thực hiện theo thuật toán trên
• Đối với mỗi thuật ngữ tích cực, đầu ra 1.
• Đối với mỗi thuật ngữ phủ định, đầu ra 0.

Chúng ta hãy gọi chuỗi này là "Mẫu bit hài hòa" của một số. Ví dụ: HBP của e bắt đầu là:

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

Thử thách của bạn:

Bạn sẽ được:

• một mục tiêu đầu vào hợp lý trong phạm vi [-10, 10] (lưu ý: thậm chí đạt 10 thông qua chuỗi điều hòa cần nhiều triệu thuật ngữ). Đây có thể là số thập phân (aka 1.1) hoặc bạn có thể lấy lý do trực tiếp (aka 12/100)
• đầu vào int n dương , chỉ định số lượng thuật ngữ của Mẫu bit hài hòa với đầu ra.

Bạn dự kiến ​​sẽ xuất Mẫu bit hài hòa chính xác của mục tiêu sang số lượng điều khoản được chỉ định. Bạn có thể xuất các giá trị được phân tách bằng dấu cách, được phân tách bằng dấu phẩy, không phân tách, v.v; miễn là có thể nhìn thấy rõ mẫu 0 và 1 và được đọc từ trái sang phải với sự phân tách nhất quán.

Các trường hợp thử nghiệm

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

Lưu ý rằng vì -9.8quá lớn, đầu tiên 1sẽ là đầu ra ở đâu đó xung quanh 149496620thuật ngữ thứ (được tính toán thông qua số float, vì vậy giá trị có thể không chính xác).

Perl, 69 byte

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

Lấy đầu vào làm đối số dòng lệnh.

Giải thích : bigratcho phép phân số ở mọi nơi để tính toán chính xác. $slà tổng số hiện tại của các điều khoản, $ARGV[0]là giá trị đích, pop(giống như $ARGV[1]) đại diện cho số lượng thuật ngữ $pvà $nđại diện cho số lượng thuật ngữ tích cực và tiêu cực. $_là 1hoặc 0tùy thuộc vào việc một thuật ngữ tích cực hay tiêu cực đã được thêm vào.

Haskell, 92 91 90 byte

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

Ví dụ sử dụng: 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].

hxây dựng mẫu bit vô hạn bằng cách mang bốn tham số xung quanh: alà tổng hiện tại. plà mẫu số của thuật ngữ tích cực tiếp theo, qđối với các thuật ngữ phủ định. zlà số mục tiêu. fbắt đầu mọi thứ lên và cắt ngắn kết quả theo chiều dài n.

Chỉnh sửa: @Zgarb tìm thấy một byte để lưu. Cảm ơn!

Python 3, 128 124 byte

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)

Điều này sử dụng Fractionlớp của Python .

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.