คำนิยาม:

• สามเหลี่ยมนั้นถือเป็นสามเหลี่ยมมุมฉากหากมุมภายในมุมใดมุมหนึ่ง 90 องศา
• จำนวนนั้นถือว่ามีเหตุผลถ้ามันสามารถแสดงโดยอัตราส่วนของจำนวนเต็มเช่นp/qที่ทั้งสองpและqเป็นจำนวนเต็ม
• ตัวเลขnเป็นตัวเลขที่สอดคล้องกันหากมีพื้นที่สามเหลี่ยมมุมฉากอยู่nซึ่งทั้งสามด้านมีเหตุผล
• นี่คือ OEIS A003273

ท้าทาย

นี่คือความท้าทายการตัดสินใจปัญหา ให้หมายเลขอินxพุทเอาท์พุทค่าที่ชัดเจนและสอดคล้องกันหากxเป็นจำนวนที่สมภาคกันและค่าที่แตกต่างและที่สอดคล้องกันแยกกันหากxไม่ใช่จำนวนที่สอดคล้องกัน ค่าเอาต์พุตไม่จำเป็นต้องเป็นความจริง / เท็จในภาษาของคุณ

กฎพิเศษ

สำหรับความท้าทายนี้คุณสามารถสันนิษฐานได้ว่าการคาดคะเนของเบิร์ชและสวินเนอร์ตัน - ไดเออร์เป็นเรื่องจริง หรือถ้าคุณสามารถพิสูจน์การคาดคะเนของเบิร์ชและสวินเนอร์ตัน - ไดเออร์ไปรับรางวัล 1,000,000 เหรียญสหรัฐ ;-)

ตัวอย่าง

(ใช้Trueสำหรับตัวเลขที่สอดคล้องกันและFalseอื่น ๆ )

5 True
6 True
108 False

กฎและคำชี้แจง

• เข้าและส่งออกจะได้รับโดยวิธีการที่สะดวกใด ๆ
• คุณสามารถพิมพ์ผลลัพธ์ไปที่ STDOUT หรือส่งคืนเป็นผลลัพธ์ของฟังก์ชัน โปรดระบุในการส่งของคุณว่าค่าที่ใช้สามารถส่งออก
• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการเล่นกอล์ฟตามปกติทั้งหมดและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

R, 179 173 142 141 137 135 134 ไบต์

การใช้อาร์กิวเมนต์เดียวกันตามทฤษฎีบทของ Tunnellจะส่งกลับค่า a 0ถ้าnไม่สอดคล้องกันและเป็น1อย่างอื่น (ใช้เวลานานพอสมควรที่จะมองเห็นข้อ จำกัด เกี่ยวกับเงื่อนไขที่ใช้กับจำนวนเต็มที่ไม่ต้องยกกำลังสอง )

function(n){b=(-n:n)^2
for(i in b^!!b)n=n/i^(!n%%i)
P=1+n%%2
o=outer
!sum(!o(y<-o(8/P*b,2*b,"+")/P-n,z<-16/P*b,"+"),-2*!o(y,4*z,"+"))}

ลองออนไลน์

การปรับปรุงที่นำโดยArnaudและGiuseppe (รหัสสุดท้ายคือ Guiseppe ส่วนใหญ่!) ด้วย -3 ขอบคุณRobin

การวิเคราะห์ไวยากรณ์:

for(i in b[b>0])n=n/i^(!n%%i) #eliminates all square divisors of n
P=2^(n%%2)                    #n odd (2) or even (1)
o=outer                       #saves 3 bytes 
o(8/P*b,2*b,"+")/P-n          #all sums of (8/P)x^2+(2/P)*y^2-n
o(...,16/P*b,"+")             #all sums of above and (16/P)*z^2
o(...,4*z,"+"))               #all sums of above and (64/P)*z^2
!o(...,4*z,"+"))              #all sums of above equal to zero
!sum(!...,2*!...)             #are zeroes twice one another (Tunnell)

กับทฤษฎีบทของ Tunnell ที่ระบุว่า n นั้นสอดคล้องกันถ้าจำนวนของการแก้ปัญหาจำนวนเต็มเป็น2x² + y² + 8z² = n เป็นสองเท่าของจำนวนวิธีการแก้ปัญหาจำนวนเต็มเป็น2x² + y² + 32z² = n ถ้า n เป็นเลขคี่และจำนวน การแก้ปัญหาจำนวนเต็มถึง8x² + y² + 16z² = n เท่ากับสองเท่าของจำนวนเต็ม Solutions ถึง8x² + y² + 64z² = n ถ้า n เป็นเลขคู่

สนิม - 282 ไบต์

fn is(mut n:i64)->bool{let(mut v,p)=(vec![0;4],n as usize%2);while let Some(l)=(2..n).filter(|i|n%(i*i)==0).nth(0){n/=l*l;}for x in -n..=n{for y in -n..=n{for z in -n..=n{for i in 0..2{if n-6*x*x*(n+1)%2==2*x*x+(2-n%2)*(y*y+(24*i as i64+8)*z*z){v[2*p+i]+=1};}}}}v[2*p]==2*v[2*p+1]}

• ใช้ทฤษฎีบทของJerrold B. Tunnellซึ่งฉันไม่เข้าใจจริง ๆ แต่ดูเหมือนว่าจะได้ผล
• หาร n ด้วยปัจจัยสแควร์ทั้งหมด, เพื่อให้มัน 'ฟรีสแควร์', เนื่องจากในเอกสารด้านล่างทฤษฏีของ Tunnell อธิบายไว้สำหรับสแควร์อิสระเท่านั้น
  • ฉันเชื่อว่าสิ่งนี้อาจใช้งานได้เพราะทุกหมายเลขที่สอดคล้องกันเมื่อคูณด้วยสี่เหลี่ยมจะสร้างจำนวนที่สอดคล้องกันมากขึ้นและในทางกลับกัน ดังนั้นโดยการทดสอบจำนวนที่น้อยลงเราสามารถตรวจสอบขนาดที่ใหญ่กว่าซึ่งในกรณีของเราคือ n (สี่เหลี่ยมที่ถูกลบออกทั้งหมดสามารถคูณเข้าด้วยกันเพื่อสร้างหนึ่งสี่เหลี่ยมจัตุรัสใหญ่)
• $$\text{if n is odd, test if n = }2x^2 + y^2 + 32z^2\text{ and/or } 2x^2 + y^2 + 8z^2$$ $$\text{if n is even, test if n = }8x^2 + 2y^2 + 64z^2 \text { and/or } 8x^2 + 2y^2 + 16z^2$$
  • ในโค้ดตัวเองสมการทั้งสี่ได้ถูก smooshed เป็นหนึ่งในลูปโดยใช้โมดูโล่สำหรับคู่ / คี่
• นับจำนวนของสมการที่ตรงกับ n
• หลังจากวนลูปทดสอบอัตราส่วนของสิ่งที่นับ (ต่อ Tunnell)

ดูสิ่งนี้ด้วย:

• หากคุณต้องการลองใช้รหัสในสนามเด็กเล่นสนิม
• ตัวเลขที่สอดคล้องกัน, รูปไข่แบบโค้งและแบบแยกส่วนโดย Guy Henniart, เว็บไซต์ Bilkent University, แปลโดย Franz Lemmermeyer
• ปัญหาหมายเลขที่สอดคล้องกันโดย Keith Conrad เว็บไซต์ University of Connecticut
• ตัวเลขที่สอดคล้องกันโดย Brian Hayes บล็อก bit-palyer.org

แก้ไขแม้ / คี่ขอบคุณ @Level River St

C ++ (gcc) , 251 234 ไบต์

ขอบคุณ @arnauld ที่ชี้ให้เห็นถึงความผิดพลาดในส่วนของฉัน

-17 ไบต์ขอบคุณ @ceilingcat

#import<cmath>
int a(int n){int s=sqrt(n),c,x=-s,y,z,i=1,X;for(;++i<n;)for(;n%(i*i)<1;n/=i*i);for(;x++<s;)for(y=-s;y++<s;)for(z=-s;z++<s;c+=n&1?2*(n==X+24*z*z)-(n==X):2*(n==4*x*x+2*X+48*z*z)-(n/2==2*x*x+X))X=2*x*x+y*y+8*z*z;return!c;}

ลองออนไลน์!

ส่งคืน 1 ถ้าnสอดคล้องกัน 0 เป็นอย่างอื่น

เนื่องจากเราสามารถสรุปได้ว่าการคาดคะเนของ Birch และ Swinnerton-Dyer นั้นเป็นจริงฉันใช้ทฤษฎีบทของ Tunnel เป็นบททดสอบ โปรดทราบว่าในทางเทคนิคจะต้องมีการทดสอบที่ไม่ใช่ศูนย์ x, y และ z เท่านั้นเนื่องจากชุดของค่าบวก (x, y, z) หมายถึงชุดเพิ่มเติมสำหรับแต่ละค่าเหล่านั้นเป็นค่าลบเนื่องจากตัวเลขทั้งสี่กำหนดให้ใช้จตุรัสของ x y และ z ในการคำนวณ นอกจากนี้เนื่องจากต้องการอัตราส่วนของตัวเลขสองตัวคือ A และ B หรือ C และ D เราจึงไม่จำเป็นต้องกังวลเกี่ยวกับเซ็ตอื่น ๆ เหล่านี้ ดังนั้นเราเพียงแค่ต้องเพิ่ม 2 สำหรับทุกวิธีแก้ปัญหาสำหรับ A หรือ C และลบ 1 สำหรับทุกวิธีแก้ปัญหาของ B หรือ D และตรวจสอบว่าเราลงท้ายด้วย 0 นอกจากนี้ข้อมูลจะถูกลดลงเป็นจำนวนเต็ม squarefree เพราะถ้า$q$ เป็นจำนวนที่สอดคล้องกันแล้ว $s^2q$ ก็สอดคล้องกัน (อัลกอริทึมดูเหมือนว่าจะทำลายตัวเลขที่มีสแควร์

JavaScript (ES7), 165 ไบต์

เช่นเดียวกับคำตอบของ @ NeilA.นี่เป็นไปตามทฤษฎีบทของ Tunnellและสันนิษฐานว่าการคาดคะเนของ Birch และ Swinnerton-Dyer นั้นเป็นจริง

ส่งคืนค่าบูลีน

n=>(r=(g=i=>i<n?g(i+!(n%i**2?0:n/=i*i)):n**.5|0)(s=2),g=(C,k=r)=>k+r&&g(C,k-1,C(k*k)))(x=>g(y=>g(z=>s+=2*(n==(X=(n&1?2:8)*x+(o=2-n%2)*y)+o*32*z)-(n==X+o*8*z))))|s==2

ลองออนไลน์!

อย่างไร?

ก่อนอื่นเราแปลงอินพุต $n$ เป็นคู่ฟรีสแควร์ของมัน $n'$คำนวณ $r=\lfloor\sqrt{n'}\rfloor$ และเริ่มต้น $s$ ไปยัง $2$.

r = (                // we will eventually save isqrt(n) into r
  g = i =>           // g = recursive function taking an integer i
    i < n ?          //   if i is less than n:
      g(i + !(       //     do a recursive call with either i or i + 1
        n % i**2 ?   //     if n is not divisible by i²:
          0          //       yield 0 and therefore increment i
        :            //     else:
          n /= i * i //       divide n by i² and leave i unchanged
      ))             //     end of recursive call
    :                //   else:
      n ** .5 | 0    //     stop recursion and return isqrt(n)
  )(s = 2)           // initial call to g with i = s = 2

จากนั้นเราจะกำหนดฟังก์ชั่นตัวช่วย $g$ ซึ่งเรียกใช้ฟังก์ชันเรียกกลับ $C$ กับ $k^2$ สำหรับ $-r<k\le r$.

  g = (C, k = r) =>  // C = callback function, k = counter initialized to r
    k + r &&         //   if k is not equal to -r:
    g(               //     do a recursive call:
      C,             //       pass the callback function unchanged
      k - 1,         //       decrement k
      C(k * k)       //       invoke the callback function with k²
    )                //     end of recursive call

ในที่สุดเราก็ใช้การโทรซ้อน 3 ครั้ง $g$ ที่จะเดินผ่านสามทั้งหมด $(x,y,z) \in [-r+1,r]^3$ and update $s$ to test whether $2A_n = B_n$ if $n$ is odd or $2C_n=D_n$ if $n$ is even, with:

$$\begin{align} &A_n=\#\{(x,y,z)\in [-r+1,r]^3 \mid n=2x^2+y^2+32z^2\}\\ &B_n=\#\{(x,y,z)\in [-r+1,r]^3 \mid n=2x^2+y^2+8z^2\}\\ &C_n=\#\{(x,y,z)\in [-r+1,r]^3 \mid n=8x^2+2y^2+64z^2\}\\ &D_n=\#\{(x,y,z)\in [-r+1,r]^3 \mid n=8x^2+2y^2+16z^2\} \end{align}$$

g(x =>                            // for each x:      \    NB:
  g(y =>                          //   for each y:     >-- all these values are
    g(z =>                        //     for each z:  /    already squared by g
      s +=                        //       add to s:
        2 * (                     //         +2 if:
          n == (                  //           n is equal to either
            X =                   //           An if n is odd (o = 1)
            (n & 1 ? 2 : 8) * x + //           or Cn if n is even (o = 2)
            (o = 2 - n % 2) * y   //
          ) + o * 32 * z          //
        ) - (                     //         -1 if:
          n == X + o * 8 * z      //           n is equal to either
        )                         //           Bn if n is odd
    )                             //           or Dn if n is even
  )                               //
)                                 // if s in unchanged, then n is (assumed to be) congruent

Ruby, 126 bytes

->n{[8,32].product(*[(-n..-t=1).map{|i|i*=i;n%i<1&&n/=i;i}*2+[0]]*3).map{|j|d=2-n%2
k,x,y,z=j
2*d*x+y+k*z==n/d&&t+=k-16}
t==1}

Try it online!

found a place to initialize t=1 and expanded the list of squares into a triplet instead of using q to make additional copies.

Ruby, 129 bytes

->n{t=0
[8,32].product(q=(-n..-1).map{|i|i*=i;n%i<1&&n/=i;i}*2+[0],q,q).map{|j|d=2-n%2
k,x,y,z=j
2*d*x+y+k*z==n/d&&t+=k-16}
t==0}

Try it online!

Uses Tunnell's theorem like the other answers. I use a single equation as follows.

2*d*x^2 + y^2 + k*z^2 == n/d  where d=2 for even n and d=1 for odd n

We check the cases k=8 and k=32 and check if there are twice as many solutions for k=8 than k=32. This is done by adding k-16 to t every time we find a solution. This is either +16 in the case k=32 or -8 in the case k=8. Overall the number is congruent if t is the same as its initial value at the end of the function.

It is necessary to find all solutions to the test equation. I see many answers testing between +/-sqrt n. It is perfectly OK to test also outside these limits if it makes code shorter, but no solutions will be found because the left side of the equation will exceed n. The thing I missed in the beginning is that negative and positive x,y,z are considered separately. Thus -3,0,3 yields three squares 9,0,9 and all solutions must be counted separately (0 must be counted once and 9 must be counted twice.)

Ungolfed code

->n{t=0                              #counter for solutions

  q=(-n..-1).map{|i|i*=i;n%i<1&&n/=i #make n square free by dividing by -n^2 to -1^2 as necessary 
  i}*2+[0]                           #return an array of squares, duplicate for 1^2 to n^2, and add the case 0 

  [8,32].product(q,q,q).map{|j|      #make a cartesian product of all possible values for k,x,y,z and iterate
    d=2-n%2                          #d=1 for odd n, 2 for even n
    k,x,y,z=j                        #unpack j. k=8,32. x,y,z are the squared values from q.
    2*d*x+y+k*z==n/d&&t+=k-16}       #test if the current values of k,x,y,z are a valid solution. If so, adjust t by k-16 as explained above.
t==0}                                #return true if t is the same as its initial value. otherwise false.