उपयोगकर्ता-निर्दिष्ट संख्याओं का उपयोग करके एक वैध समीकरण बनाएं

Question

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

Input:           Solution:
7 5 4 8 4 34     5*8-7+4/4 = 34
3 1 5 7 6 54     (7+3)*6-5-1 = 54
3 9 2 1 6 87     9*(2+1)*3+6 = 87
2 1 6 9 7 16     (9-7+6*1)*2 = 16
2 4 5 8 6 96     8*(5+6)+2*4 = 96
3 8 4 5 4 49     8*(4+4)-3*5 = 49

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

प्रोग्राम कोड लंबाई (आवश्यक व्हाट्सएप सहित) के आधार पर बनाए जाएंगे। नोट: विभाजन सटीक होना चाहिए, निकटतम पूर्णांक तक गोल या छोटा नहीं होना चाहिए।

Comments

गणितीय संचालन के किसी भी संयोजन का उपयोग करके 4 संख्याओं से एक संख्या प्राप्त करना

— पीटर टेलर

यह बहुत ही समान कार्य है, लेकिन मुझे लगता है कि अतिरिक्त शब्द और इस पर कोई प्रतिबंध नहीं है कि अभिव्यक्तियों को कैसे वर्गीकृत किया जाए ताकि समस्या का विस्तार हो सके इसके लिए दिलचस्प रूप से अलग होना चाहिए। इसके अतिरिक्त, यह एक कोड चुनौती के बजाय एक गोल्फ चुनौती है, जो विभिन्न समाधानों के लिए कॉल करेगा।

— सर_लगसालॉट

संघ के बारे में क्या? उदाहरण के लिए यदि 7 5 4 8 4 34 दिया जाता है, तो आउटपुट 7 + 54/8 * 4 की अनुमति होगी?

— पैट्रिक रॉबर्ट्स

Answer 1

पायथन 2.7 (284), पायथन 3.x (253)

from __future__ import division #(Remove for Python 3.x)
from itertools import *
a=raw_input().split()
for i in permutations(a[:-1],5):
 for j in product('+-*/',repeat=5):
  for k,l in combinations(range(1,12,2),2):
   d=''.join(sum(zip(i,j),()))[:-1];d='('+d[:l]+')'+d[l:]
   if eval(d)==int(a[-1]):print d;b

यह bसमाधान पर एक त्रुटि (अज्ञात फ़ंक्शन को कॉल करना ) देता है ।

असल में, यह एक विशाल जानवर बल है। यह इनपुट में लेता है, इसे अपने रिक्त स्थान ( 1 2 -> [1,2]) द्वारा विभाजित करता है , और फिर उस सूची के माध्यम से अनुमति देता है। प्रत्येक क्रमपरिवर्तन के साथ, यह वर्णों का उपयोग करके लंबाई 5 के सभी संभावित तारों के माध्यम से पुनरावृत्ति करेगा +-*/। उन पुनरावृत्तियों में से प्रत्येक के साथ, यह सूची की लंबाई 2 के संयोजन उत्पन्न करेगा [1,3,5,7,9,11], क्रमपरिवर्तन और स्ट्रिंग को एक साथ जोड़ देगा ( 12345 *-/+- -> 1*2-3/4+5-), और कोष्ठक में डाल दिया। अंत में, यह इसका मूल्यांकन करेगा, और यदि उत्तर और समीकरण सत्य हैं, तो यह समीकरण को प्रिंट करता है और बंद हो जाता है।

यह बहुत ही अक्षम्य है, इसके बारे में है O(n!/(n-5)!)=O(n^5), लेकिन यह परीक्षण इनपुट के लिए एक उचित समय में चलता है।

Comments

विभाजन का उपयोग करते समय पूर्णांक गणित गलत आउटपुट का कारण बन सकता है। उदाहरण के लिए, इनपुट "3 6 8 7 1 29" पैदावार "(3 + 8/6) * 7 + 1", जो 31 1/3 के बराबर है, 29 नहीं। मैं इसे स्पष्ट करने के लिए विवरण को अपडेट करूंगा।

— १

यह (3/6)*8*7+1मेरे लिए देता है।

— beary605

ठीक है, मैं इस्तेमाल किया दुभाषिया के साथ एक मुद्दे के रूप में चाक कर दूंगा।

— सर_गैसालोट

Answer 2

स्केल 368:

2 जी = -लीन का परीक्षण करना अधिक आसान है, पहला कमांड तर्क लेने के लिए लचीला है, और दोनों समान लंबाई के हैं, इसलिए मैं केवल दूसरे से गिनती करता हूं - इसे पास करने के लिए निकालें।

val g=(args.map(_.toDouble))
val g=Array(3,9,2, 1, 6, 87)
val k="+*/-DQ"
val i=(0 to 5)
val f:Seq[(Double,Double)=>Double]=Seq(_+_,_*_,_/_,_-_,(a,b)=>b-a,(a,b)=>b/a)
val h=g.init.permutations;
for(j<-h;o<-i;p<-i;q<-i;r<-i;z=try{f(r)(f(q)(f(p)(f(o)(j(0),j(1)),j(2)),j(3)),j(4))}catch{case _ => 0}
if(z==g(5)))printf("(((%d%c%d)%c%d)%c%d)%c%d=%d\n",j(0),k(o),j(1),k(p),j(2),k(q),j(3),k(r),j(4),g(5))

नमूना उत्पादन (अभी आपके पास एक प्रश्न हो सकता है - बस एक पल):

(((5+7)/1)+6)*3=54
(((5-7)D1)*6)*3=54
(((5D7)+1)*6)*3=54
(((5+7)+6)Q1)Q3=54

इस 5D7 चीज़ के बारे में क्या? डी 1? क्या यह हेक्स है? Q1, Q3 है - ऐसा क्या है।

Sir_Lagsalot ने चुनौती की भावना में नए बुनियादी संचालन की अनुमति दी, और हाँ, ये मूल संचालन हैं, डेल्टा और उद्धरण।

वे a / b से अलग हैं और ab में aQb का अर्थ है b / a और aDb का मतलब है ba। चलो इसे यूक्रेनी संकेतन कहते हैं।

इसलिए

(((5-7)D1)*6)*3=54

माध्यम

((1-(5-7))*6)*3=54
 (1-(-2))*6*3
   3*6*3 = 18*3=54

कैसे और क्यों के अधिक दिलचस्प सवाल के लिए: शुरुआत में मैं कोष्ठक लगाने की संभावनाओं के बारे में पागल हो गया, और क्या (a + b) -c = a + bc = (a + bc) = ((a + b) ) -c) = (b + a) -c इत्यादि। आप इस प्रश्न पर पागल हो सकते हैं, लेकिन यदि आप संभव कोष्ठक संयोजनों को लिखते हैं, तो आप कभी-कभी खरोंच शीट को फेंक देते हैं और इस तथ्य का सामना करते हैं: आप हमेशा 5 मानों के बीच 4 ऑपरेशन करते हैं, और आप हमेशा उनमें से एक के साथ शुरू करते हैं। अगर पैटर्न हमेशा होता है(((_x_)x_)x_)x_ ?= _ (x 4 संचालकों में से एक है) और विपरीत दिशा (xb) और (bxa) को अनुमति दें, तो आपने हर संभावना को संबोधित किया है।

अब a + b और a * b के लिए हमें किसी विपरीत दिशा की आवश्यकता नहीं है, वे कम्यूटेटिव हैं। इसलिए मैंने डी और क्यू ऑपरेटर का आविष्कार किया, जो सिर्फ दिशा को बदलते हैं। मेरे पास अब 2 ऑपरेटर और हैं, लेकिन दिशा बदलने की आवश्यकता नहीं है। खैर - यह कार्य अनुक्रम में किया जाता है:

 (a,b)=>b-a,(a,b)=>b/a

मेरी समझ के लिए एरे जी से मान लेता है, और उन्हें ई पर वितरित करता है, फिर मैं फ़ंक्शन को लेने के लिए 4 इंडेक्स चुनता हूं और बाद में (केवल इंडेक्स द्वारा) संबंधित ऑपरेटर प्रतीक। मुझे div / 0 त्रुटियों को पकड़ना होगा, क्योंकि घटाव शून्य हो सकता है, जबकि नमूना इनपुट डेटा में 0 नहीं होता है।

Comments

डेल्टा और कोटेटिव ऑपरेटर ठीक हैं। यदि आप गोल्फिंग की योजना बनाते हैं, तो आपको आउटपुट में कोष्ठक जोड़ना होगा।

— सर_गैसलाकोट

आउटपुट अब कोष्ठक को मुद्रित करता है।

— उपयोगकर्ता अज्ञात