Змінний Harmonic серія є добре відомим сходящимся поруч.

"Ясно", очевидно, що вона сходиться до природного журналу 2. Або це?

Оскільки серія не є абсолютно збіжною , просто переставивши умови, я можу змусити її підійти до всього, що я хочу. Припустимо, я хочу, щоб серія сходилася е . Все, що я повинен зробити, це це:

Якщо ви не впіймали шаблон, то очевидного немає. Ось як це працює:

1. Розгляньте умови чергування гармонічного ряду з точки зору позитивних та негативних.
2. Додайте разом достатньо позитивних термінів, щоб перевищити нашу мету (е). (ака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 через гармонічний ряд потребує багатьох мільйонів термінів). Це може бути десятковий (ака 1.1) або ви можете приймати раціональне безпосередньо (ака 12/100)
• позитивний int n введення, вказуючи кількість термінів Гармонійної бітової моделі для виведення.

Від вас очікується виведення точної гармонійної схеми бітів цілі на вказану кількість термінів. Ви можете виводити значення, розділені пробілом, розділені комами, ніякого поділу тощо; до тих пір, поки картина 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- цільове число. fвсе починає і обрізає результат на довжину n.

Редагувати: @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.