वर्गमूलों को पूर्ववत करें

Question

आपका काम दशमलव को पूर्णांक के वर्गमूल के योग में बदलना है। परिणाम में कम से कम 6 महत्वपूर्ण दशमलव अंकों की सटीकता होनी चाहिए।

इनपुट :

वर्ग जड़ों की संख्या और दशमलव को अनुमानित करने वाली संख्या को दर्शाने वाली संख्या।

उदाहरण इनपुट:

2 3.414213562373095

आउटपुट : रिक्त स्थान द्वारा अलग किए गए इंटीग्रर्स, जब वर्ग को जोड़ा और जोड़ा जाता है, लगभग कम से कम 6 महत्वपूर्ण दशमलव अंकों के सटीक मूल दशमलव होते हैं।

समाधान में शून्य की अनुमति नहीं है।

यदि कई समाधान हैं, तो आपको केवल एक प्रिंट करना होगा।

उदाहरण आउटपुट (किसी भी क्रम में):

4 2

यह काम करता है क्योंकि Math.sqrt(4) + Math.sqrt(2) == 3.414213562373095।

यह कोड गोल्फ है। सबसे छोटा कोड (वैकल्पिक बोनस के साथ) जीतता है!

हमेशा एक समाधान होने वाला है लेकिन -10 यदि आपका प्रोग्राम पूर्णांक के साथ समाधान नहीं होने पर "नहीं" प्रिंट करता है। इसके अलावा, -10 यदि आपका प्रोग्राम सभी समाधानों को प्रिंट करता है (केवल एक के बजाय, न्यूक्लियर या अर्धविराम या जो भी अलग से)।

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

3 7.923668178593959 --> 6 7 8
2 2.8284271247461903 --> 2 2
5 5.0 --> 1 1 1 1 1
5 13.0 --> 4 4 9 9 9 --> 81 1 1 1 1 --> 36 9 4 1 1 etc. [print any, but print all for the "all solutions bonus"]

और हाँ, आपके प्रोग्राम को किसी भी उचित मशीन पर परिमित मेमोरी का उपयोग करके परिमित समय में समाप्त करना होगा। यह काम नहीं कर सकता है "सिद्धांत रूप में," आपको वास्तव में इसका परीक्षण करने में सक्षम होना चाहिए।

Comments

यदि कई समाधान हैं, तो क्या यह मायने रखता है कि हम कौन सा समाधान प्रिंट करते हैं? उदाहरण के लिए आपके अंतिम परीक्षण के मामले में (5 13.0), यह भी एक वैध समाधान है: 81 1 1 1 1

— Jakube

और समाधान में शून्य की अनुमति है?

— जकूबे

क्या इनपुट हमेशा अंतरिक्ष से अलग होता है?

— Sp3000

और फंक्शन कॉल के माध्यम से इनपुट की अनुमति है?

— याकूब

इसके अलावा, डुप्लिकेट समाधान के बारे में क्या? पहले उदाहरण के लिए, क्या हमारे कोड 6 7 8को दूसरे बोनस के लिए सभी छह परमिटों को प्रिंट करने की अनुमति है ?

— मार्टिन एंडर

Answer 1

पायथन 3, 90 - 10 = 80

def S(N,x,n=[],i=1):
 if x*x<1e-12>N==0:print(*n)
 while.1+x*x>i:S(N-1,x-i**.5,n+[i]);i+=1

(युक्तियों के लिए @xnor के लिए मेगा धन्यवाद, विशेष रूप से थोड़ी देर के लिए लूप के पुनर्गठन)

एक सरल पुनरावर्ती प्रयास। यह लक्ष्य संख्या के साथ शुरू होता है और 0 या कम हिट होने तक लगातार वर्ग जड़ों को घटाता है। फ़ंक्शन Sको कहा जा सकता है S(2,3.414213562373095)(दूसरा तर्क सकारात्मक माना जाता है)।

कार्यक्रम केवल सभी समाधानों का प्रिंट आउट नहीं करता है, यह समाधानों के सभी क्रमपरिवर्तन (एक छोटे से बाहरी, मुझे पता है) को प्रिंट करता है। यहाँ पिछले मामले के लिए आउटपुट है: पास्टेबिन ।

एक मामूली मोड़ 98 - 10 = 88 समाधान देता है जो क्रमपरिवर्तन को प्रिंट नहीं करता है, जिससे यह अधिक कुशल होता है:

def S(N,x,n=[]):
 *_,i=[1]+n
 if x*x<1e-12>N==0:print(*n)
 while.1+x*x>i:S(N-1,x-i**.5,n+[i]);i+=1

और सिर्फ मनोरंजन के लिए, यह 99 - 10 = 89 एक के बारे में कुशल है क्योंकि इसे प्राप्त होता है (दूसरों के विपरीत, यह स्टैक को उड़ा नहीं देता है S(1,1000):

def S(N,x,n=[]):
 *_,i=[1]+n
 if x*x<1e-12>N:print(*n)
 while(.1+x*x>i)*N:S(N-1,x-i**.5,n+[i]);i+=1

ध्यान दें कि, हालांकि हमारे पास एक उत्परिवर्ती डिफ़ॉल्ट तर्क है, यह कभी भी समस्या का कारण नहीं बनता है यदि हम n+[i]एक नई सूची बनाते हैं।

---

शुद्धता का प्रमाण

अनंत लूप में समाप्त होने के लिए, हमें कुछ बिंदु पर जहां x <0 और 0.1 + x ² > 1 मारना चाहिए । यह x <-0.948 ... से संतुष्ट है ।

लेकिन ध्यान दें कि हम सकारात्मक x से शुरू करते हैं और x हमेशा कम होता है, इसलिए x <-0.948 ... को हिट करने के लिए हमारे पास x ' होना चाहिए - i ^0.5 <-0.948 ... कुछ x'> -0.948 के लिए। । से पहले एक्स और सकारात्मक पूर्णांक मैं । लूप को चलाने के लिए, हमारे पास 0.1 + x ' ² > i होना चाहिए ।

पुनर्व्यवस्थित करने पर हमें x ' ² + 1.897x' + 0.948 <i <0.1 + x ' ² मिलते हैं , बाहरी भाग जो x' <-0.447 का अर्थ लगाते हैं । लेकिन अगर -0.948 <x '<-0.447 , तो कोई भी सकारात्मक पूर्णांक I उपरोक्त असमानता में अंतर को फिट नहीं कर सकता है।

इसलिए हम एक अनंत लूप में कभी खत्म नहीं होंगे।

Comments

आप बच सकते हैं absके साथ x*x<1e-12।

— xnor

मुझे लगता है कि यह whileलूप कार्य को बदलने के लिए कार्य करता है for: फ़ंक्शन पैरामीटर में while.1+x*x>i:S(x-i**.5,n+[i]);i+=1आरंभिक रूप i=1से। विचार को intएस में परिवर्तित करने की आवश्यकता से बचने के लिए है । .1नाव अशुद्धियों को संभालने के लिए है, मुझे लगता है कि यह अनंत छोरों के खिलाफ सुरक्षित है।

— 19

@xnor मैंने अभी के लिए पहला टिप लागू किया है। मैं अभी भी दूसरे की शुद्धता की जाँच कर रहा हूँ, लेकिन अगर यह अच्छा है तो बहुत सारे बाइट्स बच गए हैं! (इसके अलावा मैं वास्तव में आप एक समाधान पोस्ट करने की उम्मीद है: पी)

— Sp3000

और Nअब एक फ़ंक्शन तर्क के साथ, इसकी पुनरावृत्ति N-1और चेक करने के लिए कम है जब N==0इसके बजाय len(n)==N।

— xnor

@ Sp3000 मैं अब आश्वस्त हूं कि .1सुरक्षित है; यदि आप चाहें तो मैं आपसे एक बहस कर सकता हूँ।

— xnor

Answer 2

ECLiPSe प्रस्ताव - 118 (138-20)

मैंने Prolog के निम्नलिखित कार्यान्वयन का उपयोग किया: http://eclipseclp.org/

:-lib(util).
t(0,S,[]):-!,S<0.00001,S> -0.00001.
t(N,S,[X|Y]):-A is integer(ceiling(S*S)),between(1,A,X),M is N-1,T is S-sqrt(X),t(M,T,Y).

यह एक बहुत ही भोली, घातीय दृष्टिकोण है। सभी संभावित समाधानों को सूचीबद्ध करने में सभी संयोजनों को कवर करने में समय लगता है ( संपादित करें : विज़िट किए गए पूर्णांकों की सीमा अब प्रत्येक चरण पर घट जाती है, जो बहुत सारे बेकार संयोजनों को हटा देती है)।

यहाँ एक परीक्षण सत्र की प्रतिलेख इस प्रकार है। डिफ़ॉल्ट रूप से, पर्यावरण सभी संभावित समाधान (-10) और "नहीं" प्रिंट करने का प्रयास करेगा जब वह ऐसा करने में विफल हो (-10)।

जैसा कि Sp3000 ने टिप्पणी में ठीक से उल्लेख किया है, यह सफल होने पर "हां" भी छापता है। निश्चित रूप से इसका मतलब है कि मैं 10 और अंक निकाल सकता हूं ;-)

[eclipse 19]: t(1,0.5,R).

No (0.00s cpu)
[eclipse 20]: t(2,3.414213562373095,R).

R = [2, 4]
Yes (0.00s cpu, solution 1, maybe more) ? ;

R = [4, 2]
Yes (0.00s cpu, solution 2, maybe more) ? ;

No (0.01s cpu)
[eclipse 21]: t(3,7.923668178593959,R).

R = [6, 7, 8]
Yes (0.02s cpu, solution 1, maybe more) ? ;

R = [6, 8, 7]
Yes (0.02s cpu, solution 2, maybe more) ? ;

R = [7, 6, 8]
Yes (0.02s cpu, solution 3, maybe more) ? 
[eclipse 22]: t(5,5.0,R).

R = [1, 1, 1, 1, 1]
Yes (0.00s cpu, solution 1, maybe more) ? ;
^C

interruption: type a, b, c, e, or h for help : ? abort
Aborting execution ...
Abort
[eclipse 23]: t(5,13.0,R).

R = [1, 1, 1, 1, 81]
Yes (0.00s cpu, solution 1, maybe more) ? ;

R = [1, 1, 1, 4, 64]
Yes (0.00s cpu, solution 2, maybe more) ? ;

R = [1, 1, 1, 9, 49]
Yes (0.00s cpu, solution 3, maybe more) ?
[eclipse 24]:

---

(संपादित करें) प्रदर्शन के बारे में, यह अन्य लोगों की तुलना में काफी अच्छा है, कम से कम (उदाहरण के लिए इस टिप्पणी FryAmTheEggman से देखें )। सबसे पहले, यदि आप सभी परिणाम प्रिंट करना चाहते हैं, तो निम्नलिखित विधेय जोड़ें:

    p(N,S):-t(N,S,L),write(L),fail.
    p(_,_).

(5,13.0) मामले के लिए http://pastebin.com/ugjfEHpw देखें , जो 0.24 सेकंड में पूरा होता है और 495 समाधान ढूंढता है (लेकिन शायद मुझे कुछ समाधान याद आ रहे हैं, मुझे नहीं पता)।

Comments

यह भी सफल होने पर "हाँ" प्रिंट करता है! ओह प्रोलॉग।

— Sp3000

Answer 3

Erlang, 305-10 302-10

f(M,D)->E=round(D*D),t(p(E,M,1),{M,E,D}).
p(_,0,A)->A;p(E,N,A)->p(E,N-1,A*E).
t(-1,_)->"No";t(I,{N,E,D}=T)->L=q(I,N,E,[]),V=lists:sum([math:sqrt(M)||M<-L])-D,if V*V<0.1e-9->lists:flatten([integer_to_list(J)++" "||J<-L]);true->t(I-1,T)end.
q(I,1,_,A)->[I+1|A];q(I,N,E,A)->q(I div E,N-1,E,[I rem E+1|A]).

यह फ़ंक्शन स्ट्रिंग "नहीं" या रिक्त स्थान द्वारा अलग किए गए मानों के साथ एक स्ट्रिंग देता है। यह (अक्षमता से) हर संभव मूल्यों को एक बड़े पूर्णांक में एन्कोडिंग करने की प्रक्रिया करता है, और उच्च मूल्यों के साथ शुरू होता है। समाधान में 0 की अनुमति नहीं है, और एन्कोडेड 0 सभी का प्रतिनिधित्व करता है। त्रुटि चुकता है।

उदाहरण:

f(1,0.5).               % returns "No"
f(2,3.414213562373095). % returns "4 2 "
f(3,7.923668178593959). % returns "8 7 6 "
f(5,5.0).               % returns "1 1 1 1 1 "
f(5,13.0).              % returns "81 1 1 1 1 "

कृपया f(5,13.0)फ़ंक्शन के साथ धैर्य रखें क्योंकि खोज स्थान 13 ^ 10 है। इसे 2 अतिरिक्त बाइट्स के साथ तेज किया जा सकता है।

Answer 4

पायथन 3 2: 173 159 - 10 = 149

स्पष्टीकरण: प्रत्येक समाधान x 1 x 2 के रूप का है ... x_n 1 <= x_1 <= x ^ 2 के साथ जहां x लक्ष्य राशि है। इसलिए हम बेस x ^ 2 में पूर्णांक के रूप में प्रत्येक समाधान को एन्कोड कर सकते हैं। जबकि लूप सभी (x ^ 2) ^ n संभावनाओं पर निर्भर करता है। फिर मैं पूर्णांक को वापस रूपांतरित करता हूं और योग का परीक्षण करता हूं। बहुत सीधा।

i=input;n=int(i());x=float(i());m=int(x*x);a=m**n
while a:
 s=[a/m**b%m+1for b in range(n)];a-=1
 if abs(x-sum(b**.5for b in s))<1e-5:print' '.join(map(str,s))

यह सभी समाधानों को ढूंढता है, लेकिन अंतिम परीक्षण का मामला बहुत लंबा होता है।

Answer 5

जावास्क्रिप्ट (ईएस 6) 162 (172 - 10) 173

थोड़ा छोटा, थोड़ा धीमा संपादित करें ।

2 मापदंडों के साथ एक फ़ंक्शन के रूप में, जावास्क्रिप्ट कंसोल के लिए आउटपुट। यह सभी समाधानों को बिना किसी पुनरावृत्ति के हल करता है (समाधान ट्यूपल्स पहले से ही उत्पन्न होते हैं)।
मैंने चार बार गणना के बारे में अधिक ध्यान रखा, ताकि मानक जावास्क्रिप्ट समय सीमा के भीतर एक ब्राउज़र कंसोल में इसका आसानी से परीक्षण किया जा सके।

(फरवरी २०१६ अपडेट) पिछले परीक्षण मामले के लिए वर्तमान समय: लगभग १५० सेकंड । स्मृति आवश्यकताएँ: नगण्य।

F=(k,t,z=t- --k,r=[])=>{
  for(r[k]=z=z*z|0;r[k];)
  { 
    for(;k;)r[--k]=z;
    for(w=t,j=0;r[j];)w-=Math.sqrt(r[j++]);
    w*w<1e-12&&console.log(r.join(' '));
    for(--r[k];r[k]<1;)z=--r[++k];
  }
}

ES 5 संस्करण कोई भी ब्राउज़र

function F(k,t)
{
  var z=t- --k,r=[];  
  for(r[k]=z=z*z|0;r[k];)
  {
    for(;k;)r[--k]=z;
    for(w=t,j=0;r[j];)w-=Math.sqrt(r[j++]);
    w*w<1e-12&&console.log(r.join(' '));
    for(--r[k];r[k]<1;)z=--r[++k];
  }
}

टेस्ट स्निपेट यह किसी भी हाल के ब्राउज़र पर चलना चाहिए

F=(k,t)=>
{
   z=t- --k,r=[];
   for(r[k]=z=z*z|0;r[k];)
   { 
      for(;k;)r[--k]=z;
      for(w=t,j=0;r[j];)w-=Math.sqrt(r[j++]);
      w*w<1e-12&&console.log(r.join(' '));
      for(--r[k];r[k]<1;)z=--r[++k];
   }
}

console.log=x=>O.textContent+=x+'\n'

t=~new Date
console.log('\n2, 3.414213562373095')
F(2, 3.414213562373095)
console.log('\n5, 5')
F(5, 5)
console.log('\n3, 7.923668178593959')
F(3, 7.923668178593959)
console.log('\n5, 13')
F(5, 13)

t-=~new Date
O.textContent = 'Total time (ms) '+t+ '\n'+O.textContent

<pre id=O></pre>

( संपादित करें ) नीचे मेरे पीसी पर परिणाम हैं जब मैंने 15 महीने पहले यह उत्तर पोस्ट किया था। मैंने आज कोशिश की और यह एक ही पीसी पर 100 गुना तेज है, फायरफॉक्स के 64 बिट अल्फा संस्करण के साथ (और क्रोम अच्छी तरह से पीछे है)! - फ़ायरफ़ॉक्स 40 अल्फा 64 बिट के साथ वर्तमान समय: ~ 2 सेकंड, क्रोम 48: ~ 29 सेकंड

आउटपुट (मेरे पीसी पर - अंतिम संख्या मिलीसेकंड में रनटाइम है)

2 4
1 1 1 1 1
6 7 8
1 1 1 1 81
1 1 1 4 64
1 1 1 9 49
1 1 4 4 49
1 1 1 16 36
1 1 4 9 36
1 4 4 4 36
1 1 1 25 25
1 1 4 16 25
1 1 9 9 25
1 4 4 9 25
4 4 4 4 25
1 1 9 16 16
1 4 4 16 16
1 4 9 9 16
4 4 4 9 16
1 9 9 9 9
4 4 9 9 9
281889

Answer 6

गणितज्ञ - 20६ - २० = ५६

f[n_,x_]:=Select[Union[Sort/@Range[x^2]~Tuples~{n}],Abs[Plus@@√#-x]<10^-12&]

उदाहरण

f[2, 3.414213562373095]
> {{2, 4}}
f[3, 7.923668178593959]
> {{6, 7, 8}}
f[3, 12]
> {{1, 1, 100}, {1, 4, 81}, {1, 9, 64}, {1, 16, 49}, {1, 25, 36}, {4, 4, 64}, {4, 9, 49}, {4, 16, 36}, {4, 25, 25}, {9, 9, 36}, {9, 16, 25}, {16, 16, 16}}

Comments

यह कैसे छपता है No? इसके अलावा, आउटपुट स्पेस अलग नहीं है। इसके अलावा, आप के Tr@बजाय का उपयोग नहीं कर सकते Plus@@? और अगर आप को बदल कर कुछ पात्रों को बचाने के लिए सक्षम हो सकता है Selectके लिए Casesएक पैटर्न के अंत में, समारोह, और बनाने fएक अनाम शुद्ध कार्य करते हैं।

— मार्टिन एंडर

Answer 7

हास्केल, 87 80 - 10 = 70

यह @ Sp3000 के पायथन 3 कार्यक्रम के समान एक पुनरावर्ती एल्गोरिदम है। इसमें एक इन्फिक्स फ़ंक्शन होता है #जो सभी समाधानों के सभी क्रमपरिवर्तन की एक सूची देता है।

0#n=[[]|n^2<0.1^12]
m#n=[k:v|k<-[1..round$n^2],v<-(m-1)#(n-fromInteger k**0.5)]

102 99 92 - 10 = 82 के स्कोर के साथ हम प्रत्येक समाधान को केवल एक बार प्रिंट कर सकते हैं:

0#n=[[]|n^2<0.1^12]
m#n=[k:v|k<-[1..round$n^2],v<-(m-1)#(n-fromInteger k**0.5),m<2||[k]<=v]

Answer 8

पायथ 55 54 47-20 = 27

DgGHKf<^-Hsm^d.5T2^10_12^r1hh*HHGR?jbmjdkKK"No

इसे ऑनलाइन आज़माएं।

बेशर्मी से xnor की टिप्पणी से उधार ;)

यह किसी भी मूल्य की तरह भी किसी भी कंप्यूटर पर स्मृति से बाहर चला जाएगा 5,5.0। एक फ़ंक्शन को परिभाषित करता है, gजिसे कहा जा सकता है g 3 7.923668178593959।

यह पायथन 3 प्रोग्राम अनिवार्य रूप से एक ही एल्गोरिथ्म का उपयोग करता है (बस अंत में "नहीं" मुद्रण नहीं करता है, जो सभी परिणामों को एक चर असाइन करके किया जा सकता है, फिर लेखन print(K if K else "No")), लेकिन एक जनरेटर का उपयोग करता है, इसलिए यह नहीं करता है ' टी को मेमोरी त्रुटि मिलती है (यह अभी भी बहुत लंबा समय लेगा, लेकिन मैंने इसे प्रिंट किया है क्योंकि यह मान पाता है):

इसने ठीक वही परिणाम दिए जो @ Sp3000 को मिले। इसके अलावा, इसे पूरा करने में कई दिन लगे (मैंने इसे समय नहीं दिया, लेकिन लगभग 72 घंटे)।

from itertools import*
def g(G,H):
    for x in product(range(1,int(H*H+2)),repeat=G):
        if (H-sum(map(lambda n:n**.5,x)))**2<1e-12:print(*x)

Answer 9

पायथन 3 - 157 174 169 - 10 = 159

Edit1: आउटपुट स्वरूप को अल्पविराम से अलग करने के बजाय स्पेस-पृथक पूर्णांकों में बदल दिया। चारों ओर ब्रेसिज़ को हटाने की टिप के लिए धन्यवाद (एन, एक्स)।

Edit2: गोल्फ युक्तियाँ के लिए धन्यवाद! अगर मैं सिर्फ 1e-6 के भीतर अनुमानित समानता के लिए परीक्षण के बजाय एक == परीक्षण का उपयोग करता हूं, तो मैं एक और 9 वर्णों को काट सकता हूं, लेकिन अगर ऐसा कोई भी मौजूद हो, तो अनुमानित समाधानों को अमान्य कर देगा।

सभी संभव पूर्णांक संयोजनों को उत्पन्न करने के लिए पुनरावृत्तियों का उपयोग करता है, उम्मीद है कि कुशलता से :)

मुझे "नहीं" मुद्रण को कुशलता से जोड़ने का एक तरीका नहीं मिला है, यह हमेशा 10 से अधिक अतिरिक्त वर्ण लेने लगता है।

from itertools import*
n,x=eval(input())
for c in combinations_with_replacement(range(1,int(x*x)),n):
 if abs(sum(z**.5for z in c)-x)<1e-6:print(' '.join(map(str,c)))

Comments

आपके प्रोग्राम में गलत आउटपुट स्वरूप (रिक्त स्थान के बजाय अल्पविराम) है। इसके अलावा, आप लगभग बाइट्स को हटाकर 2 बाइट्स को शेव कर सकते हैं n,x।

— 15

मुझे लगता है SyntaxErrorजब मैं evalलाइन की कोशिश कर रहा हो रहा हूँ ...

— Sp3000

@ Sp3000: 3,7.923668178593959 दर्ज करने का प्रयास करें। आपको

— जकुबे

4 थोड़ा सुधार: from itertools import*1 की बचत होती है, को हटाने के अंतरिक्ष z**.5forकी बचत होती है 1, और हटाने []में sum(z**.5for z in c)2 की बचत होती है और दूर करने ()में if(...)1. बचाता है

— Jakube

पायथन 2 में बदलाव और n,x=input()अधिक कॉम्पैक्ट होने का उपयोग करेगा ?

— ओक्टेविया तोगामी

Answer 10

स्काला (397 बाइट्स - 10)

import java.util.Scanner
object Z extends App{type S=Map[Int,Int]
def a(m:S,i:Int)=m updated(i,1+m.getOrElse(i,0))
def f(n:Int,x:Double):Set[S]={if(n==0){if(x.abs<1e-6)Set(Map())else Set()}
else((1 to(x*x+1).toInt)flatMap{(i:Int)=>f(n-1,x-Math.sqrt(i))map{(m:S)=>a(m,i)}}).toSet}
val s=new Scanner(System.in)
f(s.nextInt,s.nextDouble)foreach{(m:S)=>m foreach{case(k,v)=>print(s"$k "*v)};println}}

यदि कोई क्रमपरिवर्तन नहीं हैं, तो यह कार्यक्रम कुछ भी नहीं छापता है।