संख्याओं और अंकगणित ऑपरेटरों की दी गई सूची का उपयोग करके एक संख्या उत्पन्न करें

Question

आपको संख्याओं की सूची L = [17, 5, 9, 17, 59, 14], ऑपरेटरों का एक बैग O = {+:7, -:3, *:5, /:1}और एक नंबर दिया जाता है N = 569।

कार्य

एक समीकरण को आउटपुट करें जो Lबाईं ओर के सभी नंबरों का उपयोग करता है और केवल दायीं ओर की संख्या का उपयोग करता है N। यदि यह संभव नहीं है, उत्पादन गलत। उदाहरण समाधान:

59*(17-5)-9*17+14 = 569

सीमाएं और स्पष्टता

• आप संख्या को समाप्‍त नहीं कर सकते हैं ( [13,37]इसका उपयोग नहीं किया जा सकता है 1337)
• केवल प्राकृतिक संख्याएँ और शून्य दिखाई देंगे L।
• आदेश में Lकोई फर्क नहीं पड़ता।
• आपको सभी नंबरों का उपयोग करना चाहिए L।
• केवल ऑपरेटरों +, -, *, /में दिखाई देगा O।
• Oआपकी आवश्यकता से अधिक ऑपरेटर हो सकते हैं, लेकिन कम से कम |L|-1ऑपरेटर
• आप प्रत्येक ऑपरेटर को किसी भी संख्या में मान तक ले सकते हैं O।
• सभी चार ऑपरेशन Oमानक गणितीय संचालन हैं; विशेष रूप से, /सटीक भिन्न के साथ सामान्य विभाजन है।

अंक

• कम अंक, बेहतर
• आपके कोड का प्रत्येक वर्ण आपको एक बिंदु देता है

आपको एक गैर-गोल्फ संस्करण प्रदान करना होगा जो पढ़ने में आसान है।

पृष्ठभूमि

स्टैक ओवरफ्लो पर एक समान प्रश्न पूछा गया था। मैंने सोचा कि यह एक दिलचस्प कोड-गोल्फ चुनौती हो सकती है।

अभिकलनात्मक जटिलता

जैसा कि पीटर टेलर ने टिप्पणियों में कहा, आप इसके साथ सबसेट राशि हल कर सकते हैं :

1. आपके पास सब्मिट राशि का एक उदाहरण है (इसलिए पूर्णांक का एक सेट और संख्या x)
2. L: = S + [0, ..., 0] (| S | एक शून्य बार), N: = x, O: {{+:: S--1, *: | S | - 1, /: 0, -: 0}
3. अब मेरी समस्या के इस उदाहरण को हल करें
4. सबसेट के लिए समाधान S की संख्या है जो शून्य से गुणा नहीं होता है।

यदि आपको एक एल्गोरिथ्म मिलता है जो O (2 ^ n) से बेहतर है, तो आप साबित करते हैं कि P = NP। जैसा कि पी बनाम एनपी एक मिलेनियम पुरस्कार समस्या है और इसलिए 1,000,000 यूएस-डॉलर की कीमत है, यह बहुत संभावना नहीं है कि कोई व्यक्ति इसके लिए एक समाधान ढूंढता है। इसलिए मैंने रैंकिंग के इस हिस्से को हटा दिया।

परीक्षण के मामलों

निम्नलिखित केवल मान्य उत्तर नहीं हैं, अन्य समाधान मौजूद हैं, और अनुमति दी गई है:

• ( [17,5,9,17,59,14], {+:7, -:3, *:5, /:1}, 569)
  => 59 * (17-5)- 9 * 17 + 14 = 569
• ( [2,2], {'+':3, '-':3, '*':3, '/':3}, 1)
  => 2/2 = 1
• ( [2,3,5,7,10,0,0,0,0,0,0,0], {'+':20, '-':20, '*':20, '/':20}, 16)
  => 5+10-2*3+7+0+0+0+0+0+0+0 = 16
• ( [2,3,5,7,10,0,0,0,0,0,0,0], {'+':20, '-':20, '*':20, '/':20}, 15)
  => 5+10+0*(2+3+7)+0+0+0+0+0+0 = 15

Comments

है m = |L|? यदि हाँ, तो आप उस सूची के आकार पर निर्भर नहीं होने के लिए रनटाइम की अपेक्षा कैसे कर सकते हैं? उदाहरण के लिए, [2,2],[+,+,...,+,/],1। वास्तव में, चूंकि n O (m) है, आप इसे केवल m के संदर्भ में लिख सकते हैं।

— बूथ

यह किस तरह के अंकगणित का उपयोग करने के लिए है - सटीक अंश, पूर्णांक ( /ar div), बस फ़्लोटिंग-पॉइंट और आशा-के लिए-नो-राउंडिंग-त्रुटियाँ, ...?

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

कम्प्यूटेशनल जटिलता के लिए जटिल स्कोरिंग नियम क्यों? उप-योग से एक आसान कमी है, इसलिए O (2 ^ n) से बेहतर कुछ भी एक मिलियन अमरीकी डालर का है।

— पीटर टेलर

— संबं धत लं क

तीसरा परीक्षण मामला गलत नहीं है ...5+10+2*3+7*0+0...

— श्मिट

Answer 1

पायथन 2.7 / 478 चार्ट

L=[17,5,9,17,59,14]
O={'+':7,'-':3,'*':5,'/':1}
N=569
P=eval("{'+l+y,'-l-y,'*l*y,'/l/y}".replace('l',"':lambda x,y:x"))
def S(R,T):
 if len(T)>1:
  c,d=y=T.pop();a,b=x=T.pop()
  for o in O:
   if O[o]>0 and(o!='/'or y[0]):
    T+=[(P[o](a, c),'('+b+o+d+')')];O[o]-=1
    if S(R,T):return 1
    O[o]+=1;T.pop()
  T+=[x,y]
 elif not R:
  v,r=T[0]
  if v==N:print r
  return v==N
 for x in R[:]:
  R.remove(x);T+=[x]
  if S(R,T):return 1
  T.pop();R+=[x]
S([(x,`x`)for x in L],[])

खोज करने के लिए मुख्य विचार अभिव्यक्ति के पोस्टफिक्स फॉर्म का उपयोग करना है। उदाहरण के लिए, 2*(3+4)पोस्टफिक्स फॉर्म में होगा 234+*। तो समस्या L+ के आंशिक रूप से क्रमचय का Oपता लगाने में सक्षम हो जाती है N।

निम्न संस्करण ungolfed संस्करण है। ढेर stkजैसा दिखता है [(5, '5'), (2, '5-3', (10, ((4+2)+(2*(4/2))))]।

L = [17, 5, 9, 17, 59, 14]
O = {'+':7, '-':3, '*':5, '/':1} 
N = 569

P = {'+':lambda x,y:x+y,
     '-':lambda x,y:x-y,
     '*':lambda x,y:x*y,
     '/':lambda x,y:x/y}

def postfix_search(rest, stk):
    if len(stk) >= 2:
        y = (v2, r2) = stk.pop()
        x = (v1, r1) = stk.pop()
        for opr in O:
            if O[opr] > 0 and not (opr == '/' and v2 == 0):
                stk += [(P[opr](v1, v2), '('+r1+opr+r2+')')]
                O[opr] -= 1
                if postfix_search(rest, stk): return 1
                O[opr] += 1
                stk.pop()
        stk += [x, y]
    elif not rest:
        v, r = stk[0]
        if v == N: print(r)
        return v == N
    for x in list(rest):
        rest.remove(x)
        stk += [x]
        if postfix_search(rest, stk):
            return True
        stk.pop()
        rest += [x]
postfix_search(list(zip(L, map(str, L))), [])

Comments

वाह, यह मेरी अपेक्षा से कम है। मैंने एक एल्गोरिथ्म को स्क्राइब किया है जिसमें रूपांतरण पोस्टफ़िक्स <=> इन्फिक्स शामिल है, लेकिन मेरा स्क्रिबल आपके कार्यान्वयन से बहुत कम नहीं था। प्रभावित। और निर्माण के लिए धन्यवाद P[opr](v1, v2)। मैंने इस तरह के लंबोदा और शब्दकोशों के संयोजन के बारे में कभी नहीं सोचा था, हालांकि यह अब स्पष्ट लगता है।

— मार्टिन थोमा

मैंने अपने 4 वें टेस्टकेस के साथ आपके समाधान का परीक्षण करने की कोशिश की है। 2h के बाद, मैंने निष्पादन को रोक दिया।

— मार्टिन थोमा

@ मुझे लगता है कि इसे और तेज़ बनाने के लिए कुछ अनुमान लगाने की कोशिश करूँगा। लेकिन उसके बाद कोड की लंबाई दोगुनी हो सकती है।

— रे

मैंने यहाँ किया था जैसे अंश का उपयोग करना आपके उत्तर में एक समस्या को हल करता है। मेरे द्वारा दिए गए लिंक पर दिए गए उदाहरण के लिए इसे आज़माएँ। आपके वर्तमान कोड का उत्तर नहीं मिलता है, लेकिन जब आप अंश का उपयोग करते हैं तो यह करता है।

— मार्टिन थूमा