फ्राइडमैन संख्या उत्पन्न करें

Question

एक फ्रीडमैन संख्या एक संख्या है जिसे सभी अंकों के लिए बुनियादी गणितीय संचालन (^, /, *, +, -) लागू करके व्यक्त किया जा सकता है। संचालन को प्रत्येक व्यक्तिगत अंक पर लागू करने की आवश्यकता नहीं है, लेकिन सभी अंकों को शामिल किया जाना चाहिए। यही है, 121 = 11 ^ 2 -> सभी अंक शामिल हैं, लेकिन 11 बनाने के लिए 1 और 1 को एक साथ जोड़ा गया है।

कोष्ठक के उपयोग की अनुमति है, लेकिन तुच्छ समाधान x= (x)एक वैध समाधान नहीं है। साथ ही मान्य नहीं है x= +x।

उदाहरण

• २५ = ५ ^ २
• 121 = 11 ^ 2
• 343 = (3 + 4) ^ 3
• 2048 = (8 ^ 4) / 2 + 0

एक प्रोग्राम लिखें जो सकारात्मक दो पूर्णांक लेगा और उस सीमा (समावेशी) में फ्रीडमैन संख्याओं की संख्या प्रिंट करेगा, और बाद की पंक्तियों में अभिव्यक्तियों के साथ संख्याएं।

इनपुट -

n m    | n, m integers, n>=0, m>n

आउटपुट -

count    | number of Friedman numbers in the given range
fn1 exp1 | Friedman number, expression
fn2 exp2
fn3 exp3
.
.
.

रविवार 29 जुलाई 00:00 बजे GMT द्वारा पोस्ट किया गया सबसे छोटा कोड विजेता होगा।

Comments

क्या आप कुछ उदाहरण फ्रीडमैन संख्या जोड़ सकते हैं और बता सकते हैं कि कैसे /काम करता है? उदाहरण के लिए, क्या है 1/3?

— JPvdMerwe

यह संख्या सभी अंकों के संचालन को लागू करके व्यक्त की जाती है। यानी 25 = 5 ^ 2, 126 = 6 * 21, 343 = (3 + 4) ^ 3 और इतने पर

— एलसर

क्या आप एकात्मक ऋण की अनुमति देते हैं? जैसे -5?

— JPvdMerwe

@JPvdMerwe इनपुट विनिर्देश की जांच करें, आपको ऐसा करने की आवश्यकता नहीं होगी, लेकिन यदि आप चाहते हैं, तो अपने आप को बाहर खटखटाएं। हालांकि यूनीरी प्लस की अनुमति नहीं है। यानी +5 एक वैध समाधान नहीं है

— एलसर

आपने विभाजन के बारे में JPvdMerwe के प्रश्न का उत्तर नहीं दिया है। क्या यह सटीक होना चाहिए? क्या मध्यवर्ती परिणाम गैर-अभिन्न हो सकते हैं?

— पीटर टेलर

Answer 1

रूबी, 456 438 408 390 370 349 344 334 [तय]

g={}
f=->a,b{a.permutation(b).to_a.uniq.flatten.each_slice b}
F,T=$*
([F.to_i,10].max..T.to_i).map{|c|f[a="#{c}".split(''),v=a.size].map{|m|f[[?+,?-,?*,?/,'','**'],v-1].map{|w|(d=(s=m.zip(w)*'').size)==v&&next
0.upto(d){|y|y.upto(d+1){|u|begin(r=eval t="#{s}".insert(y,?().insert(u,?)))==c&&g[r]=t
rescue Exception
end}}}}}
p g.size,g

आउटपुट:

% ruby ./friedman-numbers.rb 1 300
9
{25=>"(5)**2", 121=>"(11)**2", 125=>"5**(2+1)", 126=>"(6)*21", 127=>"(2)**7-1", 128=>"2**(8-1)", 153=>"(3)*51", 216=>"6**(1+2)", 289=>"(9+8)**2"}

यह भी बड़ी संख्या के लिए अपेक्षाकृत तेजी से काम करता है:

% time ruby friedman-numbers.rb 3863 3864   
1
{3864=>"(6**4-8)*3"}
ruby friedman-numbers.rb 3863 3864  14.05s user 0.17s system 99% cpu 14.224 total

Comments

मैंने इसे इनपुट के साथ चलाया 5 40और इसका परिणाम मिला [11, "11**1", 21, "21**1", 31, "31**1", 41, "41**1"]:। 25वहाँ कोई संकेत नहीं है और मुझे लगता है कि सही समाधान (उदाहरण के लिए 21) है 2*1, नहीं21**1

— क्रिस्टियान लुपस्कू

@ w0lf धन्यवाद! मुझे लगता है कि मैंने इसे ठीक कर लिया है।

— defult

हाँ, यह अब बहुत अच्छा काम करता है।

— क्रिस्टियन लुपस्क्यू

@ w0lf ने आउटपुट के लिए आवश्यक वर्णों का एक बहुत कुछ जोड़ा

— डिफ्ल्ट

आप के '+-*/'.chars.to_a+['','**']साथ प्रतिस्थापित करके 2 चार्ट प्राप्त कर सकते हैं["+","-","*","/","","**"]

— क्रिस्टियन लुपस्कु

Answer 2

पायथन 2.7 - 380 378 372 371 367 363 357 354 352 348 336 चार्ट

बस एक सरल जानवर बल खोज।

from itertools import*
s=lambda x:[x]['1'>x>'0':]+['(%s%s%s)'%f for i in range(1,len(x))for f in product(s(x[:i]),'*/-+^',s(x[i:]))]
def E(e):
 try:return eval(e.replace("^","**"))
 except:0
A={i:e for i in range(input(),input()+1)for x in permutations(`i`)for e in s("".join(x))[x>='1':]if E(e)==i}
print len(A)
for v in A:print v,A[v]

उदाहरण रन:

1
300
9
128 (2^(8-1))
289 ((9+8)^2)
216 (6^(1+2))
121 (11^2)
153 (3*51)
25 (5^2)
125 (5^(2+1))
126 (6*21)
127 ((2^7)-1)

स्पष्टीकरण:

s(x) एक ऐसा कार्य है जो अंकों के अनुक्रम से युक्त एक स्ट्रिंग लेता है और उस क्रम में उन अंकों का उपयोग करके सभी अभिव्यक्तियों को वापस करता है।

[x]['1'>x>'0':] यदि x '0' है या '0' से शुरू नहीं होने वाले अंकों का अनुक्रम है तो x युक्त सूची का मूल्यांकन करता है; अन्यथा, यह एक खाली सूची का मूल्यांकन करता है। मूल रूप से यह उस मामले को संभालता है जहां मैं सभी अंकों को एक साथ जोड़ता हूं।

['(%s%s%s)'%f for i in range(1,len(x))for f in product(s(x[:i]),'*/-+^',s(x[i:]))] मूल रूप से विभाजन दो भागों में होता है (दोनों गैर-शून्य लंबाई के होते हैं), प्रत्येक भाग पर एस () कहते हैं और उत्पाद () का उपयोग करके, उनके बीच कुछ ऑपरेटर के साथ सभी परिणामों को जोड़ते हैं।

E(e) मूल रूप से एक सुरक्षित निष्कासन है। यह ई का मान लौटाता है यदि ई वैध है और कोई नहीं।

A={i:e for i in range(input(),input()+1)for x in permutations(`i`)for e in s("".join(x))[x>='1':]if E(e)==i}

मूल रूप से यह कोड सीमा में सभी संख्याओं की कोशिश करता है, उनके अंकों की अनुमति देता है और प्रत्येक अभिव्यक्ति की जांच करता है () उस क्रमचय के लिए उत्पन्न होता है, अगर x '0' से शुरू नहीं होता है, तो पहली अभिव्यक्ति को अनदेखा करता है, क्योंकि यदि x 'से शुरू नहीं होता है' 0 'तो पहला एक्सप्रेशन सिर्फ x होगा।

वैकल्पिक संस्करण - 397 वर्ण

यदि आपको अंशों का उपयोग करना आवश्यक है तो यहां मेरा कोड है:

from fractions import*
from itertools import*
s=lambda x:["Fraction(%s)"%x]['1'>x>'0':]+['(%s%s%s)'%f for i in range(1,len(x))for f in product(s(x[:i]),'*/-+^',s(x[i:]))]
def E(e):
 try:return eval(e.replace("^","**"))
 except:0
A={i:e for i in range(input(),input()+1)for x in permutations(`i`)for e in s("".join(x))[x>='1':]if E(e)==i}
print len(A)
for v in A:print v,A[v].replace("Fraction","")

Comments

मुझे नहीं लगता कि if len(x)<2फंक्शन में कभी भी सच होगा s। इसके अलावा, आप 4 अक्षरों को बचाने के लिए अपने formatसाथ बदल सकते हैं "a[Fraction(%s)%s%s]='(%s%s%s)'"%(x[:i],o,v,x[:i],o,A)।

— भालू 19605

@ beary605: यह कभी-कभी सच होता है, जब i = len (x) -1 होता है, तो अगली कॉल में एक सिंगल चार मिलेगा। दूसरे बिंदु के लिए, धन्यवाद! :)

— JPvdMerwe

हह… except:0स्मार्ट .. बहुत स्मार्ट। मुझे याद होगा

— Ev_genus

कृपया कुछ चित्रण आउटपुट शामिल करें।

— डेविड जूल

नहीं, अभी भी चल रहा है। मुझे अपना पीसी अभी स्थानांतरित करना है, लेकिन मैं इसे कुछ दिनों तक चलने दूंगा और देखूंगा कि क्या यह खत्म हो गया है।

— JPvdMerwe

Answer 3

पायथन 3 (436) (434) (443)

यह कठिन था। अगर मैं आउटपुट को अधिक देशी बनाता हूं तो मैं कुछ पात्रों को छोड़ सकता हूं।

from itertools import*
r={};k=product;m=map
q=lambda n,h=1:["("+i+c+j+")"for(i,j),c in k(chain(*[k(*m(q,f))for f in sum(([(x[:q],x[q:])for q in range(1,len(x))]for x in m("".join,permutations(n))),[])]),list("+-*/^")+[""]*h)]if 1<len(n)else[n]*h
a,b=m(int,m(input,"nm"))
for i,j in chain(*[k(q(str(n),0),[n])for n in range(a,b+1)]):
    try:exec("if eval(%r)==j:r[j]=i"%i.replace("^","**"))
    except:0
print(len(r))
for j,i in r.items():print(i,j)

उत्पादन

n100
m200
6
(2^(8-1)) 128
(3*(51)) 153
((11)^2) 121
(5^(1+2)) 125
(6*(21)) 126
((2^7)-1) 127

Comments

तो आपके पास बहुत चालाक चालें हैं; हालाँकि, मुझे उल्लेख करना चाहिए कि आप 1 से 9 को सही ढंग से नहीं संभालते हैं और आपका इनपुट समावेशी नहीं है। आप के बाद अंतरिक्ष को हटाने के द्वारा, हालांकि 2 वर्ण को हटा सकते हैं "("+i+c+j+")"और जगह len(n)>1से 1<len(n)जिसके बाद आप कि अभिव्यक्ति के बाद अंतरिक्ष निकाल सकते हैं।

— JPvdMerwe

मेला। सभी निश्चित, +7 अक्षर

— Ev_genus

आप for j in r:print(r[j],j)7 वर्णों को बचाने के लिए अंतिम पंक्ति को बदल सकते हैं ।

— JPvdMerwe

Answer 4

गणितज्ञ 456 416 402 404 400 396 वर्ण

<< Combinatorica`; l = Length; p = Permutations; f = Flatten; c = Cases;
u[d_, o_, s_] := 
 Fold[#2[[1]] @@ If[s == 1, {#1, #2[[-1]]}, {#2[[-1]], #1}] &, 
 d[[1]], Thread@{o, Rest@d}];
q[t_, r_] := {u[t, #, r], u[HoldForm /@ t, #, r]} & /@ 
p[{Plus, Subtract, Times, Divide, Power}, {l@t - 1}];
v[m_, n_] := (t = Table[Union@
  c[f[{#~q~1, #~q~0} & /@ 
     f[p /@ c[
        FromDigits /@ # & /@ 
         f[SetPartitions /@ p@IntegerDigits@j, 1], x_ /; l@x > 1],
       1], 2], {j, _}], {j, m, n}]~f~1; {l@t}~Join~t)

उदाहरण :

v[1,300]//TableForm

आउटपुट :