बधाई संख्या

Question

परिभाषाएं:

• एक त्रिकोण को एक सही त्रिकोण माना जाता है यदि आंतरिक कोणों में से एक बिल्कुल 90 डिग्री है।
• एक संख्या को तर्कसंगत माना जाता है यदि इसे पूर्णांक के अनुपात से दर्शाया जा सकता है, अर्थात p/q, जहां दोनों pऔर qपूर्णांक हैं।
• एक संख्या nएक सर्वांगसम संख्या है, यदि उस क्षेत्र का एक सही त्रिभुज मौजूद है nजहाँ तीनों पक्ष तर्कसंगत हैं।
• यह OEIS A003273 है ।

चुनौती

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

विशेष नियम

इस चुनौती के प्रयोजनों के लिए, आप मान सकते हैं कि बर्च और स्विंटर्टन-डायर अनुमान सही है। वैकल्पिक रूप से, यदि आप बर्च और स्विनर्टन-डायर अनुमान को साबित कर सकते हैं, तो अपने $ 1,000,000 मिलेनियम पुरस्कार का दावा करें। ;-)

उदाहरण

( Trueअनुरूप संख्या के लिए उपयोग करना और Falseअन्यथा)।

5 True
6 True
108 False

नियम और स्पष्टीकरण

• इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
• आप परिणाम को STDOUT में प्रिंट कर सकते हैं या इसे फ़ंक्शन परिणाम के रूप में वापस कर सकते हैं। कृपया अपने सबमिशन में बताएं कि आउटपुट क्या मान ले सकता है।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

क्या इनपुट एक धनात्मक पूर्णांक है?

— लिन

मेरा प्रारंभिक दृष्टिकोण एक अनियंत्रित वर्ग संख्या द्वारा इनपुट को गुणा करना था जब तक कि पायथागॉरियन ट्रिपल में पैरों के उत्पाद का आधा हिस्सा न हो, लेकिन तब मुझे एहसास हुआ कि वास्तव में एक गैर-अनुरूप इनपुट के लिए समाप्त करना थोड़ा कठिन हो सकता है।

— असंबंधित स्ट्रिंग

@ शीआन ठीक है, लेकिन चुनौतियां स्व-निहित होनी चाहिए।

— लिन

@ लियन हाँ, इनपुट एक धनात्मक पूर्णांक होगा।

— एडमबोर्कबर्क

Answer 1

आर, 179 173 142 141 137 135 134 बाइट्स

ट्यूनेल के प्रमेय के आधार पर समान तर्कों का उपयोग करते हुए , 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,"+"))}

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

अरनौद और ग्यूसेप द्वारा लाया गया सुधार (अंतिम कोड ज्यादातर गुइसेप का है!), -3 धन्यवाद के साथ! रॉबिन

सिंटैक्स विश्लेषण:

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 16 = n, पूर्णांक समाधानों की संख्या 8x² + y² + 64z² = n की तुलना में दोगुनी है यदि n सम है।

Comments

PPCG में आपका स्वागत है! लक्ष्य कोड को यथासंभव छोटा बनाना है। शायद आप इन युक्तियों को गोल्फ के लिए या इन R- विशिष्ट युक्तियों को देख सकते हैं ।

— गिउसेप्पे

बहुत सारे व्हाट्सएप हैं, और मैं इसे ऑनलाइन आज़माने के लिए एक लिंक भी सुझाऊँगा ! अपने कोड को सत्यापित करने में मदद करने के लिए :-)

— Giuseppe

अगर आप चाहें तो आर गोल्फर चैट में भी बेझिझक पहुंच सकते हैं; आप का उपयोग करके सूचित कर सकते हैं @[username]... मुझे लगता है कि आप रॉबिन राइडर द्वारा कोड गोल्फ में खींच लिया गया है ??

— गिउसेप्पे

142 बाइट्स - अनाम फ़ंक्शंस पूरी तरह से ठीक हैं, और मैंने कुछ अन्य गोल्फ बनाए जिन्हें मैं समझाकर खुश हूं

— Giuseppe

अच्छा! क्या कोई कारण है जो आप उपयोग करते हैं -n:n? मैंने टनल की प्रमेय को नहीं पढ़ा, लेकिन मुझे ऐसा लगता है कि n:0यह सिर्फ 1 बाइट के लिए काम करेगा ... इसके अलावा, प्रो टिप, अगर आप टीआईओ के शीर्ष पर "लिंक" बटन दबाते हैं, तो आप अच्छे होंगे PPCG :-) EDIT में कॉपी और पेस्ट करने के प्रारूप: मैं देखता हूं, कुछ मामले ऐसे हैं, जहां n:0काम नहीं करता।

— ग्यूसेप

Answer 2

जंग - 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]}

• जेरोल्ड बी ट्यूनेल का उपयोग करें के प्रमेय का , जिसे मैं वास्तव में नहीं समझता, लेकिन वैसे भी काम करने लगता है।
• अपने सभी वर्गाकार कारकों द्वारा n को विभाजित करें, इसे 'वर्ग मुक्त' बनाने के लिए, क्योंकि नीचे के कागजात में टनल के प्रमेय को केवल वर्ग-मुक्त के लिए वर्णित किया गया है।
  • मेरा मानना ​​है कि यह काम कर सकता है क्योंकि हर एक बधाई संख्या, जब एक वर्ग से गुणा किया जाता है, एक बड़ा बधाई संख्या बनाता है, और इसके विपरीत। इसलिए छोटी संख्या का परीक्षण करके, हम बड़े को मान्य कर सकते हैं, जो हमारे मामले में n है। (सभी हटाए गए वर्गों, एक बड़ा वर्ग बनाने के लिए एक साथ गुणा किया जा सकता है)।
• x, y, z पूर्णांक के सभी संभावित संयोजनों के माध्यम से लूप, ट्यूनेल के समीकरणों का परीक्षण करें: $$\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$$
  • कोड में, चार समीकरणों को एक में, एक लूप के अंदर, यहां तक ​​कि विषम के लिए modulo का उपयोग करते हुए स्मूच किया गया है
• एक मिलान गिनती रखें कि समीकरण n से मेल खाते हैं
• लूपिंग के बाद, लम्बाई के अनुपात का परीक्षण करें (प्रति टनेल)

यह भी देखें:

• यदि आप चाहें, तो रस्ट प्लेग्राउंड पर कोड का प्रयास करें
• कंजेंट नंबर्स, एलिप्टिक कर्व्स, और मॉड्यूलर फॉर्म, गाइ हेनिआर्ट द्वारा, बिल्केंट यूनिवर्सिटी की वेबसाइट, फ्रैंज लेम्मरमेयर द्वारा अनुवादित
• कीथ कॉनराड, यूनिवर्सिटी ऑफ़ कनेक्टिकट वेबसाइट द्वारा कांग्रूवेन्ट नंबर समस्या
• बधाई संख्या, ब्रायन हेस द्वारा, bit-palyer.org ब्लॉग

सही भी / विषम, धन्यवाद @ नदी नदी सेंट

Comments

ओह ठीक है, जिस समय मुझे यह काम मिला, मैंने केवल सी ++ का उत्तर देखा जो गलत था ...

— उज्ज्वल

धन्यवाद स्तर नदी सेंट

— उज्ज्वल

Answer 3

सी ++ (जीसीसी) , 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।

$q$$s^2q$ भी सर्वांगसम है (एल्गोरिथ्म कुछ वर्ग-युक्त संख्याओं पर विराम लगता है।

Comments

@ अरनल्ड: आह, यह मेरी ओर से एक टाइपो था। तय की।

— नील ए।

Answer 4

जावास्क्रिप्ट (ईएस 7), 165 बाइट्स

बहुत कुछ @ नील के जवाब की तरह , यह टनल के प्रमेय पर आधारित है और इसलिए मानता है कि बर्च और स्विंटर्टन-डायर अनुमान सही है।

एक बूलियन मान लौटाता है।

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

$g$$(x,y,z) \in [-r+1,r]^3$$s$$2A_n = B_n$$n$$2C_n=D_n$$n$ यहां तक ​​कि, इसके साथ:

$$\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

Answer 5

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.

Comments

about positive and negative solutions, same here, I wasted quite a while missing this point!

— Xi'an