9

मैं अपने एक दोस्त के साथ गणित के सवाल पर काम कर रहा था, और हमने एक स्क्रिप्ट लिखने का फैसला किया, जिसका जवाब मिल जाए। मूल प्रश्न इस प्रकार है:

दो प्राकृतिक संख्याओं का अंतर 2010 है और उनका सबसे बड़ा सामान्य भाजक 2014 के उनके सबसे छोटे सामान्य गुणा से छोटा है। सभी संभव समाधान खोजें।

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

from fractions import*;print[i for i in range(10**6)if i*(i+2010)/gcd(i,i+2010)**2==2014]

हम यह देखना चाहते थे कि क्या कोई छोटा कोड लिखता है, जो पहले 1 मिलियन i की गणना करता है। यदि आप प्रतिस्पर्धा करने के लिए पर्याप्त बहादुर हैं, तो आप अपनी पसंद की किसी भी भाषा का उपयोग कर सकते हैं, लेकिन हम आपके साथ अपने कोड की तुलना करने में सक्षम होने के लिए पायथन 2 को प्राथमिकता देंगे।

सामान्य नियम लागू होते हैं, कम से कम बाइट्स जीतते हैं। मानक कोड गोल्फ कमियां लागू होते हैं। मानक "कमियां" जो अब मजाकिया नहीं हैं

मज़े करो!

code-golf math

— sammko
स्रोत

2

@ रैनबोल्ट: ठीक है, किसी भी भाषा की अनुमति है। अजगर सीमा तुलना उद्देश्यों के लिए था। लेकिन आप जो चाहें करें: D

— sammko

क्या 3 और 5092 के अलावा अन्य उत्तर हैं? 10,000,000 से पहले कुछ और नहीं खोज सकते।

— kennytm

@ केनीटीएम: मुझे 4 और 5092 मिले। और हां, मुझे नहीं लगता कि कोई अन्य हैं।

— संस्कारो

अरे, मैंने आपके शीर्षक को बेहतर तरीके से प्रतिबिंबित करने के लिए संपादित किया है कि आप क्या पूछ रहे हैं। अगर आपको लगता है कि मुझे कुछ याद आया तो इसे बदलने के लिए स्वतंत्र महसूस करें।

— FryAmTheEggman 22

रास्ते से अजगर टैग हटा दिया।

— टाइमटेक

21

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

{4,5092}

सबूत है कि 4 और 5092 एकमात्र समाधान हैं: मूल समस्या को फिर से लिखा जा सकता है

x (x + 2010) = 2014 GCD (x, x + 2010) ²

आइए x को 2 ^{a ₂} 3 ^{a ₃} 5 ^{a ₅} … और x + 2010 को 2 ^{b ₂} 3 ^{b ₃} 5 ^{b ₅} … के रूप में लिखें।

2 ^{एक ₂ + b ₂} 3 ^{एक ₃ + बी ₃} 5 ^{एक ₅ + बी ₅} ... = 2014 2 ^{2 मिनट (एक ₂ , बी ₂ )} 3 ^{2 मिनट (एक ₃ , बी ₃ )} 5 ^{2 मिनट (एक ₅ , बी ₅ )} ...

2014 = 2 × 19 × 53 के बाद से हमारे पास है

a _p + b _p = 2min (a _p , b _p ) + {1 यदि p b {2, 19, 53}, 0 +}

इस प्रकार

a _p = b _p यदि p, 2, 19, 53
a _p = b _p। 1 और

इस प्रकार

x + 2010 = 2 ^{± 1} 19 2010 ¹ 53। ¹ x

केवल 8 संभावित विकल्प हैं, और हम आसानी से जांच सकते हैं कि 4 और 5092 एकमात्र सकारात्मक पूर्णांक समाधान हैं।

रुको, मैंने सुना है कि लोग मानक खामियों को चिल्ला रहे हैं ...

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

Select[Range[9^7],2014GCD[#,s=#+2010]^2==s#&]

— kennytm
स्रोत

4

अजगर 27 25

J2010fq+J4/*T+TJ^iTJ2U^T6

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

यह आपके एल्गोरिथ्म को काफी भोलेपन से उपयोग करता है ... मैं कुछ बेहतर करने में सक्षम हो सकता हूं ...

मूल रूप से उन मानों को फ़िल्टर करता है जो मानदंड से पूरा नहीं करते हैं range(10**6)

चैट में इंगित करने के लिए @xnor को धन्यवाद gcd(x,x+2010)==gcd(x,2010)

— FryAmTheEggman
स्रोत

3

पायथन 3, 84 बाइट्स

FryAmTheEggman का पहले से ही सुझाव है कि कैसे अपने समाधान 88 बाइट्स बनाने के लिए तो मैं यह पोस्ट नहीं करेंगे। लेकिन मैंने सोचा कि मैं दिखाऊंगा कि आप पायथन 3 में भी कैसे कम बाइट पा सकते हैं:

from fractions import*
x=10**6
while x:y=x+2010;x*y-gcd(x,y)**2*2014or print(x);x-=1

(सुझावों के लिए FryAmTheEggman के लिए धन्यवाद)

यह पायथन 2 में काम नहीं करता है क्योंकि printएक फ़ंक्शन नहीं है।

मुझे यकीन नहीं है कि अगर हमें अनुमति है, लेकिन अगर हम 9**9इसके बजाय उपयोग कर सकते हैं तो 10**6एक और बाइट होगी।

— Sp3000
स्रोत

मुझे पता था कि इसके साथ ऐसा करने का एक तरीका है ... and/ orहालांकि अजगर 3 के बारे में नहीं सोचा होगा;) विषय पर अधिक: यदि आदेश कोई फर्क नहीं पड़ता, मुझे लगता है कि सेटिंग करना x=10**6और करना while x:x-=1;...एक बाइट कम है।

— FryAmTheEggman

@FryAmTheEggman प्रश्न के लुक से ऐसा नहीं लगता है कि ऑर्डर मायने रखता है इसलिए मैं इसमें डालूँगा, धन्यवाद!

— Sp3000

2

आर, 75 चार्ट

for(a in 1:1e6){q=1:a;b=a+2010;if(a*b/max(q[!a%%q&!b%%q])^2==2014)print(a)}

लाइन ब्रेक के साथ:

for(a in 1:1e6){
    q=1:a
    b=a+2010
    if(a*b/max(q[!a%%q&!b%%q])^2==2014)print(a)
    }

— plannapus
स्रोत

2

गोल्फस्क्रिप्ट (41 बाइट्स)

दो प्राकृतिक संख्याओं का अंतर २०१० है और उनका सबसे बड़ा सामान्य भाजक २०१४ उनके सबसे छोटे सामान्य गुणकों से छोटा है। सभी संभव समाधान खोजें।

नंबरों पर कॉल करें amऔर bmकहां gcd(a, b) = 1और कैसे वॉगिंग करें b > a। फिर अंतर है m(b-a) = 2010, और lcm(am, bm) = abm = 2014mइसलिए ab=2014।

2014 के कारक हैं

और जो मतभेद हैं जो 2010 में विभाजित हैं

1007 - 2 => m = 2, solution is 4, 2014
53 - 38 => m = 134, solution is 5092, 7102

चूंकि मैं एक ऐसी भाषा में काम कर रहा हूं जिसमें बिल्ट-इन जीसीडी या एलसीएम नहीं है, मुझे लगता है कि यह विश्लेषण शायद कार्यक्रम को छोटा करता है:

44,{).2014{.2$/\@%!}:,~\2$- 2010,***}%0-`

जहां 44है floor(sqrt(2014))।

भोले पाश का उपयोग करके काफी करीब आना संभव है:

10 6?,1>{.2010+.2${.@\%.}do;.*2014*@@*=},`

— पीटर टेलर
स्रोत

तो @ केटीटीएमएम का प्रमाण (4,5092) एकमात्र समाधान गलत है?

— ऑप्टिमाइज़र

@Optimizer, आप इसे गलत बता रहे हैं। वह यह भी साबित करता है कि दो समाधान हैं, और वे मेरे समाधान के समान हैं। उसका प्रमाण मेरा (IMAO) की तुलना में बहुत कठिन है।

— पीटर टेलर

आह, सच। और हाँ, तुम्हारा उससे अधिक अर्थ है।

— ऑप्टिमाइज़र

2

पर्ल 6 61 58 56 54 52

आपके स्रोत का काफी प्रत्यक्ष अनुवाद देता है

for ^10**6 ->\i{i.say if i*(i+2010)/(i gcd(i+2010))**2==2014}

gcd Perl6 में एक infix op है।

^10**6के लिए कम है 0 ..^ 10**6, जहां ^इस सीमा को सीमा से बाहर रखा गया है।

बेशक i gcd (i+2010)एक ही है i gcd 2010इसलिए मैं 3 पात्रों को बचा सकता हूं

for ^10**6 ->\i{i.say if i*(i+2010)/(i gcd 2010)**2==2014}

यदि मैं $_इसके बजाय का उपयोग करता हूं तो मैं iएक और जोड़े को बचा सकता हूं। (के .sayलिए कम है $_.say)

for ^10**6 {.say if $_*($_+2010)/($_ gcd 2010)**2==2014}

मैं ... && .sayइसके बजाय का उपयोग करके वर्णों के एक और जोड़े को बचा सकता हूं .say if ..., क्योंकि मुझे उस &&तरह के दोनों पक्षों पर जगह की आवश्यकता नहीं है जैसे मैं करता हूं if।

for ^10**6 {$_*($_+2010)/($_ gcd 2010)**2==2014&&.say}

चूँकि मैंने पिछले दोनों "अनुकूलन" किए थे, इसलिए मैं बयान संशोधक रूप का उपयोग कर सकता हूं for, जिसका अर्थ है कि मैं हटा सकता हूं {और }।

$_*($_+2010)/($_ gcd 2010)**2==2014&&.say for ^10**6

मुझे लगता है कि मैं एक अलग एल्गोरिथ्म का उपयोग किए बिना जा सकता हूं जितना छोटा है।

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

जे, 26 बाइट्स

   I.((*.=+.*4--)2010+])i.1e6
4 5092

उन शापित 2-बाइट क्रिया ... :)

— randomra
स्रोत

1

दिल्लोग एपीएल, 29 अक्षर

      a←⍳10        ⍝ the integers up to 10
      a
1 2 3 4 5 6 7 8 9 10
      2010+a       ⍝ corresponding integers at distance 2010
2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
      a∨2010+a     ⍝ GCD-s between elements of a and 2010+a
1 2 3 2 5 6 1 2 3 10
      ⍝ All APL functions (e.g. + and ∨) are prefix-or-infix, right-associative,
      ⍝ and of the same precedence.
      a∧2010+a     ⍝ LCM-s
2011 2012 2013 4028 2015 2016 14119 8072 6057 2020
      ⍝ For which of them is the LCM 2014 times the GCD?
      (a∧2010+a)=2014×a∨2010+a
0 0 0 1 0 0 0 0 0 0
      ⍝ 0 means false, 1 means true
      ⍝ Filter the elements of "a" corresponding to the 1-s
      ((a∧2010+a)=2014×a∨2010+a) / a
4
      ⍝ Let's abstract this as a function by using curlies.
      ⍝ Omega (⍵) stands for the right argument.
      {((⍵∧2010+⍵)=2014×⍵∨2010+⍵) / ⍵} a
4
      ⍝ Up to a million instead of up to ten:
      {((⍵∧2010+⍵)=2014×⍵∨2010+⍵) / ⍵} ⍳1e6
4 5092
      ⍝ Hey, we can save a few characters by making 2010 the left argument, alpha (⍺)
      2010 {((⍵∧⍺+⍵)=2014×⍵∨⍺+⍵) / ⍵} ⍳1e6
4 5092
      ⍝ Remove a pair of parens by using the switch operator ⍨
      ⍝ An "operator" occurs to the right of a function and modifies its behaviour.
      ⍝ In this case A f⍨ B means the same as B f A
      ⍝ Left and right are swapped, hence "switch".
      2010 {⍵ /⍨ (⍵∧⍺+⍵)=2014×⍵∨⍺+⍵)} ⍳1e6
4 5092
      ⍝ That's 32 characters (modulo whitespace).  Not bad, but we can do better.
      ⍝ A "fork" is a sequence of 3 functions in isolation: f g h
      ⍝ It is evaluated as:  ⍺(f g h)⍵  ←→  (⍺ f ⍵)g(⍺ h ⍵)
      ⍝ If the first item is an array instead of a function: A f g  ←→  {A} f g
      ⍝ Forks are right-associative: f g h k l ←→ f g (h k l)
      2010 {⍵ /⍨ (⍺(⊢∧+)⍵)=2014×(⍺(⊢∨+)⍵)} ⍳1e6
4 5092
      ⍝ The "right tack" function (⊢) simply returns its right argument
      ⍝ Let's abuse forks a little further:
      2010 {⍵ /⍨ ⍺((⊢∧+)=(2014×(⊢∨+)))⍵} ⍳1e6
4 5092
      ⍝ ... and more
      2010 {⍺ (⊢(/⍨)((⊢∧+)=(2014×(⊢∨+)))) ⍵} ⍳1e6
4 5092
      ⍝ But {⍺ f ⍵} is equivalent to f
      2010 (⊢(/⍨)((⊢∧+)=(2014×(⊢∨+)))) ⍳1e6
4 5092
      ⍝ Note that now we are not mentioning ⍺ and ⍵ at all.
      ⍝ This is called "point-free style" or "tacit programming".
      ⍝ Removing some unnecessary parens and whitespace:
      2010(⊢(/⍨)(⊢∧+)=2014×⊢∨+)⍳1e6
4 5092
      ⍝ How many characters?
      ⍴'2010(⊢(/⍨)(⊢∧+)=2014×⊢∨+)⍳1e6'
29

— NGN
स्रोत

1

PARI / GP, 42 बाइट्स

[n|n<-[1..8!],2014*gcd(n,t=n+2010)^2==n*t]

मुझे लगता है कि GP के fordivनिर्माण का उपयोग करते हुए एक बहुत ही सुंदर समाधान है, लेकिन यह सरासर संक्षिप्तता के लिए इस समाधान के साथ प्रतिस्पर्धा नहीं कर सकता है।

— चार्ल्स
स्रोत

0

रैकेट, 72 चार्ट

(filter(λ(i)(=(/(*(+ i 2010)i)(expt(gcd(+ i 2010)i)2))2014))(range 1e6))

— मैथ्यू बटरिक
स्रोत

1

क्या रैकेट ISO-8859-7 के साथ काम करता है? अन्यथा मुझे नहीं लगता λकि 1 बाइट के रूप में मायने रखता है।