एक नंबर के जारी अंश को दोगुना करें

Question

आपका कार्य, दिया गया x, आउटपुट है 2*x। आसान सही !? लेकिन एक पकड़ है: xएक (संभवतः अनंत) निरंतर अंश के रूप में दी जाएगी , और आउटपुट एक निरंतर अंश होना चाहिए। इनपुट को वास्तविक बीजीय संख्या होने की गारंटी है, जिसकी डिग्री अधिकतम 2 पर है।

इनपुट : के निरंतर अंश x। यह 3 भागों में विभाजित है: पूर्णांक भाग, उपसर्ग और दोहराव वाला भाग। पूर्णांक भाग में एक पूर्णांक होता है। उपसर्ग और दोहराव वाला भाग धनात्मक पूर्णांक के एरे (संभवतः खाली) होते हैं जो कि पूर्वगामी और दोहराव वाले अंश का वर्णन करते हैं। उदाहरण के लिए, इनपुट (3, [1], [2, 4])जारी अंश का प्रतिनिधित्व करता है [3; 1, 2, 4, 2, 4, ...]।

यदि दोहराव वाला भाग खाली है, तो यह तर्कसंगत संख्या को दर्शाता है। उदाहरण के लिए, (3, [1, 2], [])प्रतिनिधित्व करता है [3; 1, 2] = 11/3। आपको परिमेय संख्या के दोनों रूपों को स्वीकार करना चाहिए (अर्थात (3, [1, 1, 1], []), जो [3; 1, 1, 1] = 11/3वैध इनपुट भी होना चाहिए)।

आउटपुट : इनपुट के रूप में एक ही प्रारूप में दो बार इनपुट के निरंतर अंश का आउटपुट। यदि आउटपुट तर्कसंगत है, तो आप निरंतर अंश के रूप में आउटपुट कर सकते हैं। जब तक उत्तर सही उत्तर के बराबर है, तब तक यह ठीक है; कोई "संपीड़न" आवश्यक नहीं है, इसलिए अनंत भाग थोड़ा "अनियंत्रित" [1; 4, 2, 3, 2, 3...]हो सकता है (उदाहरण के लिए लिखा (1, [4], [2, 3])या हो सकता है (1, [4, 2, 3], [2, 3]))। सभी उत्तर सटीक होना चाहिए।

परीक्षण के मामले : सुविधा के लिए सटीक फॉर्म कॉलम दिया गया है।

Input               Exact Form       Output
(0, [] [])          0                (0, [] []) or (-1, [1], [])
(-5, [1, 1], [])    -4.5             (-9, [], []) or (-10, [1], [])
(3, [1, 2], [])     11/3             (7, [3], []) or (7, [2, 1], [])
(1, [], [2])        sqrt(2)          (2, [], [1, 4])
(-1, [2], [2, 1])   -1/sqrt(3)       (-2, [1, 5], [2, 6])

और अंत में परिशुद्धता सुनिश्चित करने के लिए थोड़ा बड़ा परीक्षण मामला (0, [1], [6, 1, 3, 1, 42, 1, 3, 1, 6, 2]) --> (1, [], [1, 2, 1, 8, 1, 20, 1, 8, 1, 2, 1, 2]):।

सबसे छोटा कोड जीतता है!

संकेत : आप यहां बताए गए निरंतर अंशों पर एक सीधे तरीके से अंकगणित कर सकते हैं । एक निरंतर अंश को दोगुना करना इस एल्गोरिथ्म का केवल एक विशेष मामला है (हालांकि निरंतर अंश दोहराए जाने पर पेचीदा हिस्सा मिल सकता है)।

Comments

क्या यह काम करेगा? tio.run/##y00syUjNTSzJTE78n2b73zk/ryQzrzQ1xa0oMbkkMz8v2kjLrSg/...

— पावेल

@Pavel नहीं, आप केवल पूर्णांक, उपसर्ग और दोहराए जाने वाले भागों के आधार पर इनपुट निर्दिष्ट करने में सक्षम होना चाहिए Sqrt[2]।

— सोकटिनपैक

क्षमा करें, यह मेरी ओर से एक गलती थी। यहां इनपुट के रूप में वास्तविक जारी अंश के साथ लिंक है: tio.run/##0000UUNNTSzJTE78n2b73zk/ryQzrzQ1xa0oMbkkMz8vkjLrSg//

— पावेल

[3; 1, 1, 1](3, [1, 1, 1], [])हमारे द्वारा उपयोग किए जा रहे इनपुट प्रारूप में होगा - इसलिए प्रश्न को संभवतः उस प्रारूप में (तीसरे अनुच्छेद में) उल्लेख करना चाहिए, बस स्पष्टता सुनिश्चित करने के लिए।

— सूंदर -

आउटपुट कम से कम कैसे हो, इस पर क्या अड़चनें हैं? ईजी (-2, [1, 5, 2], [6, 2])इनपुट के लिए स्वीकार्य आउटपुट होगा (-1, [2], [2, 1])? कैसे के बारे में (-2, [1, 5, 2, 6, 2, 6], [2, 6])?

— पीटर टेलर

Answer 1

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 44 बाइट्स

ContinuedFraction[2FromContinuedFraction@#]&

इसे ऑनलाइन आज़माएं!

मैथेमेटिका में एक बिलियन है! वाह! मैथेमेटिका का बिलियन सुपर लंबा है। ओह।

मैथमेटिका के निरंतर अंश जैसे दिखते हैं {integer, ...prefix, {...repeating}}

-1 जुंगहवन मिन को धन्यवाद

Comments

*अगर कोई एक नहीं है, तो आप गणितज्ञ के डिफ़ॉल्ट सीमांकक को छोड़ सकते हैं Times।

— जुंगह्वान मिन

जब आपकी भाषा ने स्क्रैबल स्कोरिंग से लेकर बकरी की पहचान तक सभी चीजों के लिए निर्माण किया है, तो उनके कुछ नामों को आवश्यकता से "सुपर लंबा" होना होगा। :)

— सूंदर - मोनिका

@sundar नहीं, Mathematica में केवल ~ 5000 बिलियन हैं। प्रत्येक बिल्टइन 2 बाइट्स को अधिक से अधिक करना संभव है (Mthmtca देखें)

— user202729

@ user202729 लेकिन गणितज्ञ इतना लोकप्रिय नहीं होता अगर वह ऐसा करता: P

— mbomb007

Answer 2

जावास्क्रिप्ट (ईएस 6), 267 बाइट्स

(n,f,r)=>eval(`f=[0,...f];e=i=[0,2,1,0];o=j=[];k=[];m={};while([a,b,c,d]=e,c|d&&o)i*m[s=i+m+(e=c*d&&(q=a/c|0)==(b/d|0)?(o.push(q),[c,d,a-c*q,b-d*q]):1/(++i,[p,...f]=f+f?f:(i=r[0],r),p)?[b,a+b*p,d,c+d*p]:[b,b,d,d])]?k+(o=k)?o=0:(m={})[s]=1:m[s]=1;[2*n+j.shift(),j,k]`)

3 तर्क (n = पूर्णांक भाग, f = उपसर्ग, r = दोहरा भाग) को स्वीकार करता है। एक सरणी में तीन भागों को आउटपुट करता है। इसे ऑनलाइन आज़माएं!

व्याख्या

यह गणना के लिए एल्गोरिथ्म का एक काफी प्रत्यक्ष कार्यान्वयन है जो यहां जारी चुनौती में जुड़े अंश अंकगणित को जारी रखता है । दोहराए जाने वाले टेबल में इंटरमीडिएट मैट्रिसेस को संग्रहीत करने, दोहराव की प्रतीक्षा करने, और उस डुप्लिकेट की अगली उपस्थिति तक शर्तों को आउटपुट करने से बार-बार शब्दों को संभाला जाता है। यह असभ्य है और निरंतर फ्रैक्चर को संभालने के लिए आवश्यक बाइट्स को दोगुना करता है, लेकिन मैं एक बेहतर विकल्प के बारे में नहीं सोच सकता था।

अग्रणी शब्द की गणना अलग-अलग करने के लिए की जाती है ताकि यह सुनिश्चित किया जा सके कि ऋणात्मक निरंतर अंश पहले वाले सभी शब्दों के लिए सकारात्मक मान बनाए रखें।

दोहराया चक्र की प्रतीक्षा करते समय झूठी सकारात्मकता को रोकने के लिए, लुकअप तालिका डेटा को निम्नानुसार संग्रहीत करती है <index of input repeating part><delimiter><matrix values>:।

ध्यान दें कि गोल्फ संस्करण eval1 बाइट को बचाने के लिए उपयोग करता है।

(n, f, r) => {
    f = [0, ...f];                       // use a 0 to chop off the integer part
    e = i = [0,2,1,0];                   // e: matrix with starting values to handle doubling
                                         // 0 + 2x
                                         // ------
                                         // 1 + 0x
                                         // i: tracks index of repeating part; until the function loops through the
                                         // repeating part, i is equivalent to NaN
    o = j = [];                          // o: alias for group of terms currently being computed
                                         // j: output array of non-repeating terms
    k = [];                              // k: output array of repeating terms
    m = {};                              // lookup table
    while ([a,b,c,d] = e, c | d && o)    // destructure matrix
                                         // c | d stops loop if both a/c and b/d equal infinity
        i * m[s = i + m + (              // m also serves as the delimiter; JS will stringify it as "[object Object]"
                                         // if i equals a value that is coerced to NaN, this multiplication
                                         // will be falsy
            e = c * d && (q=a/c|0) == (b/d|0) // checks if either c or d is 0 to avoid converting an Infinity value to 0 using the bitwise or
                ? (o.push(q), [c, d, a - c*q, b - d*q]) // append the output term and compute the new matrix
                : 1/(++i, [p, ...f] = f+f ? f : (i=r[0], r), p) // 1/(... p) checks if p is a valid number
                                         // f+f is a short way to check length of f; if f is an empty
                                         // array, f+f = '' (which is falsy)
                                         // if f is empty, try to replace with r
                                         // if r is empty, the value of i will be set to undefined (e.g. NaN)
                    ? [b, a + b*p, d, c + d*p]
                    : [b,b,d,d]
            )
        ]                                // checks if matrix has been cached in lookup table
            ? k+(o=k)                    // if the repeating part of the output has a value...
                ? o=0                    // o serves as a flag to halt the loop
                : (m={})[s] = 1          // reset lookup table to only hold the first duplicate matrix
            : m[s] = 1;                  // otherwise flag a matrix as seen
    return [2*n + j.shift(), j, k]       // add the doubled integer part to the first term
}