वह प्रोग्राम लिखें जो Erdős-Straus अनुमान को सत्यापित करता है

Question

प्रोग्राम लिखें, जो Erdős-Straus अनुमान को सत्यापित करता है ।
कार्यक्रम एक पूर्णांक इनपुट के रूप में लेना चाहिए n( 3 <= n <= 1 000 000) और पहचान को संतोषजनक पूर्णांकों का ट्रिपल प्रिंट 4/n = 1/x + 1/y + 1/z, 0 < x < y < z।

सबसे छोटा कोड जीतता है।

कुछ उदाहरण:

3 => {1, 4, 12}
4 => {2, 3, 6}
5 => {2, 4, 20}
1009 => {253, 85096, 1974822872}
999983 => {249996, 249991750069, 62495875102311369754692}
1000000 => {500000, 750000, 1500000}

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

Comments

क्या कार्यक्रम को हर संभव समाधान या केवल एक ही आउटपुट की आवश्यकता है? उदाहरण के लिए n = 5 के लिए 2 संभावनाएँ हैं।

— izlin

केवल एक ही काफी है।

— सोमनियम

यह कुछ भ्रामक है कि आपका एकमात्र परीक्षण मामला युक्ति के अनुसार मान्य इनपुट नहीं है।

— पीटर टेलर

मैं इसे बदल दूंगा, उदाहरण में जोड़ा गया Durron597।

— सोमनियम

मैंने उस उदाहरण को जोड़ा क्योंकि मेरे शोध ने सुझाव दिया कि यह करना विशेष रूप से कठिन था। सबसे कठिन प्रमेय हैं जो {1, 121, 169, 289, 361, 529}modulo 840 के लिए

— बधाई हैं।

Answer 1

रूबी, 119 106 अक्षर

f=->s,c,a{m=s.to_i;c<2?m<s||(p a+[m];exit):(1+m...c*s).map{|k|f[s/(1-s/k),c-1,a+[k]]}}
f[gets.to_r/4,3,[]]

कोड प्रत्येक चर के लिए न्यूनतम सीमा का उपयोग करता है, उदाहरण के लिए n/4<x<3n/4, इसी तरह y। यहां तक ​​कि अंतिम उदाहरण तात्कालिक ( यहां प्रयास करें ) देता है।

उदाहरण:

> 12
[4, 13, 156]

> 123
[31, 3814, 14542782]

> 1234
[309, 190654, 36348757062]

> 40881241801
[10220310451, 139272994276206121600, 22828913614743204775214996005450198400]

Comments

शांत समाधान, हालांकि सीमाएं थोड़ी तंग हैं, क्योंकि 1 000 000 के लिए आपका कार्यक्रम अधिक समाधान पाता है (मेरा उदाहरण देखें)।

— सोमनि

@ user2992539 मेरा कोड lexicographically पहला समाधान (250001 <500000) देता है।

— हावर्ड

Answer 2

गणितज्ञ 62

यह सादे-वेनिला समाधान ठीक काम करता है - ज्यादातर समय।

f@n_ := FindInstance[4/n == 1/x + 1/y + 1/z && 0 < x < y < z, {x, y, z}, Integers]

उदाहरण और समय (सेकेंड में)

AbsoluteTiming[f[63]]
AbsoluteTiming[f[123]]
AbsoluteTiming[f[1003]]
AbsoluteTiming[f[3003]]
AbsoluteTiming[f[999999]]
AbsoluteTiming[f[1000000]]

{0.313671, {{x -> 16, y -> 1009, z -> 1017072}}}
{0.213965, {{x -> 31, y -> 3814, z -> 14542782}}}
{0.212016, {{x -> 251, y -> 251754, z -> 63379824762}}}
{0.431834, {{x -> 751, y -> 2255254, z -> 5086168343262}}}}
{1.500332, {{x -> 250000, y - > 249999750052, z -> 1201920673328124750000}}}
{1.126821, {{x -> 375000, y -> 1125000, z -> 2250000}}}

---

लेकिन यह एक पूर्ण समाधान नहीं है। कुछ संख्याएँ हैं जिन्हें वह हल नहीं कर सकता है। उदाहरण के लिए,

AbsoluteTiming[f[30037]]
AbsoluteTiming[f[130037]]

{2.066699, FindInstance [4/30037 == 1 / x + 1 / y + 1 / z && 0 <x <y <z, {x, y, z}, Integers]}
{1.981802, FindInstance [4/130037 = = 1 / x + 1 / y + 1 / z && 0 <x <y <z, {x, y, z}, Intex]}

Comments

सही काम के लिए सही उपकरण। +1

— विलियम बारबोसा

@WilliamBarbosa मैं तर्क दूंगा कि FindInstanceयह सही उपकरण नहीं है क्योंकि यह परिणाम की गारंटी नहीं दे सकता है ...

— हावर्ड

@ हॉवर्ड मैं मैथेमेटिका के बारे में बात कर रहा था, वास्तव में

— विलियम बारबोसा

Reduceजिद्दी मामलों को हल करने में लगता है, हालांकि इसमें अक्सर समय लगता है। उदा 15 मिनट n = 10037 के लिए 82 समाधान खोजने के लिए।

— डेविड जुएल

Answer 3

सी#

अस्वीकरण: यह एक गंभीर जवाब नहीं है

यह सिर्फ 1 से 1 << 30 तक सभी संभावनाओं को पूरा करता है। यह बहुत बड़ा है, यह धीमा है, मुझे यह भी नहीं पता कि यह सही ढंग से काम करता है या नहीं, लेकिन यह विनिर्देशों का अक्षरशः पालन करता है, क्योंकि यह हर बार स्थिति की जांच करता है, इसलिए यह अच्छा है। मैंने इसका परीक्षण नहीं किया है क्योंकि ideone के पास कार्यक्रमों के लिए 5 सेकंड की समय सीमा है और इसलिए यह निष्पादन को पूरा नहीं करेगा।

(अगर कोई सोच रहा था: यह एक लंबा 308 बाइट्स है )

static double[]f(double n)
{
    for(double x=1;x<1<<30;x++)
    {
        for(double y=1;y<1<<30;y++)
        {
            for(double z=1;z<1<<30;z++)
            {
                if(4/n==1/x+1/y+1/z)
                    return new[]{x,y,z};
            }
        }
    }
    return null;
}

अपडेट: इसे ठीक कर दिया ताकि यह वास्तव में काम करे

Comments

काम नहीं करता है (संकेत: पूर्णांक विभाजन)।

— हावर्ड

राउंड-ऑफ त्रुटियों के कारण संभवतः यह काम नहीं करेगा।

— सोमनियम

@ user2992539 यह मेरे लिए काम करता है, मैंने इसे 5इनपुट के रूप में परीक्षण किया और इसने सही परिणाम दिया ( 2, 4, 20)

— क्रिस्टोफ बोम्हवालडर

@HackerCow बड़े पूर्णांक के लिए काम नहीं कर सकता है।

— सोमनीम जूल

@HackerCow आप निश्चित रूप से y = x + 1 और z = y + 1 से शुरू करके समय बचा सकते हैं। संभवत: बराबर चेक 4xyz = n (xy + yz + xz) का उपयोग करना तेज़ होगा, हालांकि मैं स्वीकार करता हूं कि यह एक लंबी अभिव्यक्ति है और इसमें गोलाई की समस्या भी है।

— एल्काइमेस्ट

Answer 4

पायथन 2 , 171 बाइट्स

from sympy import*
def f(n):
 for d in xrange(1,n*n):
  for p in divisors(4*d+n*n):
   q=(4*d+n*n)/p;x=(n+p)/4;y=(n+q)/4
   if (n+p)%4+(n+q)%4+n*x*y%d<1:return x,y,n*x*y/d

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

पहले उत्तर में पर्याप्त तेजी से परीक्षण किया जाना चाहिए। यह सभी 3 ≤ के लिए समाधान खोजने के लिए सक्षम है n में के बारे में 24 मिनट ≤ 1000000 कुल , लगभग 1.4 मिलीसेकंड प्रत्येक के एक औसत के लिए।

यह काम किस प्रकार करता है

4 / n = 1 / x + 1 / y + 1 / z को फिर से लिखें z = n · x · y / d , जहाँ d = 4 · x · y - n · x - n · y के । फिर हम 4 · d + n ² = (4 · x - n ) · (4 · y - n ) कर सकते हैं, जो हमें x की खोज करने के लिए बहुत तेज़ तरीका देता है और छोटा होता है। दिया गया एक्स y लंबे समय के रूप के रूप में घ < y < z , हम कम से कम साबित कर सकते हैं घ <3 · एन ²/ 4 (इसलिए बाहरी लूप पर बाध्य), हालांकि व्यवहार में यह बहुत छोटा हो जाता है - 95% समय, हम d = 1, 2 या 3 का उपयोग कर सकते हैं । सबसे खराब स्थिति n है = 769129 है, जिसके लिए सबसे छोटा डी 1754 है (इस मामले में लगभग 5 साल लगते हैं)।

Answer 5

गणितज्ञ, 99 बाइट्स

f[n_]:=(x=1;(w=While)[1>0,y=1;w[y<=x,z=1;w[z<=y,If[4/n==1/x+1/y+1/z,Return@{x,y,z}];++z];++y];++x])

यह काफी भोली शक्ति है, इसलिए यह वास्तव में अच्छा नहीं है। मैं निश्चित रूप से एक मिलियन में जा रहा हूं (इसलिए इस समय के लिए इसे अमान्य मानें)। n = 100आधा n = 300सेकंड लगता है , लेकिन पहले से ही 12 सेकंड लगते हैं।

Answer 6

Golflua 75

nप्रांप्ट से पढ़ता है (टर्मिनल में मंगलाचरण के बाद), लेकिन मूल रूप से केल्विन के हल के समाधान के रूप में यह करता है:

n=I.r()z=1@1~@y=1,z-1~@x=1,y-1?4*x*y*z==n*(y*z+x*z+x*y)w(n,x,y,z)~$$$z=z+1$

उपरोक्त का एक अनगुल्ड लुआ संस्करण है

n=io.read()
z=1
while 1 do
   for y=1,z-1 do
      for x=1,y-1 do
         if 4*x*y*z==n*(y*z+x*z+x*y) then
            print(n,x,y,z)
            return
         end
      end
   end
   z=z+1
end

उदाहरण:

n=6     -->     3      4     12
n=12    -->     6     10     15
n=100   -->    60     75    100
n=1600  -->  1176   1200   1225

Answer 7

पायथन, 117

n=input();r=range;z=0
while 1:
 z+=1
 for y in r(z):
  for x in r(y):
    if 4*x*y*z==n*(y*z+x*z+x*y):print x,y,z;exit()

उदाहरण:

16 --> 10 12 15

कुछ खास नहीं।

Comments

यदि आप केवल एक बार कॉल करने जा रहे हैं तो आप किसी फ़ंक्शन को क्यों परिभाषित करते हैं?

— isaacg

@isaacg इसे किसी तरह रोकने की जरूरत है, लेकिन exit()इसके बजाय इसका उपयोग छोटा कर देता है।

— केल्विन के

Answer 8

सी # - 134

खैर, मैंने पहले यहां एक उत्तर पोस्ट किया था, लेकिन यह वास्तव में इतना गंभीर नहीं था। जैसा कि ऐसा होता है, मैं बहुत बार बहुत बोर हो जाता हूं, इसलिए मैंने इसे थोड़ा-थोड़ा कर लिया।

यह सभी उदाहरणों को तकनीकी रूप से सही ढंग से गणना करता है (मैंने अंतिम दो की कोशिश नहीं की है, क्योंकि, फिर से, विचारधारा 5 सेकंड की समय सीमा को प्रभावित करती है), लेकिन पहले वाले सही परिणाम देते हैं (जरूरी नहीं कि आपके द्वारा गणना की गई परिणाम, लेकिन एक सही है)। यह अजीब रूप से संख्या को क्रम से बाहर करता है (मुझे कोई सुराग क्यों नहीं है) और यह देता है10, 5, 2 के लिए 5(जो विकिपीडिया के अनुसार एक वैध जवाब है)।

अभी के लिए 134 बाइट्स, मैं शायद इसे थोड़ा और ऊपर गोल्फ कर सकता था।

float[]f(float n){float x=1,y,z;for(;x<1<<30;x++)for(y=1;y<x;y++)for(z=1;z<y;z++)if(4/n==1/x+1/y+1/z)return new[]{x,y,z};return null;}

Answer 9

हास्केल - 150 वर्ण

main = getLine >>= \n -> (return $ head $ [(x,y,z) | x <- [1..y], y <- [1..z], z <- [1..], (4/n') == (1/x) + (1/y) + (1/z)]) where n' = read n

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