สลับฮาร์มอนิซีรีส์เป็นที่รู้จักกันดีชุดกัน

"ชัดเจน" เป็นที่ชัดเจนว่ามันรวมเข้ากับบันทึกธรรมชาติของ 2 หรือมันได้หรือไม่

เนื่องจากซีรีย์ไม่ได้รวมกันอย่างแน่นอนโดยเพียงแค่จัดเรียงเงื่อนไขใหม่ฉันสามารถทำให้มันเข้าใกล้ทุกสิ่งที่ฉันต้องการ สมมติว่าผมต้องการชุดที่จะมาบรรจบกันเพื่ออี สิ่งที่ฉันต้องทำคือ:

หากคุณไม่ได้จับแบบนั้นก็ไม่มีความชัดเจน นี่คือวิธีการทำงาน:

1. พิจารณาข้อกำหนดของซีรีย์ฮาร์มอนิสลับในแง่ของแง่บวกและลบ
2. เพิ่มคำศัพท์บวกเข้าด้วยกันเพื่อให้เกินเป้าหมาย (e) (aka sum > target)
3. ลบคำลบถัดไป
4. กลับไปที่ 2

โปรดทราบว่าในขั้นตอนที่ 2 หากเราsum == targetคุณควรเพิ่มคำบวกอีกคำหนึ่ง

จากนี้เราสามารถกำหนดลำดับที่เกี่ยวข้องกับแต่ละหมายเลขดังนี้:

• ทำตามอัลกอริทึมด้านบน
• สำหรับแต่ละคำที่เป็นบวกเอาต์พุต 1
• สำหรับแต่ละคำเชิงลบเอาต์พุต 0

ลองเรียกลำดับนี้ว่า "รูปแบบบิตความสามัคคี" ของตัวเลข ตัวอย่างเช่น HBP ของ e เริ่มต้นเมื่อ:

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

ความท้าทายของคุณ:

คุณจะได้รับ:

• เป้าหมายอินพุตที่มีเหตุผลอยู่ในช่วง [-10, 10] (หมายเหตุ: แม้การเข้าถึง 10 ผ่านซีรีย์ฮาร์มอนิกนั้นใช้เวลาหลายล้านเทอม) นี่อาจเป็นทศนิยม (aka 1.1) หรือคุณอาจใช้เหตุผลโดยตรง (aka 12/100)
• อินพุตint n ที่เป็นบวกโดยระบุจำนวนเงื่อนไขของรูปแบบ Harmonious Bit เพื่อส่งออก

คุณคาดว่าจะส่งออกรูปแบบ Harmonious Bit ที่แน่นอนของเป้าหมายไปยังจำนวนคำที่ระบุ คุณสามารถส่งออกค่าที่คั่นด้วยช่องว่างคั่นด้วยเครื่องหมายจุลภาคไม่มีการแยก ฯลฯ ตราบใดที่รูปแบบของ 0s และ 1s สามารถมองเห็นได้ชัดเจนและอ่านจากซ้ายไปขวาด้วยการแยกที่สอดคล้องกัน

กรณีทดสอบ

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

โปรดทราบว่าเนื่องจาก-9.8มีขนาดใหญ่มากสิ่งแรก1ที่จะส่งออกอยู่ที่ไหนสักแห่งรอบ149496620คำศัพท์ที่ (ซึ่งคำนวณโดยผ่านทางลอยดังนั้นค่าอาจไม่แน่นอน)

Perl, 69 ไบต์

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

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่ง

คำอธิบาย : bigratเปิดใช้งานเศษส่วนได้ทุกที่เพื่อการคำนวณที่แม่นยำ $sคือผลรวมของคำปัจจุบัน$ARGV[0]คือมูลค่าเป้าหมายpop(เหมือน$ARGV[1]) หมายถึงจำนวนคำ$pและ$nเป็นตัวแทนของจำนวนคำบวกและลบ $_เป็น1หรือ0ขึ้นอยู่กับว่ามีการเพิ่มคำบวกหรือลบ

Haskell, 92 91 90 ไบต์

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

ตัวอย่างการใช้งาน: ->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]

hสร้างรูปแบบบิตที่ไม่มีที่สิ้นสุดโดยดำเนินการกับพารามิเตอร์สี่ตัวรอบ ๆ : aคือผลรวมปัจจุบัน pเป็นตัวส่วนของเทอมบวกถัดไปqสำหรับเทอมลบ zคือหมายเลขเป้าหมาย เริ่มต้นทุกอย่างขึ้นและตัดทอนผลต่อความยาวfn

แก้ไข: @Zgarb พบไบต์เพื่อบันทึก ขอบคุณ!

Python 3, 128 124 ไบต์

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)

นี่ใช้ประโยชน์จากFractionคลาส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.