सामंजस्यपूर्ण "अभिसरण"

Question

द अल्टरनेटिंग हार्मोनिक सीरीज एक प्रसिद्ध अभिसरण श्रृंखला है।

"स्पष्ट रूप से", यह स्पष्ट है कि यह 2 के प्राकृतिक लॉग में परिवर्तित होता है। या करता है?

चूंकि श्रृंखला पूरी तरह से अभिसरण नहीं है , बस शब्दों को फिर से व्यवस्थित करके, मैं इसे कुछ भी बना सकता हूं जो मैं चाहता हूं। मान लीजिए कि मैं चाहता हूं कि श्रृंखला ई से अभिसरित हो । मुझे बस इतना ही करना है:

यदि आप पैटर्न नहीं पकड़ते हैं, तो कोई स्पष्ट नहीं है। यहां देखिए यह कैसे काम करता है:

1. सकारात्मक और नकारात्मक शब्दों के संदर्भ में वैकल्पिक हार्मोनिक श्रृंखला की शर्तों पर विचार करें।
2. हमारे लक्ष्य (ई) को पार करने के लिए बस पर्याप्त सकारात्मक शब्द जोड़ें। (उर्फ sum > target)
3. अगला नकारात्मक शब्द घटाएं।
4. 2 पर वापस जाएं।

ध्यान दें कि चरण 2 में, यदि हमारे sum == target, आपको एक और सकारात्मक शब्द जोड़ना चाहिए।

इससे हम प्रत्येक संख्या से जुड़े अनुक्रम को इस प्रकार परिभाषित कर सकते हैं:

• ऊपर एल्गोरिथ्म का पालन करें
• प्रत्येक सकारात्मक शब्द के लिए, आउटपुट 1।
• प्रत्येक नकारात्मक शब्द के लिए, आउटपुट 0।

आइए इस क्रम को एक नंबर का "हार्मोनल बिट पैटर्न" कहते हैं। उदाहरण के लिए, e का HBP निम्नानुसार शुरू होता है:

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वें टर्म के आसपास है (जो कि फ्लोट के माध्यम से गणना की गई थी, इसलिए मान सटीक नहीं हो सकता है)।

Answer 1

पर्ल, 69 बाइट्स

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

कमांड लाइन तर्क के रूप में इनपुट लेता है।

स्पष्टीकरण : bigratसटीक गणना के लिए हर जगह भिन्नता को सक्षम करता है। $sशब्दों की वर्तमान राशि $ARGV[0]है, लक्ष्य मान है, pop(उसी तरह $ARGV[1]) शब्दों की संख्या का प्रतिनिधित्व करता है , $pऔर $nसकारात्मक और नकारात्मक शब्द गणना का प्रतिनिधित्व करता है। या $_तो एक सकारात्मक या नकारात्मक शब्द जोड़ा गया था पर निर्भर करता है।10

Answer 2

हास्केल, 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 को बचाने के लिए एक बाइट मिला। धन्यवाद!

Comments

बाइट बचाने के h a p qबजाय परिभाषित करना h p q a।

— जर्बर्ग

यह ध्यान दिया जाना चाहिए कि 7 बाइट्स केवल अनंत परिणाम सूची को लंबाई n में से एक को ट्रिम करने पर खर्च किए जाते हैं । यह वास्तव में परिणाम के रूप में अनंत सूची देने के लिए बहुत अच्छा होगा।

— चालू करना बंद कर

Answer 3

पायथन 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कक्षा का उपयोग करता है ।

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.

Comments

'x'*int(input())?

— FryAmTheEggman