यह गणित करने का समय है

Question

परिचय

यह मेरी पसंदीदा गणित पहेलियों में से एक है।

एक अंक (3 कहते हैं) और उस अंक का उपयोग करने के लिए समय की संख्या (5 का कहना है), 10 भाव उत्पन्न करते हैं जिसके परिणामस्वरूप 1, 2, 3, 4, 5, 6, 7, 8, 9 और 10 का उपयोग करके + -, ×,,, ^ और √ (रूट) (ब्रैकेट को समूह संचालन की अनुमति है)।

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

(3^3 + 3)/(3 + 3) = (33 - 3)/(3 + 3) = 3 + 3/3 + 3/3 = 5

ध्यान दें कि उपर्युक्त सभी पांच 3 का उपयोग करते हैं और गणितीय संचालन और परिणाम 5. आप एक घन रूट को दर्शाने के लिए √ से पहले 3 का भी उपयोग कर सकते हैं। चौथा मूल बताने के लिए goes से पहले 4 का उपयोग करने के लिए समान जाता है।

यह भी ध्यान दें कि दो 3 का उपयोग 33 बनाने के लिए किया जा सकता है, या तीन 3 का उपयोग 333 और इतने पर बनाने के लिए किया जा सकता है।

चुनौती

• आपको फ़ंक्शन तर्क, STDIN या कमांड लाइन तर्क के रूप में दो नंबर (1 से 5 तक दोनों) दिए जाएंगे ।
• पहली संख्या यह दर्शाती है कि किस अंक का उपयोग करना है और दूसरी संख्या उस संख्या का निरूपण करती है जो उस संख्या का उपयोग अभिव्यक्ति में किया जाना है।
• आपके प्रोग्राम को आकार 10 (या 10 स्पेस-सेपरेटेड नंबरों) का एक सरणी आउटपुट करना चाहिए, जहां प्रत्येक तत्व यह दर्शाता है कि (index + 1)संख्या में जिसके परिणामस्वरूप गणितीय अभिव्यक्ति (केवल अनुमत ऑपरेटरों का उपयोग करना) संभव है या सत्य / मिथ्या मूल्य का उपयोग नहीं कर रहा है।

उदाहरण के लिए, यदि इनपुट है

1 3

फिर आउटपुट होना चाहिए

[1, 1, 1, 0, 0, 0, 0, 0, 0, 1]

क्योंकि केवल 1, 2, 3 और 10 को तीन 1 का उपयोग करके व्यक्त किया जा सकता है।

स्कोर

• यह एक कोड-गोल्फ है इसलिए बाइट्स जीत में न्यूनतम कोड लंबाई होती है।

बक्शीश

प्रिंट-एम-सब []50]

अपने स्कोर से 50 घटाएँ अगर आउटपुट सरणी तत्व सत्य (index + 1)या मिथ्या मूल्यों के बजाय मूल्य प्राप्त करने के लिए प्रशंसनीय संयोजनों की कुल संख्या के बराबर हैं।

उदाहरण के लिए, यदि 5 के 3 के केवल 3 संभावित संयोजन हैं, जिसके परिणाम 5 हैं, तो आउटपुट सरणी की 4 ^वीं प्रविष्टि 3 होनी चाहिए।

चरम गणित []100]

यदि आउटपुट एरे तत्वों में कम से कम एक वास्तविक अभिव्यक्ति है, जिसके परिणामस्वरूप (index + 1)मूल्य है, तो अपने स्कोर से 100 घटाएं ।

उदाहरण के लिए, यदि पांच 3 का उपयोग करते हैं, तो आउटपुट सरणी की 4 ^वीं प्रविष्टि या तो हो सकती है (3^3 + 3)/(3 + 3), (33 - 3)/(3 + 3)या3 + 3/3 + 3/3

अति-संपन्न [illed200]

यदि उत्पादन सरणी तत्वों में सभी संभावित संयोजन (अलग-अलग |) होते हैं, तो अपने स्कोर से 200 घटाएं । यह बोनस एक्सट्रीम मैथ्स बोनस में सबसे ऊपर जोड़ा जाता है , इसलिए आपको कुल मिलाकर total300 मिलता है।

उदाहरण के लिए, यदि पांच 3 का उपयोग करते हैं, तो आउटपुट सरणी का 4 ^वां तत्व होना चाहिए(3^3 + 3)/(3 + 3)|(33 - 3)/(3 + 3)|3 + 3/3 + 3/3

नोट: समान परिणाम प्राप्त करने के लिए किन्हीं दो अभिव्यक्तियों को उन दोनों में भिन्न दृष्टिकोण के साथ तार्किक रूप से भिन्न होना चाहिए।

उदाहरण के लिए, 5 का उपयोग करने के लिए पाँच 3, 3 + 3/3 + 3/3के समान है 3/3 + 3 + 3/3या 3/3 + 3/3 + 3क्योंकि उनमें से प्रत्येक के लिए एक ही दृष्टिकोण लिया जाता है। (3^3 + 3)/(3 + 3)और (33 - 3)/(3 + 3)भिन्न, जैसे कि 30 अंश में विभिन्न दृष्टिकोणों के माध्यम से प्राप्त किया जाता है।

अद्यतन : सभी उत्तरों से गुजरने के बाद, यह पाया गया कि सभी उत्तरों में एकात्मकता -और going के किनारे के मामलों के कारण खामियां थीं । इस प्रकार, उन धारियों को गायब करना ठीक माना जाता था जहाँ तक उत्तरों की पूर्णता शामिल है।

यह एक कठिन सवाल है, लेकिन एक दिलचस्प है।

हैप्पी गोल्फिंग!

Comments

मुझे क्षमा करें, यह गूंगा हो सकता है, लेकिन आप केवल तीन 1एस के साथ 10 कैसे प्राप्त करेंगे ?

— FryAmTheEggman

@FryAmTheEggman 11-1

— अनुकूलक

आह, तो मैं गूंगा था: पी

— फ्राईएम्मैनमैन

यह एक बहुत ही अस्पष्ट नियम है। मैं यह तय कर सकता हूं कि 1 का वर्गमूल, 1 के वर्गमूल का वर्गमूल आदि सभी अलग-अलग दृष्टिकोण हैं और मेरे पास अनंत संख्या में उत्तर हैं। क्या A + b, b + a से अलग है? क्या (-ए) * (-बी) बी * ए से अलग है?

— feersum

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

— १०:४४ पर १४:१४ बजे

Answer 1

पायथन 3 (अपूर्ण), 449 - 300 = 149

के रूप में सभी एक ही कमियों से ग्रस्त KSab के समाधान : कोई एकल ऑपरेटरों, पूरी तरह से parenthesized, की तरह बराबर भाव होता है (1+1)+1और 1+(1+1)। मैंने परिणामों को पारित करके सटीक डुप्लिकेट को समाप्त कर दिया set()। आउटपुट कुछ बाइट्स को बचाने के लिए थोड़ा बदसूरत हो सकता है, लेकिन मुझे यह इस तरह से पसंद है। मैंने nth रूट भी नहीं किया क्योंकि ऐसा नहीं लगता कि वे आपको इस समस्या में ज्यादा खरीदते हैं।

R=range
E=lambda z:eval(z.replace("^","**"))
def m(d,n):_=R(1,11);s={i:[]for i in _};r=R(1,n);n<2 and s[d].append(str(d));d=str(d);t=[[(d*i,i)for i in r]]+[[]]*n;h=[];[(h.append("("+A+o+B+")"),t[l].append((h[0],a+b))if a+b<n else E(*h)in _ and s[E(*h)].append(h[0]),h.pop())for l in r for j in R(l)for A,a in t[j]for k in R(l)for B,b in t[k]if a+b<=n for o in"+-*/^"if(o=="^"and-~-(0<E(B)<9)or 0==E(B)and"/"==o)-1];[print(i,set(s[i])or'')for i in _]

यदि दूसरा तर्क 5 है तो इसे चलाने में कई मिनट लगेंगे। 5. कॉल करके टेस्ट करें m(digit, number):

>>> m(1,3)
1 {'((1*1)^1)', '(1^(1+1))', '((1-1)+1)', '((1/1)/1)', '((1*1)*1)', '((1^1)/1)', '(1*(1*1))', '(1^(1*1))', '(1+(1-1))', '(1^(1^1))', '((1^1)*1)', '(1^(1/1))', '((1/1)*1)', '(1-(1-1))', '(1/(1^1))', '(1/(1*1))', '(1/(1/1))', '(1*(1^1))', '((1+1)-1)', '((1*1)/1)', '((1^1)^1)', '(1*(1/1))', '((1/1)^1)'}
2 {'(1*(1+1))', '((1^1)+1)', '((1+1)/1)', '((1*1)+1)', '((1+1)^1)', '(1+(1*1))', '((1/1)+1)', '(1+(1^1))', '(1+(1/1))', '((1+1)*1)'}
3 {'((1+1)+1)', '(1+(1+1))'}
4 
5 
6 
7 
8 
9 
10 {'(11-1)'}
>>> m(3,3)
1 {'((3/3)^3)'}
2 {'(3-(3/3))', '((3+3)/3)'}
3 {'(3-(3-3))', '((3-3)+3)', '((3/3)*3)', '(3*(3/3))', '(3/(3/3))', '((3+3)-3)', '(3^(3/3))', '(3+(3-3))', '((3*3)/3)'}
4 {'((3/3)+3)', '(3+(3/3))'}
5 
6 {'((3*3)-3)'}
7 
8 
9 {'(3+(3+3))', '((3+3)+3)', '((3^3)/3)'}
10 

Answer 2

पायथन (अपूर्ण) 493 474 - 300 = 174

इस समाधान के साथ उचित संख्या में मुद्दे हैं, सबसे पहले कि यह किसी भी प्रतिपादक को अनदेखा करता है जो बहुत बड़ा है (कोई भी घातांक 100 से अधिक है)। मुझे वास्तव में नहीं लगता कि यह 5 या उससे कम इनपुट के लिए किसी भी संभावना को हटाता है, लेकिन मुझे 100% यकीन नहीं है।

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

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

एक साइड नोट पर मुझे लगता है कि इसमें मेरे द्वारा लिखी गई कोड की सबसे लंबी सिंगल लाइन शामिल हो सकती है, खासकर इससे पहले कि यह पूरी तरह से गोल्फ हो।

R=range
F=lambda s:lambda a,b:eval(s)
L=lambda D,N:[(int(str(D)*N),str(D)*N)]+[(o(u,v),"(%s%s%s)"%(s,c,t))for p in R(1,N)for u,s in L(D,p)for v,t in L(D,N-p)for c,o in[('+',F('a+b')),('-',F('a-b')),('*',F('a*b')),('/',F("1.*a/b if b else''")),('^',F("''if(a<0 and int(b)!=b)|(a and b<0)|(b>99)else a**b")),('v',F("b**(1./a)if a and(a>=0 or b)and(b>=0 or int(1./a)==1./a)&(1./a<99)else''"))]if o(u,v)!='']
A=L(*input())
for i in R(11):
 for v,s in A:
    if v==i:print i,s[1:-1]

उदाहरण: ('v' '' 'का प्रतिनिधित्व करता है)

2,3

0 2*(2-2)
0 2v(2-2)
0 (2-2)*2
0 (2-2)/2
0 (2-2)^2
1 2^(2-2)
1 2-(2/2)
1 2v(2/2)
1 (2/2)^2
2 2v(2+2)
2 2+(2-2)
2 2-(2-2)
2 2v(2*2)
2 2*(2/2)
2 2/(2/2)
2 2^(2/2)
2 2v(2^2)
2 (2+2)-2
2 (2+2)/2
2 (2-2)+2
2 (2*2)-2
2 (2*2)/2
2 (2/2)*2
2 (2/2)v2
2 (2^2)-2
2 (2^2)/2
3 2+(2/2)
3 (2/2)+2
6 2+(2+2)
6 2+(2*2)
6 2+(2^2)
6 (2+2)+2
6 (2*2)+2
6 (2^2)+2
8 2*(2+2)
8 2*(2*2)
8 2*(2^2)
8 (2+2)*2
8 (2*2)*2
8 (2^2)*2

Comments

मुझे कुछ चीजें मिलीं जिन्हें आप छोटा कर सकते हैं L:L=lambda D,N:[(int(str(D)*N),str(D)*N)]+[(o(u,v),"(%s%s%s)"%(s,c,t))for p in R(1,N)for u,s in L(D,p)for v,t in L(D,N-p)for c,o in[('+',F('a+b')),('-',F('a-b')),('*',F('a*b')),('/',F("1.*a/b if b else''")),('^',F("''if(a<0 and int(b)!=b)|(a and b<0)or b>100 else a**b")),('v',F("''if a==0 or(b<0 and int(1./a)!=(1./a))or(b or a<0)or(1./a)>100 else b**(1./a)"))]if o(u,v)!='']

— FryAmTheEggman

मुझे माफ करना, उस टिप्पणी दिखता है वास्तव में बुरा :( वैसे भी, समझाने के लिए: जब के खिलाफ की तुलना 0, मैं बयान नकारना है, तो परिणाम स्वैप करने की कोशिश की मैं भी उपयोग करने के लिए कुछ स्थान नहीं मिला। |और &के बजाय orऔर andइन चालों के दोनों। एफ को अंतिम कॉल को छोटा करने के लिए इस्तेमाल किया जा सकता है, लेकिन किसी को कुछ डीमॉर्गन की आवश्यकता होगी और मैं चोंच के समय से बाहर भाग गया; पी

— फ्रैमएग्मैनमैन

@FryAmTheEggman ओह, यह एक अच्छी पकड़ है, मैंने अपना जवाब अपडेट किया है कि आपने क्या पोस्ट किया है और जब मेरे पास समय होगा तो मैं अंतिम एक को देखूंगा। इनपुट की वैधता की जाँच करने के लिए उन

— सशर्तियों

नेस्टेड लैम्ब्डा की evalशानदारता के लिए +10 और - मुझे आपकी दूसरी पंक्ति का पता लगाने में काफी समय लगा! मुझे लगता है कि मैंने आपको "सबसे लंबी सिंगल लाइन" पर हरा दिया है, हालांकि। ;) मैं बड़ी घातांक की अनदेखी पर सहमत हूं; वास्तव में, मुझे लगता है कि 9 से बड़ा कोई भी प्रतिपादक उपयोगी नहीं होने वाला है (जब आधार 1 है तो नो-ऑप को छोड़कर)

— DLosc

@DLosc वैसे एक परिदृश्य जो आपके पास हो सकता है वह कुछ इस तरह है 3 = 33 √ (3 ^ 33)। वास्तव में जैसा कि मैंने यह लिखा है कि मुझे एहसास है कि दो (शायद केवल दो?) संयोजन है कि मेरे उत्तर याद कर रहे हैं 4 = (4^4) √ (4 ^ (4^4))और 5एस के साथ बराबर अभिव्यक्ति है । माना जाता है कि समस्या की जड़ें बहुत ज्यादा नहीं हैं, क्योंकि उनमें से अधिकांश का उपयोग या तो 0 या 1 पर नो-ऑप्स के रूप में किया जाता है, रूट-1 होने पर नो-ऑप्स या केवल एक शक्ति को रद्द करने के लिए।

— केएसएबी

Answer 3

पायथन 3 - 349 346

r=range
l=lambda s:eval("lambda a"+s)
def T(u,f,X,Y):
    try:return u(f(X,Y))
    except:0
c=l(',x:{x}.union(*[{u(int("1"*a)*x)}|{T(u,f,X,Y)for j in r(1,a)for X in c(j,x)for Y in c(a-j,x)for f in[l(",b:a%sb"%o)for o in{"**"}|set("+-*/")]+[l(",b:a**b**-1")]}for u in[l(":-a")]+[l(":a**.5**%i"%k)for k in r(9)]])')
R=l(",i:[{n+1}<c(i,a)for n in r(10)]")

यहाँ एक बल्कि ungolfed संस्करण है:

def R(x,i):
    # Unary Operations
    U = [lambda a:-a] + [eval("lambda a:a**(1/2.**%i)" % j) for j in range(9)]
    # Binary Operations
    F = [eval("lambda a,b:a%sb"%o) for o in ["+","-","*","/","**"]] + [lambda a,b:a**(1./b)]

    def combos(i):
        L = {x}
        for u in U:
            # 3, 33, 333, etc.
            L |= {u(int(str(x)*i))}

            for j in range(1,i):
                for X in combos(j):
                    for Y in combos(i-j):
                        for f in F:
                            # To avoid trouble with division by zero, overflows and similar:
                            try:
                                L |= {u(f(X,Y))}
                            except:
                                pass
        return L

    return [n in combos(i) for n in range(1,11)]

परीक्षण के लिए मैं (9)कुछ छोटे को बदलने की सलाह देता हूं , क्योंकि यह कई वर्गमूलों की संख्या को ध्यान में रखता है, जो प्रदर्शन पर बहुत बड़ा प्रभाव डालता है।

अंत में, इसने मुझे आश्चर्यचकित कर दिया, कि क्या वास्तव में किसी मामले में माइनस की जरूरत है ...

Comments

मुझे लगता है कि आप एकात्मक के बारे में सही हैं '-' शायद कुछ नहीं जोड़ना (कम से कम बोनस के बिना आधार सवाल)। केवल गैर-तुच्छ परिदृश्य मैं ऐसा कुछ भी सोच सकता हूं 1 = 3^3 * 3^(-3), लेकिन यहां तक ​​कि इन पर विचार करते हुए, मुझे संदेह है कि कोई भी संख्या है जिसके लिए यह एक संभव समाधान है जब कोई अन्य नहीं है।

— केएसएबी

आप कई वर्ग जड़ों की गणना करने के a**.5**%iबजाय 3 बाइट्स बचा सकते a**(1/2**%i)हैं।

— DLosc

@DLosc: वास्तव में, धन्यवाद।

— Wrzlprmft

आप चार बाइट्स को एक स्थान पर कम करके छह बाइट्स बचा सकते हैं।

— बीटा डेके

@ बेताडे: मैं कभी भी चार-स्थान इंडेंट (कंपकंपी) का उपयोग नहीं करता, मैं टैब का उपयोग करता हूं। बस मेरी पोस्ट के स्रोत पर गौर करें। स्टैक एक्सचेंज सिर्फ उन्हें चार स्थानों के रूप में प्रस्तुत करता है।

— Wrzlprmft

Answer 4

गणितज्ञ - 246 वर्ण (कोई बोनस का दावा नहीं)

f[x_,y_]:=x-y
g[x_,y_]:=x/y
h[x_,y_]:=x^(1/y)
j[x_,y_]:=FromDigits@Join[IntegerDigits@x,{y}]
z[{r_,n_,L_}]:=z[{L[[1]][r,n],n,Rest@L}]
z[{r_,n_,{}}]:=r
a[n_,t_]:=Union@Select[z[{n,n,#}]&/@Tuples[{Plus,f,Times,g,Power,h,j},t-1],IntegerQ@#&&0<#<11&]

व्याख्या

फ़ंक्शन jदो-अंकों की संख्या को बुद्धिमान बनाता है।

फ़ंक्शन zएक परिणाम r, संख्या nऔर कार्यों की सूची लेता है L, जिनमें से प्रत्येक दो तर्कों पर काम करता है। यह तब [r,n]पुनरावृत्ति का उपयोग कर argumnts के लिए क्रमिक रूप से फ़ंक्शन की सूची को लागू करता है , जब तक कि सूची खाली नहीं होती है, जिसके परिणामस्वरूप यह परिणाम देता है।

फ़ंक्शन aएक संख्या nऔर कई प्रतियाँ लेता है t। यह फ़ंक्शन की सूची से लंबाई के सभी tuples (t-1) बनाता है {Plus, f, Times, g, Power, h, j}और फ़ंक्शन ज़ के माध्यम से प्रत्येक tuple भेजता है, फिर 10 के माध्यम से सभी संख्या 1 की एक सूची देता है जो बनाए गए थे।

उदाहरण निष्पादन a[2,3]लौटने {1, 2, 3, 6, 8}।

सीमाएं

क्योंकि कार्यों की सूची क्रमिक रूप से लागू की जाती है, हर बार संख्या की एक प्रति का उपभोग करते हुए, यह कुछ संयोजनों को याद कर सकता है। उदाहरण के लिए, जब चार जुड़वा बच्चों पर काम किया जाता है, तो यह 22/22 = 1 को याद करेगा, क्योंकि यह कार्य की क्रम से बाहर की सूची का मूल्यांकन करने में असमर्थता के कारण होता है। बेशक, 2/2 * 2/2 = 1 इस मामले को कवर करता है।