गिनती करने वाली इकाई वर्ग वृत्त से होकर गुजरती है

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो एक पूर्णांक त्रिज्या r देता है। इकाई की संख्या उस वर्ग को मापता है जिसके मूल में त्रिज्या r होता है। यदि सर्कल ग्रिड पर एक बिंदु से बिल्कुल गुजरता है जो आसन्न इकाई वर्गों से गुजरने के रूप में गिनती नहीं करता है।

यहाँ r = 5 के लिए एक चित्रण है :

^{ओईआईएस पर पाया गया किवल नोगोक्रांग द्वारा चित्रण}

उदाहरण:

0 → 0
1 → 4
4 → 28
5 → 28
49 → 388
50 → 380
325 → 2540
5524 → 44180 554
→ 44020

Comments

OEIS - A242118

— ल्यूक

@ ल्यूक मैं बस इसके लिए देख रहा था, लेकिन यह थोड़ी अलग परिभाषा का उपयोग करता है (कम से कम यह सहमत नहीं है N = 50)।

— मार्टिन एंडर

@smls बाउंडिंग स्क्वायर में गिनती करके। सुनिश्चित करें कि आप उन वर्गों की गणना नहीं करते हैं जहां सर्कल केवल एक कोने को छूता है। OEIS के नंबर गलत हैं, मुझे अभी समीक्षा में सुधार करना है।

— १

मुझे फिर से मिनीक्राफ्ट में गुंबदों के निर्माण का आग्रह है ...

— पैट्रिक रॉबर्ट्स

क्या आप एक 3Blue1Brown दर्शक हैं?

— नाइट्रो 2k01

Answer 1

पायथन 2 , 54 बाइट्स

f=lambda r,x=0:r-x and-~((r*r-x*x)**.5%1>0)*4+f(r,x+1)

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

कम गोल्फ (55 बाइट्स) ( TIO )

lambda r:8*r-4*sum((r*r-x*x)**.5%1==0for x in range(r))

यह आउटपुट का अनुमान लगाता है 8*r, फिर शीर्ष क्रॉसिंग के लिए सही होता है। परिणाम है 8*r-g(r*r), जहां लिखने के तरीकोंg(x) की संख्या गिना जाता हैx दो वर्गों (को छोड़कर g(0)=0) के योग के रूप में जाता है ।

यदि सर्कल कभी किसी कोने से नहीं गया, तो छोड़ी गई कोशिकाओं की संख्या पार किए गए किनारों की संख्या के बराबर होगी। सर्कल 2*rऊर्ध्वाधर ग्रिडलाइन्स और 2*rक्षैतिज ग्रिडलाइंस से गुजरता है , दोनों में से हर एक को दिशा में, कुल के लिए 8*r।

लेकिन, एक शीर्ष पर प्रत्येक क्रॉसिंग दो किनारे क्रॉसिंग के रूप में गिना जाता है, जबकि केवल एक नए सेल में प्रवेश होता है। इसलिए, हम वर्टेक्स क्रॉसिंग की संख्या घटाकर क्षतिपूर्ति करते हैं। इस अक्ष पर अंक की तरह शामिल (r,0)करने के साथ ही पाइथागोरस की तरह ट्रिपल (4,3)के लिए r=5।

हम एक एकल वृत्त का चतुर्थ भाग के लिए अंक गिनती (x,y)के साथ x>=0और y>0साथ x*x+y*y==nहै, तो गुणा 4. द्वारा हम इस की numer की गणना के द्वारा करना sqrt(r*r-x*x)है कि पूरे नंबर के लिए कर रहे हैं xअंतराल में [0,r)।

Answer 2

मैथेमेटिका, 48 बाइट्स

4Count[Range@#~Tuples~2,l_/;Norm[l-1]<#<Norm@l]&

पहले चतुर्थांश को देखता है और ग्रिड कोशिकाओं की संख्या को गिना जाता है जिसके लिए इनपुट सेल के निचले बाएँ और ऊपरी दाएं कोनों के मानदंडों के बीच पड़ता है (परिणाम को 4 से गुणा करना, निश्चित रूप से)।

Comments

एक अन्य विधि 8#-SquaresR[2,#^2]Sign@#&xnor के पद पर आधारित है

— मील

@ मीलों अरे वाह, मेरा कोई वजूद नहीं था SquaresR। खुद को बेझिझक पोस्ट करें (या xnor इसे पोस्ट करें)।

— मार्टिन एंडर

Answer 3

पायथन 2 , 72 बाइट्स

lambda n:sum(0<n*n-x*x-y*y<2*(x-~y)for x in range(n)for y in range(n))*4

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

Answer 4

जेली , 21 13 12 11 बाइट्स

R²ạ²Æ²SạḤ×4

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

यह काम किस प्रकार करता है

R²ạ²Æ²SạḤ×4  Main link. Argument: r

R            Range; yield [1, 2, ..., r].
 ²           Square; yield [1², 2², ..., r²].
   ²         Square; yield r².
  ạ          Absolute difference; yield [r²-1², r²-2², ..., r²-r²].
    Ʋ       Test if each of the differences is a perfect square.
      S      Sum, counting the number of perfect squares and thus the integer
             solutions of the equation x² + y² = r² with x > 0 and y ≥ 0.
        Ḥ    Un-halve; yield 2r.
       ạ     Subtract the result to the left from the result to the right.
         ×4  Multiply by 4.

Answer 5

पर्ल 6, 61 बाइट्स

->\r{4*grep {my &n={[+] $_»²};n(1 X+$_)>r²>.&n},(^r X ^r)}

यह काम किस प्रकार करता है

->\r{                                                    } # Lambda (accepts the radius).
                                                (^r X ^r)  # Pairs from (0,0) to (r-1,r-1),
                                                           #   representing the bottom-left
                                                           #   corners of all squares in
                                                           #   the top-right quadrant.
       grep {                                 }            # Filter the ones matching:
             my &n={[+] $_»²};                             #   Lambda to calculate the norm.
                              n(1 X+$_)>r²                 #   Top-right corner is outside,
                                          >.&n             #   and bottom-left is inside.
     4*                                                    # Return length of list times 4.

Answer 6

AWK, 90 बाइट्स

{z=$1*$1
for(x=$1;x>=0;x--)for(y=0;y<=$1;y++){d=z-x*x-y*y
if(d>0&&d<2*(x+y)+2)c++}$0=4*c}1

उपयोग:

awk '{z=$1*$1
    for(x=$1;x>=0;x--)for(y=0;y<=$1;y++){d=z-x*x-y*y
    if(d>0&&d<2*(x+y)+2)c++}$0=4*c}1' <<< 5525

वृत्त को प्रतिच्छेदित करने वाले सभी बक्सों को खोजने के लिए चतुर्थांश 1 के माध्यम से बस एक सरल खोज। समरूपता 4 से गुणा करने की अनुमति देती है। इससे जा सकते हैं -$1 to $1, लेकिन यह अधिक बाइट लेगा और कम कुशल होगा। जाहिर है कि यह एल्गोरिदम का सबसे समय कुशल नहीं है, लेकिन मेरी मशीन पर 5525 केस को चलाने में केवल 16 सेकंड लगते हैं।

Answer 7

हास्केल, 74 बाइट्स

f n=sum[4|x<-[0..n],y<-[0..n],(1+n-x)^2+(1+n-y)^2>n^2,(n-x)^2+(n-y)^2<n^2]

बहुत सीधा है, (0,0) और (n, n) के बीच वर्गों की संख्या की गणना करें, जहां नीचे बाईं ओर सर्कल के अंदर है और शीर्ष दाएं सर्कल के बाहर है, फिर 4 से गुणा करें।

Answer 8

पायथ , 29 बाइट्स

Lsm*ddb*4lf}*QQrhyTym+1dT^UQ2

कोशिश करो!

व्याख्या

Lsm*ddb*4lf}*QQrhyTym+1dT^UQ2  # implicit input: Q
Lsm*ddb                        # define norm function
 s                             # sum
  m   b                        #     map each coordinate to
   *dd                         #                            its square
                         ^UQ2  # cartesian square of [0, 1, ..., Q - 1]
                               #     -> list of coordinates of all relevant grid points
          f                    # filter the list of coordinates T where:
           }*QQ                # square of Q is in
               r               #     the range [
                hyT            #         1 + norm(T),
                               #                  ^ coordinate of lower left corner
                   ym+1dT      #         norm(map({add 1}, T))
                               #              ^^^^^^^^^^^^^^^ coordinate of upper right corner
                               #     ) <- half-open range
         l                     # size of the filtered list
                               #     -> number of passed-through squares in the first quadrant
       *4                      # multiply by 4
                               # implicit print

Answer 9

बैच, 147 बाइट्स

@set/an=0,r=%1*%1
@for /l %%i in (0,1,%1)do @for /l %%j in (0,1,%1)do @set/a"i=%%i,j=%%j,a=i*i+j*j-r,i+=1,j+=1,a&=r-i*i-j*j,n-=a>>31<<2
@echo %n%

AWK और हास्केल उत्तरों से कुछ हद तक प्रेरित है।

Comments

खुशी है कि मैं किसी को प्रेरित कर सकता हूं :)

— रॉबर्ट बेन्सन

Answer 10

बैश + यूनिक्स उपयोगिताओं, 127 बाइट्स

c()(d=$[(n/r+$1)**2+(n%r+$1)**2-r*r];((d))&&echo -n $[d<0])
r=$1
bc<<<`for((n=0;n<r*r;n++));{ c 0;c 1;echo;}|egrep -c 01\|10`*4

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

बस पहले चतुर्थांश में सभी बिंदुओं पर जाएं, उन्हें गिनें और 4. से गुणा करें। यह बहुत धीमा हो सकता है, लेकिन यह काम करता है।

Answer 11

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

n=>4*(G=k=>k<n?Math.ceil((n**2-k++**2)**0.5)-(0|(n**2-k**2)**0.5)+G(k):0)(0)

Comments

क्या आप शायद nनीचे से पीछे हटकर एक-दो बाइट काट सकते हैं 0?

— नील

@ नील मैंने कोशिश की लेकिन एक रास्ता नहीं देख सका। केवल एक फ़ंक्शन का उपयोग करना चाहते थे, लेकिन अभी भी nत्रिज्या और kपुनरावृत्ति दोनों को संग्रहीत करने की आवश्यकता है और सभी प्रयास एक ही बाइट्स से बाहर आए

— जॉर्ज रीथ

@ नील आह मैं देख रहा हूं कि आप क्या कह रहे हैं, k<n?...लेकिन मैं उन बाइट्स को खो देता हूं, जिस पर पलटवार n**2-k++**2करते समय ऑपरेटर वरीयता गलत है, गैर-कम्यूटेटिव है, इसलिए बाईं ओर हमेशा पैरेंटस की जरूरत होती है k-1और जरूरत होती है। जब तक आपको कोई रास्ता नहीं मिला है?

— जॉर्ज रीथ

आह, मैंने घटाव को नजरअंदाज कर दिया ... हो सकता है कि आप पूरे काम को 4 के बजाय 4 से गुणा कर सकें? (हालांकि वह अभी भी आपकी बचत में खा सकता है ...)

— नील