मैथ्स मेटागॉल्फ उन्माद!

Question

मथमेनिया स्पेक्स:

Mathemania कोड का हर टुकड़ा नंबर से शुरू होता है 2। से 2, आप निम्न कार्य कर सकते हैं:

• e: घातांक। इस कमांड का डिफॉल्ट नंबर स्क्वेर कर रहा है।
• f: कारक। यह कमांड का डिफॉल्ट नंबर ( using f on 2 = 2! = 2) पर सिंगल फैक्टोरियल का उपयोग कर रहा है ।
• r: जड़। इस कमांड का डिफॉल्ट संख्या को वर्ग-मूल है।
• c: छत समारोह।
• l: मंजिल समारोह।

Mathemania में नंबर जेनरेट करने के लिए, आपको इन कमांड्स को एक साथ स्ट्रिंग करना होगा, जो नंबर पर लेफ्ट-टू-राइट की जाती हैं 2।

उदाहरण:

ef = (2^2)! = 4! = 24
rl = floor(sqrt(2)) = floor(1.4...) = 1
er = sqrt(2^2) = sqrt(4) = 2
efrrc = ceil(sqrt(sqrt((2^2)!)))
      = ceil(sqrt(sqrt(24)))
      = ceil(sqrt(4.89...))
      = ceil(2.21...)
      = 3

e, fऔर rआदेशों अतिरिक्त Mathemania आदेश (जो भी साथ शुरू द्वारा बदला जा सकता 2है अपने "आधार" संख्या के रूप में) बदल समारोह के बाद कोष्ठक रखने और इसके अंदर Mathemania आदेशों रखकर अलग exponentiations, factorials और जड़ों उत्पन्न करने के लिए।

उदाहरण के लिए, एक वर्ग को विभाजित करने के बजाय किसी संख्या को क्यूब करने के लिए, आप इस तरह से 3उसके लिए कमांड डाल सकते हैं e:

e(efrrc) -> cube a number, "efrrc" = 3

नोट: हमारे उद्देश्य के लिए, भाज्य कमांड ( f) 2एकल गुट के रूप में शुरू होता है । इसलिए यदि आप ऐसा करते हैं f(efrrc), तो एक दोहरे तथ्य का मूल्यांकन किया जाएगा, न कि एक तिहरे तथ्य पर।

के लिए n-factorials (जैसे डबल factorials = 2 भाज्य, ट्रिपल भाज्य = 3 भाज्य आदि), आधार संख्या संख्या है कि से गुणा किया जाता nहै कि यह कम से कम, और nहै कि कम से कम, और इतने पर जब तक अंतिम संख्या नहीं किया जा सकता nबनने 0या नकारात्मक होने के बिना घटाया ।

उदाहरण के लिए:

7!! = 7 * 5 * 3 * 1 = 105 (repeatedly subtract 2, 1 is the last term as
                           1 - 2 = -1, which is negative)
9!!! = 9 * 6 * 3 = 162 (repeatedly subtract 3, 3 is the last term as
                        3 - 3 = 0, which is 0)

अधिक जानकारी के लिए, यहाँ देखें ।

आप इसे कहीं भी सम्मिलित कर सकते हैं, और यह एक समारोह के रूप में मथेमानिया द्वारा इलाज करेगा:

e(efrrc)rc = ceil(sqrt(2^3))
           = ceil(2.82...)
           = 3

आपको एक दूसरे के अंदर ये घोंसला बनाने की भी अनुमति है:

e(e(e)) = e(4th power)
        = (2^4)th power
        = 16th power

Mathemania कोड के एक दुभाषिया के लिए, यहां क्लिक करें (चीयर्स, @ BradGilbertb2gills!)

कार्य:

आपका कार्य एक ऐसा प्रोग्राम बनाना है, nजिसे इनपुट के रूप में पॉजिटिव पूर्णांक दिए जाने पर , एक मैथेमेनिया प्रोग्राम उत्पन्न होता है, जिसे निष्पादित करते समय, रिटर्न देता है n।

हालाँकि, आपके द्वारा उत्पन्न Mathemania कार्यक्रम जितना संभव हो उतना छोटा (गोल्फ) होना चाहिए, और आपका अंतिम स्कोर नमूना के उत्पन्न Mathemania कार्यक्रमों में बाइट्स की संख्या से निर्धारित होता है, जो कि पूर्णांक 10,000हैं 10,100। सबसे कम स्कोर जीतता है।

नियम और चश्मा:

• आपके प्रोग्राम को किसी भी सकारात्मक पूर्णांक के लिए एक वैध Mathemania कार्यक्रम का उत्पादन करना चाहिए, लेकिन केवल संख्याओं के बीच 10,000और 10,100परीक्षण किया जाएगा।
• आपको मातमणिया कार्यक्रमों का उत्पादन करने की अनुमति नहीं है जो एक पूर्णांक में परिणाम नहीं देते हैं। यदि आप ऐसा करते हैं, तो आपका कार्यक्रम अयोग्य है।
• आदेशों के लिए e, fऔर r, उन कार्यों के अंदर मैथेमेनिया कोड (जैसे e(efrrc), जहां efrrcफ़ंक्शन के अंदर कोड है) को ऊपर एक सकारात्मक पूर्णांक का मूल्यांकन करना चाहिए 2। यदि आपका प्रोग्राम इस नियम का पालन नहीं करता है, तो यह अयोग्य भी है।
• आपके प्रोग्राम को आधुनिक लैपटॉप पर अधिकतम 30 मिनट में 101 में से किसी भी एक परीक्षण पूर्णांक के लिए एक मैथेमेनिया कार्यक्रम वापस करना होगा।
• आपके प्रोग्राम को किसी भी पूर्णांक के लिए हर बार चलाने के बाद उसी समाधान को वापस करना होगा। उदाहरण के लिए, जब किसी प्रोग्राम को इनपुट दिया जाता है 5और वह आउटपुट करता है efrc, तो उसे आउटपुट करना होगा कि हर बार इनपुट 5दिया जाए।
• आप किसी भी सकारात्मक पूर्णांक के लिए किसी भी समाधान को हार्ड-कोड नहीं कर सकते हैं।
• अपने आउटपुट में पूरी तरह से गोल्फिंग क्षमता को अधिकतम करने के लिए, आपके कार्यक्रम को मनमाने ढंग से बड़े पूर्णांकों को संभालने में सक्षम होना चाहिए। यदि आपकी भाषा इस का समर्थन नहीं करती है, तो यह अच्छी बात नहीं है।

यह मेटाफॉल्फ है , इसलिए सबसे कम स्कोर जीतता है!

Comments

मैंने TIO Nexus पर Perl 6 में इस भाषा के लिए एक मूल्यांकनकर्ता लिखा था ।

— ब्रैड गिल्बर्ट b2gills

@ ब्रैडगिल्बर्ब २gills वाह, धन्यवाद! मैं चुनौती में एक कड़ी डालूँगा।

— ३५:१६ को ३:२

यदि इनपुट efउदाहरण के लिए है, तो क्या कोड को "स्किप" करने की अनुमति है और efऑपरेशन से पहले परिणाम का उत्पादन करें ?

— devRicher 20

@devRicher यदि आपका मतलब है कि प्रोग्राम "एफई" पहले से कठिन है, तो मौजूदा नियमों के तहत, हां आपको ऐसा करने की अनुमति है, क्योंकि "एफई" 10,000 से 10,100 की सीमा में नहीं है। मुझे यकीन नहीं है कि आपका क्या मतलब है, और मैं नियमों को बदल सकता हूं क्योंकि हार्डकोडिंग चुनौती का रास्ता बहुत आसान बनाता है, आईएमओ।

— clismique

मैं पिछले कुछ घंटों से इस चुनौती के लिए एक कार्यक्रम लिख रहा हूं। मुझे लगता है कि मेरे पास काम करने वाला कोड है, लेकिन मैं इसे ठीक से परख नहीं सकता हूं क्योंकि गुटों द्वारा बनाए गए कुछ नंबर बिल्कुल विशाल हैं और पायथन (जहां मेरा अपना कार्यक्रम और दुभाषिया है) अपने वर्गमूल को नहीं ले सकते। मुझे पूरा यकीन नहीं है कि इस बिंदु पर कार्यक्रम का क्या करना है। एक साइड नोट पर, मैंने मूल रूप से गलत समझा और सोचा कि सभी 101 परीक्षण मामलों को समय सीमा के भीतर फिट करना था, जो असंभव लग रहा था। कोई भी एक बहुत अधिक उचित लगता है।

— नॉटजागन

Answer 1

पायथन 3.5, का स्कोर ??

अब तक मेरे पास सभी 101 इनपुट्स के लिए आउटपुट नहीं है, लेकिन एक बार जब मैं सभी टेस्ट मामलों के लिए प्रोग्राम चलाता हूं तो मैं अपने स्कोर के साथ अपडेट करूंगा।

from math import *

memoized = {}
same = {}

def _(mathmania, n):
    memoized[n] = mathmania
    return mathmania

def is_prime(n):
    if n == 2:
        return True
    if n % 2 == 0 or n <= 1:
        return False
    for divisor in range(3, int(sqrt(n)) + 1, 2):
        if n % divisor == 0:
            return False
    return True

def pair_key(pair):
    low, high = pair
    diff = high - low
    if diff == 0:
        return 100
    low_done, high_done, diff_done = low in memoized, high in memoized, diff in memoized
    if high_done and memoized[high] == None or low_done and memoized[low] == None:
        return -1
    return (high_done + diff_done + (diff + 1 == low)) * 33 + low / high

def major_pairs(n):
    for i in range(n, int(sqrt(n)), -1):
        d = n / i
        if i - d < d - 1:
            break
        if d == int(d):
            yield (int(d), i)

def fact_key(pair):
    i, f = pair
    if i in memoized:
        if memoized[i] == None:
            return -1
        return 1
    return i / f

def near_fact(n, level):
    s = 4
    if n in same:
        s = same[n]
    for i in range(s, n ** 2 ** level):
        f = factorial(i)
        if f > (n - 1) ** 2 ** level:
            if f < (n + 1) ** 2 ** level:
                same[n] = i
                yield (i, f)
            else:
                return

def generate_mathmania(n):
    if n in memoized and memoized[n] != None:
        return memoized[n]
    memoized[n] = None
    binx = log(n, 2)
    if binx == int(binx):
        if binx == 2:
            return _("e", n)
        if binx == 1:
            return _("er", n)
        if binx == 0:
            return _("rl", n)
        return _("e(" + generate_mathmania(int(binx)) + ")", n)
    sq = sqrt(n)
    if sq == int(sq):
        return _(generate_mathmania(int(sq)) + "e", n)
    low, high = max(major_pairs(n), key=pair_key)
    if pair_key((low, high)) == -1:
        level = 1
        while True:
            try:
                i, f = max(near_fact(n, level), key=fact_key)
            except:
                level += 1
                continue
            if fact_key((i, f)) == -1:
                return _(generate_mathmania((n - 1) ** 2 + 1) + "rc", n)
            if f == n ** 2 ** level:
                return _(generate_mathmania(i) + "f" + "r" * level, n)
            if f < n ** 2 ** level:
                return _(generate_mathmania(i) + "f" + "r" * level + "c", n)
            return _(generate_mathmania(i) + "f" + "r" * level + "l", n)
    if low != 1:
        if low == high:
            return _(generate_mathmania(low) + "e", n)
        if high - low == 1:
            return _(generate_mathmania(high) + "f", n)
        return _(generate_mathmania(high) + "f(" + generate_mathmania(high - low + 1) + ")", n)
    good = None
    for i in range(n ** 2 - 1, (n - 1) ** 2, -1):
        if i in memoized:
            return _(generate_mathmania(i) + "rc", n)
        if not is_prime(i):
            good = i
    if good:
        return _(generate_mathmania(good) + "rc", n)
    for i in range((n + 1) ** 2 - 1, n ** 2, -1):
        if i in memoized:
            return _(generate_mathmania(i) + "rl", n)
        if not is_prime(i):
            good = i
    if good:
        return _(generate_mathmania(good) + "rl", n)
    return _(generate_mathmania((n - 1) ** 2 + 1), n)

इसके अतिरिक्त, मैं कुछ परीक्षण मामलों के आउटपुट को सत्यापित करने में असमर्थ था जो मैंने सरासर संख्या आकार के कारण कोशिश की थी, और उस समय @ ब्रैडगिलबर्ट 2 मिल्स के ऑनलाइन दुभाषिए के समय के बाहर। उम्मीद है कि सभी आउटपुट काम करेंगे।

Comments

मेरे पास पायथन 2 (संभवतः 3) में एक दुभाषिया है जो यहां मनमानी परिशुद्धता को संभालने में सक्षम होना चाहिए । इसे चलाने के लिए अपने IDE में कॉपी और पेस्ट करें।

— क्लिस्मिक

कुछ आउटपुट क्या थे ताकि मैं संभवतः इसे ऑप्टिमाइज़ कर सकूं।

— ब्रैड गिल्बर्ट