ฉันทำงานกับคำถามทางคณิตศาสตร์กับเพื่อนของฉันและเราตัดสินใจที่จะเขียนสคริปต์ที่ค้นหาคำตอบ คำถามเดิมมีดังนี้:

ความแตกต่างของจำนวนธรรมชาติสองตัวคือ 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 ล้านตัวแรกของฉัน หากคุณกล้าพอที่จะแข่งขันคุณอาจใช้ภาษาใดก็ได้ที่คุณชอบ แต่เราอยากให้ Python 2 เปรียบเทียบโค้ดของคุณกับเราได้

ใช้กฎแบบปกติไบต์ที่สั้นที่สุดจะชนะ ใช้ช่องโหว่ของรหัสมาตรฐาน "ช่องโหว่" มาตรฐานซึ่งไม่ตลกอีกต่อไป

มีความสุข!

Mathematica ขนาด 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 ^{a ₂ + b ₂} 3 ^{a ₃ + b ₃} 5 ^{a ₅ + b ₅} … = 2014 2 2 ^{นาที (a ₂ , b ₂ )} 3 ^₂นาที^{(a ₃ , b ₃ )} 5 ^{_{2 นาที} (a ₅ , b ₅ )} ...

ตั้งแต่ 2014 = 2 × 19 × 53 เรามี

a _p + b _p = 2 นาที (a _p , b _p ) + {1 ถ้า p ∈ {2, 19, 53}, 0 อื่น}

ดังนั้น

a _p = b _pถ้า p ≠ 2, 19, 53
a _p = b _p ± 1 อื่น

ดังนั้น

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

มีเพียง 8 ตัวเลือกที่เป็นไปได้และเราสามารถตรวจสอบได้อย่างง่ายดายว่า 4 และ 5092 เป็นโซลูชั่นจำนวนเต็มบวกเท่านั้น

เดี๋ยวก่อนฉันได้ยินคนกรีดร้องช่องโหว่มาตรฐาน ...

Mathematica ขนาด 45 ไบต์

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

Pyth 27 25

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

ลองออนไลน์

นี่ใช้อัลกอริทึมของคุณอย่างไร้เดียงสา ... ฉันอาจจะคิดอะไรดีกว่า ...

โดยทั่วไปจะกรองค่าที่ไม่ตรงตามเกณฑ์ range(10**6)

ขอบคุณ @xnor ที่ชี้ให้เห็นในการแชท gcd(x,x+2010)==gcd(x,2010)

Python 3, 84 ไบต์

FryAmTheEggman แนะนำวิธีการแก้ปัญหาของคุณ 88 ไบต์ดังนั้นฉันจะไม่โพสต์สิ่งนั้น แต่ฉันคิดว่าฉันจะแสดงวิธีที่คุณสามารถรับไบต์ที่น้อยลงใน Python 3:

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

(ขอบคุณสำหรับ FryAmTheEggman สำหรับเคล็ดลับ)

สิ่งนี้ไม่ทำงานใน Python 2 เพราะprintไม่ใช่ฟังก์ชั่น

ฉันไม่แน่ใจว่าเราได้รับอนุญาต แต่ถ้าเราสามารถใช้9**9แทนที่จะ10**6เป็นไบต์อื่น

R, 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)
    }

GolfScript (41 ไบต์)

ความแตกต่างของตัวเลขธรรมชาติสองตัวคือ 2010 และตัวส่วนร่วมที่ยิ่งใหญ่ที่สุดของพวกเขาคือ 2014 มีขนาดเล็กกว่าตัวคูณร่วมที่ต่ำที่สุด ค้นหาโซลูชันที่เป็นไปได้ทั้งหมด

โทรตัวเลขamและbmที่gcd(a, b) = 1และ b > aWLOG จากนั้นความแตกต่างคือm(b-a) = 2010และlcm(am, bm) = abm = 2014mอื่นab=2014ๆ

ปัจจัยปี 2557 ได้แก่

1 * 2014
2 * 1007
19 * 106
38 * 53

และผู้ที่มีความแตกต่างที่แบ่งออกเป็น 2010 คือ

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

เนื่องจากฉันทำงานด้วยภาษาที่ไม่มี GCD หรือ LCM ในตัวฉันจึงคิดว่าการวิเคราะห์นี้อาจทำให้โปรแกรมสั้นลง:

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

ที่เป็น44floor(sqrt(2014))

เป็นไปได้ที่จะเข้ามาใกล้โดยใช้วงลูป

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

Perl6 61 58 56 54 52

การแปลแหล่งที่มาของคุณโดยตรงอย่างเป็นธรรม

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

gcd เป็น infix op ใน Perl6

^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

ฉันคิดว่ามันสั้นที่สุดเท่าที่จะทำได้โดยไม่ต้องใช้อัลกอริธึมที่แตกต่างกัน

J, 26 ไบต์

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

คำกริยา 2 ไบต์ที่สาปแช่ง ... :)

Dyalog APL, 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

PARI / GP, 42 ไบต์

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

ฉันรู้สึกว่ามีวิธีการแก้ปัญหาที่สง่างามอย่างยิ่งโดยใช้fordivโครงสร้างของ GP แต่มันไม่สามารถแข่งขันกับโซลูชันนี้เพื่อความกะทัดรัดที่แท้จริง

แร็กเก็ต, 72 ตัวอักษร

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

Haskell, 52 ตัวอักษร

show [x|x<-[1..6^8],x*(x+2010)==2014*(gcd x 2010)^2]

ทำงานในสภาพแวดล้อมแบบโต้ตอบของ Haskell GHCi