นี่คือความท้าทายของรหัสกอล์ฟที่ฉันคิดด้วยการดัดงอทางคณิตศาสตร์ ความท้าทายคือการเขียนรหัสที่สั้นที่สุดเท่าที่จะเป็นไปได้ว่าเป็นคำถามเปิดหรือไม่ว่ารหัสนั้นจะยุติลงหรือไม่ ตัวอย่างของสิ่งที่ผมหมายถึงอาจจะเป็นชิ้นส่วนของรหัสต่อไปหลามที่ดัดแปลงมาจาก Anwser ไปนี้คำถาม stackexchange cs

def is_perfect(n):
    return sum(i for i in range(1, n) if n % i == 0) == n

n = 3
while not is_perfect(n):
    n = n + 2

นักคณิตศาสตร์คาดเดาว่าไม่มีตัวเลขสมบูรณ์แบบแปลก ๆ แต่มันไม่เคยได้รับการพิสูจน์แล้วดังนั้นจึงไม่มีใครรู้ว่ารหัสชิ้นนี้จะยุติลงหรือไม่ คุณสามารถใช้โค้ดอื่น ๆ (อาจขึ้นอยู่กับปัญหาแบบเปิดอื่น ๆ เช่นการคาดคะเนโคลลาตซ์หรือการคาดคะเนสองช่วง) ที่สั้นกว่า แต่ไม่ทราบว่ายุติหรือไม่?

แก้ไข: บางคนได้นำมาเพิ่มเติมกฎที่ดี - การแก้ปัญหาสำหรับคำถามควรกำหนดขึ้น แม้ว่ามันจะน่าสนใจยิ่งขึ้นถ้าคุณสามารถหาวิธีแก้ปัญหาที่สั้นกว่าโดยใช้ nondeterminism ในกรณีนี้กฎจะค้นหาตัวอย่างที่ไม่ทราบความน่าจะเป็นของการเลิกจ้าง

เยลลี่ขนาด 7 ไบต์

!‘Ʋµ4#

ลองออนไลน์!

พื้นหลัง

วิธีนี้จะยุติลงเมื่อพบวิธีการแก้ไขปัญหาที่สี่ของปัญหาBrocardนั่นคือทางออกn! + 1 = m²ด้วย(n, m) ≠ (4, 5), (5, 11), (7, 71)เหนือจำนวนเต็มบวก การใช้งานไม่ได้ใช้เลขคณิตจุดลอยตัวดังนั้นมันจะยุติก็ต่อเมื่อมันหาวิธีที่สี่หรือถ้าn! ไม่สามารถแสดงในหน่วยความจำได้อีกต่อไป

ปัญหาของ Brocard ถูกใช้ครั้งแรกในคำตอบนี้โดย @xnor

มันทำงานอย่างไร

!‘Ʋµ4#  Main link. No arguments. Implicit argument: 0

    µ4#  Convert the links to the left into a monadic chain and call it with
         arguments k = 0, 1, 2, ... until 4 of them return 1.
!        Factorial; yield k!.
 ‘       Increment; yield k! + 1.
  Ʋ     Squareness; return 1 if k! + 1 is a perfect square, 0 if not.

เยลลี่ , 11 9 ไบต์

ÆẸ⁺‘ÆPµ6#

วิธีนี้จะยุติลงเมื่อพบแฟร์มาต์ไพร์มที่หก

ลองออนไลน์!

มันทำงานอย่างไร

ÆẸ⁺‘ÆPµ6#  Main link. No arguments. Implicit argument: 0

      µ6#  Convert the links to the left into a monadic chain and call it with
           arguments k = 0, 1, 2, ... until 6 of them return 1.
ÆẸ         Convert [k] to the integer with that prime exponent factorization, i.e.,
           into 2 ** k.
  ⁺        Repeat.
   ‘       Increment.
           We've now calculated 2 ** 2 ** k + 1.
    ÆP     Test the result for primality.

Pyth, 10 ไบต์

fP_h^2^2T5

ใช้การคาดคะเนที่ตัวเลขแฟร์มาต์ทั้งหมด 2^(2^n)+1ประกอบเข้าn>4ด้วยกัน

f        5   Find the first number T>=5 for which
   h^2^2T    2^(2^T)+1
 P_          is prime                   

Python ขนาด 36 ไบต์

k=n=1
while(n+1)**.5%1+7/k:k+=1;n*=k

ใช้ปัญหาของ Brocard :

n! +1 เป็นสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบสำหรับn≥8ไหม?

คำนวณแฟคทอเรียลต่อเนื่องและตรวจสอบว่ามันเป็นสี่เหลี่ยมและมีk>7หรือไม่ ขอบคุณเดนนิสสำหรับ 2 ไบต์!

สิ่งนี้ถือว่า Python ยังคงมีเลขคณิตที่ถูกต้องสำหรับตัวเลขขนาดใหญ่โดยพลการ ในการใช้งานจริงมันจะยุติลง

Perl, 50 38 36 34 33 ไบต์

$_=196;$_+=$%while($%=reverse)-$_

คำอธิบาย: 196 เป็นหมายเลข Lychrel ที่เป็นไปได้- ตัวเลขที่ไม่ได้สร้างรูปแบบ palindrome ด้วยการเพิ่มการย้อนกลับของมันซ้ำ ๆ การวนซ้ำดำเนินต่อไปจนกระทั่ง $ n เท่ากับย้อนกลับซึ่งยังไม่ทราบค่าเริ่มต้น 196

25 + 52 = 77

ซึ่งไม่ถูกต้อง

96 + 69 = 165
165 + 561 = 726
726 + 627 = 1353
1353 + 3531 = 4884

ดังนั้นตัวเลขในลำดับนี้จึงไม่ถูกต้อง

แก้ไข: ตีมันลงโดยใช้ลูปจนกระทั่งแทนลูป for (อย่างใด) นอกจากนี้ฉันมีไบต์น้อยกว่าที่ฉันคิด (ฉันอาจจะดูจำนวนไบต์ของฉันอย่างระมัดระวังมากขึ้นในอนาคต)

แก้ไข: แทนที่$nด้วย$_เพื่อประหยัด 2 reverseไบต์สำหรับอาร์กิวเมนต์โดยนัยใน ฉันคิดว่านี่เป็นเรื่องเกี่ยวกับกอล์ฟเท่าที่การดำเนินการนี้จะได้รับ

แก้ไข: ฉันผิด แทนการใช้until($%=reverse)==$_ฉันสามารถไปในขณะที่ความแตกต่างไม่ใช่ศูนย์ while($%=reverse)-$_(เช่นจริง):

MATL 11 ไบต์

`@QEtZq&+=z

ยุติการคาดเดาหาก Goldbachเป็นเท็จ นั่นคือโปรแกรมจะหยุดถ้าพบว่าจำนวนที่มากกว่า2นั้นไม่สามารถแสดงเป็นผลรวมของสองช่วงเวลา

`        % Do...while
  @      %   Push iteration index k. Gives 1, 2, 3, ...
  QE     %   Add 1 and multiply by 2. Gives 4, 6, 8, ...
  tZq    %   Duplicate. Push all primes up to current k
  &+     %   Matrix with all pairwise additions of those primes
  =z     %   Number of entries of that matrix that equal k. This is used as loop
         %   condition. That is, the loop continues if this number is nonzero
         % Implicit end

05AB1E , 8 ไบต์

จะยุติลงเมื่อพบแฟร์มาต์ที่ 6

5µNoo>p½

คำอธิบาย

5µ          # loop over increasing N (starting at 1) until counter reaches 5
  Noo       # 2^2^N
     >      # + 1
      p½    # if prime, increase counter

Python ขนาด30 28 ไบต์

n=2
while 2**~-n%n**3-1:n+=1

โปรแกรมนี้จะหยุดถ้าหากมีจำนวนเต็ม n มากกว่า 1 เช่นนั้น 2 ^ (n-1) -1 จะหารด้วย n ^ 3 ความรู้ของฉันไม่ทราบว่ามีหมายเลขใด ๆ กับคุณสมบัตินี้อยู่หรือไม่ (ถ้าจำนวนพอใจคุณสมบัตินี้เป็นจำนวนเฉพาะมันเรียกว่าไพรม์ Wieferich ของคำสั่งที่ 3 ถึงฐาน 2 และเปิดอยู่ไม่ว่าจะมีนายกใด ๆ )

Haskell, 47 ไบต์

[n|n<-[1..],2*n==sum[d|d<-[2..n],n`mod`d<1]]!!0

ค้นหาแรกจำนวน quasiperfectซึ่งเป็นจำนวนรวมที่มีของตัวหารเป็นn 2*n+1แทนที่จะเพิ่ม 1 ฉันไม่รวม 1 จากรายการตัวหาร

Brain-Flak, 212 208 204 ไบต์

โปรแกรมนี้ใช้อัลกอริทึมการคูณที่เขียนโดยMegaTomและตัวตรวจสอบที่ไม่ใช่สแควร์ที่เขียนโดย1000000000

ลองใช้ออนไลน์

(((()()()()){})){{}((({}()))<{(({})[()])}{}>[()]){({}<({}<>)({<({}[()])><>({})<>}{}<><{}>)>[()])}{}(({}())){(({}[()]<>)<>)(({({})({}[()])}{}[({})]<>)){{}{}({}<>)(<([()])>)}{}({}()){(((<{}{}<>{}>)))}{}}{}}

โปรแกรมนี้เริ่มต้นที่ 8 และทดสอบแต่ละหมายเลขเพื่อดูว่า n! +1 เป็นจำนวนสแควร์หรือไม่ มันจะออกเมื่อพบสิ่งนั้น สิ่งนี้เรียกว่าปัญหาของ Brocardและเป็นปัญหาที่เปิดกว้างในวิชาคณิตศาสตร์

Brachylog (v2), 3 ไบต์ในการเข้ารหัสของ Brachylog

⟦cṗ

ลองออนไลน์! (จะหมดเวลาโดยไม่ทำอะไรที่มองเห็นได้ด้วยเหตุผลที่ชัดเจน)

โปรแกรมเต็มรูปแบบ; หากรันโดยไม่มีอินพุตให้ค้นหาSmarandache primeแรกและเอาต์พุตtrue.หากและเมื่อพบหนึ่ง มันเป็นคำถามที่เปิดกว้างว่า Smarandache นั้นมีอยู่หรือไม่ (โปรดทราบว่าอัลกอริทึมการทดสอบเฉพาะของ Brachylog ถึงแม้ว่ามันจะทำงานได้ในทางทฤษฎีเกี่ยวกับจำนวนมากโดยพลการ แต่ก็มีแนวโน้มที่จะทำงานได้ช้าลงดังนั้นถ้าคุณสนใจที่จะค้นหา Smarandache ในช่วงตัวเองฉันแนะนำให้ใช้ภาษาอื่น)

คำอธิบาย

⟦cṗ
⟦     Form an increasing range from 0 to {the smallest number with no assertion failure} 
 c    Concatenate all the numbers that make up that range, in decimal
  ṗ   Assert that the result is prime

Brachylog ทำงานกับตัวเลขทศนิยมของตัวเลขเมื่อใดก็ตามที่คุณพยายามที่จะรักษามันเหมือนรายการดังนั้น "ช่วง" ตามด้วย "concatenate" เป็นวิธีที่สั้นมากในการสร้างลำดับของตัวเลข Smarandache (และจากนั้นเรากรองโดย primality; พฤติกรรมโปรแกรมเต็มรูปแบบเริ่มต้นจะบังคับองค์ประกอบแรกของตัวสร้างผลลัพธ์) ช่วงมีศูนย์นำ แต่โชคดีที่มีรูปแบบการไหลนี้ Brachylog ลบศูนย์แทนที่จะล้มเหลว

นี่คือตัวอย่างที่พบหมายเลข Smarandache แรกที่เท่ากับ 6 (mod 11) เป็นการสาธิตโปรแกรมที่คล้ายกันซึ่งจะสิ้นสุดภายใน 60 วินาทีแทนที่จะมีสถานะไม่รู้จัก

⟦c{-₆~×₁₁&}

ลองออนไลน์!

สิ่งนี้จะพิมพ์true.เป็นโปรแกรมเต็มรูปแบบ แต่ฉันโยนในZอาร์กิวเมนต์บรรทัดคำสั่งเพื่อพิมพ์ตัวเลขที่เป็นปัญหาให้การสาธิตที่ดีกว่าว่าวิธีการทั่วไปนี้ใช้งานได้

Python 2, 88 ไบต์

p=lambda n:all(n%x for x in range(2,n))
s=lambda n:0if p((10223*2**n)+1)else s(n+1)
s(0)

รหัสนี้จะยุติหาก 1,0223 เป็นหมายเลขSierpiński 10223 ปัจจุบันเป็นผู้สมัครที่เล็กที่สุดที่อาจจะใช่หรือไม่ใช่ตัวเลขSierpiński ณ เดือนธันวาคม 2556

หมายเลขSierpińskiคือตัวเลขkที่ตัวเลขทั้งหมดของแบบฟอร์ม(k * 2^n) + 1ประกอบ

Pyth, 16 ไบต์

f!}1.u@,/G2h*3GG

ส่งคืนค่าแรกที่ Collatz คาดเดาไม่ได้ถือ เนื่องจากไม่ทราบว่าการคาดเดามีไว้สำหรับตัวเลขทั้งหมดหรือไม่จึงไม่เป็นที่ทราบว่ารหัสนี้จะยุติลงหรือไม่

จริงแล้ว 16 ไบต์

1`;;pY)▒@D÷íu*`╓

ลองออนไลน์!

รหัสนี้จะสิ้นสุดลงหากมีบางหมายเลขประกอบnเช่นที่totient(n)หารn-1( ปัญหา totient ของ Lehmer )

คำอธิบาย:

1`;;pY)▒@D÷íu*`╓
1`            `╓  first integer, starting with 0, where the following function leaves a truthy value on top of the stack:
    pY       *      composite (not prime) and
   ;  )▒            totient(n)
  ;     @D֒u       is in the list of divisors of n-1

เยลลี่ , 9 8 ไบต์

-1 ไบต์ขอบคุณ @Dennis! (ใช้การยกกำลังแทนการคูณเพื่อหลีกเลี่ยงÆṣ(0))

*ḂÆṣ=µ2#

จะส่งคืนรายการศูนย์และจำนวนสมบูรณ์แบบคี่ที่เล็กที่สุดหากมีอยู่

อย่างไร?

*ḂÆṣ=µ2# - Main link: no arguments
     µ   - monadic chain separation
      2# - count up from implicit `n=0` and return the first 2 truthy results of
 Ḃ       -     mod 2        -> n%2
*        -     exponentiate -> n**(n%2)  (1 when n is even, n when n is odd)
  Æṣ     -     sum of proper divisors of n**(n%2)
    =    -     equals n?    -> 1 if n is zero or both perfect and odd, else 0

Haskell, 46 ไบต์

[n|m<-[1..],n<-[1..m],product[1..n]+1==m^2]!!3

สิ้นสุดลงหากพบวิธีที่ 4 ในการแก้ไขปัญหาของบัตร

Python ขนาด 92 ไบต์

นี่ไม่ชนะการแข่งขันกอล์ฟรหัสใด ๆ และต้องใช้หน่วยความจำที่ไม่มีที่สิ้นสุดและความลึกในการเรียกซ้ำ แต่นี่เป็นโอกาสที่สมบูรณ์แบบในการเชื่อมต่อปัญหาที่น่าสนใจที่ฉันถามในการคำนวณทางคณิตศาสตร์สแต็คสองปีที่ผ่านมา ของทั้งสองก้อนบวก มันสนุกพอมันเริ่มจากไอเดียการแข่งขันกอล์ฟรหัสดังนั้นฉันเดาว่าฉันมาเต็มวงแล้ว

def f(i,j):
 r=range(i)
 for a in r:
  for b in r:
   if a**3+b**3==i:1/0
 f(j,i+j)
f(13,21)

Python 2, 123 98 92 ไบต์

p=lambda n,k=2:n<=k or n%k*p(n,k+1)
g=lambda n:[p(b)*p(n-b)for b in range(n)]and g(n+2)
g(4)

รหัสนี้จะยุติลงหากการคาดคะเนของ Goldbach ไม่ได้เก็บไว้สำหรับหมายเลขคู่ทั้งหมด (เช่นถ้าหมายเลขคู่ทั้งหมดสามารถแสดงเป็นผลรวมของสองช่วงเวลา) ปัจจุบันได้มีการทดสอบตัวเลขที่มีขนาดไม่เกิน 4 * 10 ^ 18

ขอขอบคุณ @ Pietu1998 จำนวนมากที่ทำให้รหัสของฉันสั้นลงมาก!

แก้ไข: ขอบคุณ @JonathanAllan สำหรับการลบรหัสของฉัน 6 ไบต์!

JavaScript (ES6), 104 101 ไบต์

for(n=[6,9,p=1];!p;n=n.map((x,i)=>(q=n[n.length+~i],p|=x^q,c=q+x+c/10|0)%10).concat(c/10|0||[]))c=p=0

ใช้วิธีเดียวกันกับคำตอบ Perl: ตั้งค่าnเป็น 196 จากนั้นเพิ่มnอีกครั้งเป็นฐาน 10 ย้อนกลับจนกว่าจะเป็น palindrome ในฐาน 10 ซึ่งจะสั้นลงถ้า JS รองรับตัวเลขที่มีความแม่นยำตามอำเภอใจ แต่ก็ดี

Python ขนาด 80 ไบต์

สิ้นสุดลงถ้าการคาดคะเน Collatzได้รับการพิสูจน์แล้วว่าผิด ดูคำถามนี้

n=2
while 1:
 L=[];x=n
 while~-n:1/(n not in L);L+=[n];n=(n/2,n*3+1)[n%2]
 n=x+1

Python 2, 64 ไบต์

หมายเลขลิ้นจี่เป็นจำนวนธรรมชาติที่ไม่สามารถสร้างรูปแบบ palindrome ผ่านกระบวนการวนซ้ำของการย้อนกลับของตัวเลขและเพิ่มจำนวนผลลัพธ์

ไม่มีการพิสูจน์ตัวเลข Lychrelในฐานสิบ 196 เป็นผู้สมัครหมายเลขลิ้นจี่ที่เล็กที่สุด มันแสดงให้เห็นว่าถ้ามี palindrome อยู่ (ทำ 196 ไม่ใช่หมายเลข Lychrel) มันจะมีตัวเลขอย่างน้อยหนึ่งพันล้าน (10 ^ 9) หลักเพราะผู้คนใช้งานอัลกอริทึมที่ยาวนาน

n=196
while 1:
    x=str(n);r=x[::-1]
    if x!=r:n=n+int(r)
    else:1/0

เยลลี่ขนาด 7 ไบต์

*+3Ẓµ4#

ลองออนไลน์! (พิมพ์สององค์ประกอบไม่ใช่ 4 เพื่อที่คุณจะได้เห็นมันหยุด)

$n$$n^n+3$

คำอธิบาย

*+3Ẓµ4#
     4#  Find the first four numbers with the following property:
    µ      (bracketing/grouping: place everything to the left inside the loop)
*          {The number} to the power of {itself}
 +3        plus 3
   Ẓ       is prime

R, 30 ไบต์พิสูจน์ได้ว่ามันถูกกำหนดไว้หรือไม่

while(any(sample(2,654,T)>1))1

ตัวสร้างตัวเลขสุ่มเริ่มต้นของ R มีขนาดเท่ากันใน 653 มิติติดต่อกัน แต่ไม่ทราบใน 654 มิติ ดังนั้นอาจมีหรือไม่มีลำดับของตัวเลขเทียมที่สุ่มตัวอย่างองค์ประกอบที่ต่ำที่สุดจากเวกเตอร์ที่กำหนด 654 ครั้งในแถว (นี่คือเวกเตอร์1:2)

เนื่องจาก RNG ของ R เป็นระยะ (แม้ว่าจะมีระยะเวลานานมาก) ฉันจึงอ้างว่านี่เป็นสิ่งที่กำหนดได้เพราะในที่สุดมันจะวนกลับไปสู่จุดเริ่มต้น ความคิดเห็นของคุณอาจแตกต่างกันแน่นอน

Python 3, 101 ไบต์

ฉันรู้ว่ามันนานกว่าคนอื่น ๆ อีกหลายคน แต่ฉันใช้เวลามากมายดูว่าฉันจะเล่นกอล์ฟสั้นแค่ไหน

นี้พยายามที่จะหักล้างออยเลอร์ผลรวมของพลังการคาดคะเนสำหรับk=6(มีอยู่ไม่มีการแก้ปัญหาจำนวนเต็มบวกสม Diophantine A^6+B^6+C^6+D^6+E^6==F^6) ซึ่งไม่มี counterexample มีการค้นพบ

R=[1]
while 1:R+=[R[-1]+1];eval(("[1/("+"+%s**6"*5+"!=%%s**6)%s]"%("for %s in R "*6))%(*"ABCDEF"*2,))

ใน Python 2 (104 ไบต์):

R=[1]
while 1:R+=[R[-1]+1];eval(("[1/("+"+%s**6"*5+"!=%%s**6)%s]"%("for %s in R "*6))%tuple("ABCDEF"*2))

หักกอล์ฟ:

x=2
while 1:
    R=range(1,x)
    [1/(A**6+B**6+C**6+D**6+E**6!=F**6)for F in R for E in R for D in R for C in R for B in R for A in R]
    x+=1

รุ่น Mathy ไม่มี eval:

R=range
x=2
while 1:
    for i in R(x**6):1/(sum(map(lambda x:x**6,[1+(i%x**-~j/x**j)for j in R(6)]))-i%x-1)
    x+=1

ข้อมูลอ้างอิงอื่น: ผลรวมการคาดเดาของออยเลอร์ - MathWorld

Python ขนาด 68 ไบต์

n=2
while"".join(str((i+2)**n)[0]for i in range(8))!="23456789":n+=1

ลองออนไลน์

พยายามที่จะตอบหนึ่งในคำถามของช้าง

2. แถว "23456789" จะปรากฏสำหรับ n> 1 หรือไม่ ไม่มีสำหรับ n <= 10 ^ 5 ...

Clojure, 154 ไบต์

(loop[x 82001](if(= 0(reduce +(map{true 1 false 0}(for[y(range 3 6)](true?(for[z(str(range 2 y))](.indexOf z(Integer/toString x y))))))))x(recur(inc x))))

ตรวจสอบว่ามีตัวเลขสูงกว่า 82,000 ที่มีเพียง 0 และ 1 สำหรับฐาน 2 ตลอดจนฐาน 5 หรืออีกนัยหนึ่งคือตรวจสอบว่ามีหมายเลขอื่นในลำดับนี้หรือไม่

ในกลุ่มพิเศษที่มีเพียงตัวเลข 3 0, และ1 มีจำนวนไม่มากที่เป็นไปตามกฎที่ที่น้อยกว่าโดยประมาณเป็น82,0003*10^19723

Pyt , 14 ไบต์

27*²0`ŕĐ₫+Đ₽¬ł

ท่าเรือคำตอบ mbomb007 ของ