इंटेगरेटेड नोटरी नोटिफिकेशन

Question

संपादित करें: मैं meta-golfजल्द ही इस प्रश्न का एक नया संस्करण पोस्ट करूंगा । ठहरे रहो!

# संपादित करें: मैं अब चुनौती को अपडेट नहीं करूंगा, लेकिन इसे खुला छोड़ दूंगा। meta-golfसंस्करण यहाँ उपलब्ध है: /codegolf/106509/obfuscated-number-golf

पृष्ठभूमि:

अधिकांश संख्याओं को केवल 6 अलग-अलग प्रतीकों के साथ लिखा जा सकता है:

• e (यूलर कांस्टेंट)
• - (घटाव, नकारात्मकता नहीं)
• ^ (घातांक)
• (
• )
• ln (प्राकृतिक)

उदाहरण के लिए, आप iइस समीकरण का उपयोग करके काल्पनिक संख्या को परिवर्तित कर सकते हैं:

(e-e-e^(e-e))^(e^(e-e-ln(e^(e-e)-(e-e-e^(e-e)))))

लक्ष्य:

किसी kभी उचित माध्यम से किसी भी पूर्णांक को देखते हुए , केवल 6 प्रतीकों का उपयोग करके उस संख्या का सबसे छोटा प्रतिनिधित्व संभव है।

उदाहरण:

0 => "e-e"
1 => "ln(e)"
2 => "ln(ee)"
// Since - cannot be used for negation, this is not a valid solution: 
// ln(e)-(-ln(e))
-1 => "e-e-ln(e)"

टिप्पणियाँ:

• अंत में कोष्ठक की गिनती वर्णों की कुल मात्रा की ओर होती है।
• ln( केवल 1 वर्ण के रूप में गिना जाता है।
• बाकी सब 1 चरित्र के रूप में गिना जाता है।
• n^0=1
• संचालन के आदेश लागू होते हैं
• कोष्ठक गुणा स्वीकार्य है, जैसे (2)(8)=16, 2(5)=10, और eln(e)=e।
• ln e मान्य नहीं है, आपको अवश्य करना चाहिए ln(e)

Comments

मुझे लगता है कि सूत्र ( ln(ee...e)) सकारात्मकता को चित्रित करने का सबसे अच्छा तरीका है। संपादित करें: नहीं, इसकी नहीं। ln(e^(ln(eeeee)ln(eeee)))20 के लिए बेहतर है

— MildlyMilquetoast

@JulianLachniet विचार से प्यार करता है, हालांकि अनुरोध किए गए अनुक्रम के पहले 10-20 शब्द देखना चाहेंगे। शायद स्पष्टीकरण के लिए -10 से 10 के लिए एक उदाहरण रखें। WheatWizard ने पहले से ही एक जोड़े को छेद दिया है, उन छेदों के साथ "सबसे कम संभव" के उद्देश्य मानदंड ठोस उदाहरणों के बिना निर्धारित करना कठिन है।

— मैजिक ऑक्टोपस Urn

कुछ उच्च लोगों के बारे में निश्चित नहीं हैं, विशेष रूप से 20.

— जूलियन लाचनीट

ln(eeee)^ln(ee)ln(eeeeeeeeeeeeeeee)16 से कम के लिए छोटा है

— पोस्ट रॉक गार्फ हंटर

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

— पोस्ट रॉक गार्फ हंटर

Answer 1

पायथन 3, 402 बाइट्स

from itertools import*
from ast import*
from math import*
v,r=lambda x:'UnaryOp'not in dump(parse(x)),lambda s,a,b:s.replace(a,b)
def l(x,y):
    for s in product('L()e^-',repeat=x):
        f=r(r(r(''.join(s),'L','log('),')(',')*('),'^','**')
        g=r(f,'ee','e*e')
        while g!=f:f,g=g,r(g,'ee','e*e')
        try:
            if eval(g)==y and v(g):return g
        except:0
def b(v):
    i=1
    while 1:
        r=l(i,v)
        if r:return r
        i+=1

उदाहरण का उपयोग:

>>> b(1)
'log(e)'
>>> b(0)
'e-e'
>>> b(-3)
'e-log(e*e*e)-e'
>>> b(8)
'log(e*e)**log(e*e*e)'

ध्यान दें कि यद्यपि आउटपुट स्वरूप इसे प्रतिबिंबित नहीं कर सकता है, लेकिन कोड प्रश्न की विशिष्टताओं के अनुसार सभी लंबाई को ठीक से गिनता है।

यह स्ट्रिंग्स के सभी संभावित लंबाई के माध्यम से एक गूंगा ब्रूटफोर्स है। फिर मैं कुछ प्रतिस्थापन का उपयोग करता हूं ताकि पायथन इसका मूल्यांकन कर सके। अगर यह हम चाहते हैं के बराबर है, मैं भी एएसटी की जाँच करके अनुपयोगी नकारात्मक संकेतों को बाहर करने के लिए जाँच करता हूँ।

मैं पायथन में गोल्फिंग में बहुत अच्छा नहीं हूं, इसलिए अगर कोई भी मदद करना चाहता है तो यहां सेमी-अनगलॉग कोड है!

from itertools import*
from ast import*
from math import*

def valid(ev):
    return 'UnaryOp' not in dump(parse(ev))

def to_eval(st):
    f = ''.join(st).replace('L', 'log(').replace(')(', ')*(').replace('^', '**')
    nf = f.replace('ee', 'e*e')
    while nf != f:
        f, nf = nf, nf.replace('ee', 'e*e')
    return nf

def try_length(length, val):
    for st in product('L()e^-', repeat=length):
        ev = to_eval(st) 
        try:
            if eval(ev) == val and valid(ev):
                return st
        except:
            pass

def bruteforce(val):
    for i in range(11):
        res = try_length(i, val)
        if res:
            print(i, res)
            return res

Comments

टैब के साथ इंडेंट करने के बजाय आप इंडेंट और टैब के एक स्तर के लिए रिक्त स्थान के साथ 2. के लिए इंडेंट कर सकते हैं

— पोस्ट रॉक गार्फ हंटर