ओवरलैपिंग सर्कल

Question

आपको एक प्रोग्राम या फंक्शन लिखना चाहिए जो समान रूप से स्पेस स्क्वायर ग्रिड और एक सॉलिड इंस्क्राइब्ड सर्कल आउटपुट Nद्वारा दिया गया हो Nया ग्रिड स्क्वेयर की संख्या देता है जो आंशिक रूप से या पूरी तरह से सॉलिड सर्कल द्वारा ओवरलैप किए जाते हैं।

0-आकार के ओवरलैप्स (यानी जब सर्कल केवल एक लाइन को छूता है) को गिना नहीं जाता है। (ये ओवरलैप्स उदाहरण के लिए होते हैं N = 10।)

उदाहरण

N = 8 (64 squares), Slices = 60

इनपुट

• एक पूर्णांक N > 0। (ग्रिड wil में N * Nवर्ग हैं।)

उत्पादन

• एक पूर्णांक, ठोस सर्कल स्लाइस की संख्या।

उदाहरण

(इनपुट-आउटपुट जोड़े)

Inputs:  1 2 3  4  5  6  7  8  9 10  11  12  13  14  15
Outputs: 1 4 9 16 25 36 45 60 77 88 109 132 149 172 201

यह कोड-गोल्फ है इसलिए सबसे छोटी प्रविष्टि जीतती है।

Comments

क्या यह सिर्फ मैं या हर कोई यहाँ स्पष्ट समाधान याद कर रहा है? संपादित करें: कोई बात नहीं। पहले जो एक साधारण जैसा दिखता था N^2।

— nyuszika7h

Answer 1

पायथ, २ 26 २६

-*QQ*4lfgsm^d2T*QQ^%2_UtQ2

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

मैं एक 2Nx2Nग्रिड का उपयोग करता हूं और अतिव्यापी 2x2वर्गों की गणना करता हूं । यह थोड़ा छोटा है, क्योंकि मैं पहले से ही त्रिज्या जानता हूं N।

और वास्तव में मैं अतिव्यापी वर्गों की गिनती नहीं करता हूं। मैं दूसरे चतुर्थांश के गैर-अतिव्यापी वर्गों की गिनती करता हूं, संख्या को 4 से गुणा करें और परिणाम को घटाएं N*N।

27 समाधान के लिए स्पष्टीकरण:

-*QQ*4lfgsm^-Qd2T*QQ^t%2UQ2   implicit: Q = input()
                     t%2UQ    generates the list [2, 4, 6, ..., Q]
                    ^     2   Cartesian product: [(2, 2), (2, 4), ..., (Q, Q)]
                              These are the coordinates of the right-down corners
                              of the 2x2 squares in the 2nd quadrant. 
       f                      Filter the coordinates T, for which:
        gsm^-Qd2T*QQ             dist-to-center >= Q
                                 more detailed: 
          m     T                   map each coordinate d of T to:
           ^-Qd2                       (Q - d)^2
         s                          add these values
        g        *QQ                 ... >= Q*Q
    *4l                       take the length and multiply by 4
-*QQ                          Q*Q - ...

26 समाधान के लिए स्पष्टीकरण:

मैंने देखा कि मैं केवल एक बार निर्देशांक का उपयोग करता हूं और तुरंत निर्देशांक घटाता हूं Q। Q - coordsसीधे-सीधे मूल्यों को उत्पन्न क्यों नहीं किया?

इसमें होता है %2_UtQ। पिछले समाधान की तुलना में केवल एक चार्ट बड़ा है और 2 चार्ट बचाता है, क्योंकि मुझे कोई विकल्प नहीं है -Q।

Answer 2

अजगर 2, 72

lambda n:sum(n>abs(z%-~n*2-n+(z/-~n*2-n)*1j)for z in range(~n*~n))+n+n-1

Ungolfed:

def f(n):
    s=0
    for x in range(n+1):
        for y in range(n+1):
            s+=(x-n/2)**2+(y-n/2)**2<(n/2)**2
    return s+n+n-1

ग्रिड एक (n+1)*(n+1)वर्ग के लिए इंगित करता है । यदि सेल का केंद्र बिंदु निकटतम सर्कल के अंदर है, तो एक सेल सर्कल को ओवरलैप करता है। तो, हम ग्रिड बिंदुओं की गणना कर सकते हैं, इसके अलावा 2*n+1कुल्हाड़ियों (यहां तक ​​कि और विषम दोनों n) पर ग्रिड बिंदुओं को छोड़ देता है , इसलिए हम उस मैन्युअल रूप से सही करते हैं।

कोड केंद्र तक की दूरी की गणना करने के लिए जटिल दूरी का उपयोग करके पात्रों को बचाता है और एक इंडेक्स पर पुनरावृति करने के लिए एक लूप पतन होता है।

Answer 3

CJam, 36 35 34 27 बाइट्स

यह xnor के रूप में एक ही एल्गोरिदम निकला, लेकिन मुझे आश्चर्य है कि अगर कोई बेहतर है।

rd:R,_m*{{2*R(-_g-}/mhR<},,

कोड स्पष्टीकरण :

rd:R                                "Read the input as double and store it in R";
    ,_                              "Get 0 to input - 1 array and take its copy";
      m*                            "Get Cartesian products";
                                    "Now we have coordinates of top left point of each";
                                    "of the square in the N by N grid";
        {               },,         "Filter the squares which are overlapped by the";
                                    "circle and count the number";
         {        }/                "Iterate over the x and y coordinate of the top left";
                                    "point of the square and unwrap them";
          2*                        "Scale the points to reflect a 2N grid square";
            R(-                     "Reduce radius - 1 to get center of the square";
               _g-                  "Here we are reducing or increasing the coordinate";
                                    "by 1 in order to get the coordinates of the vertex";
                                    "of the square closer to the center of the grid";
                    mhR<            "Get the distance of the point from center and check";
                                    "if its less than the radius of the circle";

अद्यतन : 7 बाइट को बचाने के लिए कुछ अन्य तकनीकों के साथ जकुबे से 2N चाल का उपयोग करना!

इसे यहाँ ऑनलाइन आज़माएँ

Answer 4

Pyth,  44  36

JcQ2L^-+b<bJJ2sm+>*JJ+y/dQy%dQqQ1*QQ

अगर मैं कुछ बाइट्स शेव कर सकता हूं तो इसे थोड़ा साफ करने की कोशिश करूंगा।

व्याख्या

                           Q = eval(input())    (implicit)
JcQ2                       calculate half of Q and store in J
L                          define function y(b) that returns
 ^-+b<bJJ2                 (b - J + (1 if b < J else 0)) ^ 2
s                          output sum of
 m                 *QQ      map d over integers 0..(Q*Q-1)
  +
   >*JJ                      J*J is greater than
       +y/dQy%dQ              sum of y(d / Q) and y(d % Q)
                qQ1          or Q is 1; see below

मुझे स्पष्ट रूप से जांचना होगा n = 1, क्योंकि मेरा एल्गोरिथ्म केवल केंद्र के निकटतम वर्ग के कोने की जांच करता है (और कोई भी इसमें शामिल नहीं है n = 1)।

Answer 5

ऑक्टेव (74) (66) (64)

यहाँ सप्तक संस्करण। मूल रूप से सर्कल के भीतर सभी कोने ढूंढना और फिर सभी वर्गों को एक या अधिक वैध कोने के साथ कनवल्शन के माध्यम से खोजना। 64 बाइट्स:

x=ndgrid(-1:2/input(''):1);sum(conv2(x.^2+x'.^2<1,ones(2))(:)>0)

66 बाइट्स:

x=meshgrid(-1:2/input(''):1);sum(conv2(x.^2+x'.^2<1,ones(2))(:)>0)

74 बाइट्स:

n=input('');x=ones(n+1,1)*(-1:2/n:1);sum(conv2(x.^2+x'.^2<1,ones(2))(:)>0)

Answer 6

आर - 64

function(n)sum(rowSums(expand.grid(i<-0:n-n/2,i)^2)<n^2/4)+2*n-1