कोड-गोल्फ: एक सर्कल के अंदर जाली अंक

Question

निम्न चित्र समस्या को दर्शाता है:

एक फ़ंक्शन लिखें, जो सर्कल त्रिज्या के रूप में पूर्णांक देता है, केंद्रित सर्कल (सीमा सहित) के अंदर जाली बिंदुओं की संख्या की गणना करता है ।

छवि दिखाती है:

f[1] = 5  (blue points)
f[2] = 13 (blue + red points)  

आपकी जाँच / डीबगिंग के लिए अन्य मान:

f[3]    = 29
f[10]   = 317
f[1000] = 3,141,549
f[2000] = 12,566,345  

उचित प्रदर्शन होना चाहिए। मान लीजिए कि f [1000] के लिए एक मिनट से भी कम समय है।

सबसे छोटा कोड जीतता है। सामान्य कोड-गोल्फ नियम लागू होते हैं।

कृपया उदाहरण के रूप में f [1001] की गणना और समय पोस्ट करें।

Comments

oeis.org/A328

— msh210

त्रिकोणीय संस्करण ।

— user202729

Answer 1

जे, 21 19 18

+/@,@(>:|@j./~@i:)

-X-xj से x + xj तक कॉम्प्लेक्स बनाता है और परिमाण लेता है।

संपादित करें: साथ >:

एडिट 2: हुक और मोनैडिक के साथ ~। किसी कारण से कुछ समय धीमा चलता है, लेकिन फिर भी f (1000) के लिए 10-ish सेकंड होता है।

Comments

ओह हे, मैं के बारे में पता नहीं था i:, मैं कर रहा हूँ तो यह है कि चोरी, धन्यवाद!

— जेबी

@ जेबी: हाँ, ठीक है ... मैं चोरी कर रहा हूँ >:। derp

— जेसी मिलीकैन 18

काश, मैंने कैप को अच्छी तरह से समझ लिया होता, तो उन ओ ओ

— बी

यह उत्तर निराशाजनक रूप से छोटा है (किसी ऐसे व्यक्ति के लिए, जिसने एक छोटी और / या गोल्फ लैंग सीखने की जहमत नहीं उठाई) >:। लेकिन हे, यह एक अच्छा जवाब है! :)

— निधि मोनिका का मुकदमा

Answer 2

जे, २ 27 २१

3 :'+/,y>:%:+/~*:i:y'

बहुत क्रूर: [, एन, एन] रेंज पर sqrt (xut + y over ) की गणना करता है और आइटमों की गणना करता है । अभी भी 1000 के लिए बहुत स्वीकार्य समय है।

संपादित करें : i:yकी तुलना में थोड़ा छोटा है y-i.>:+:y। धन्यवाद जेसी मिलिकन !

Comments

हा! एक अच्छा प्रदर्शन पूछने के पीछे यही विचार था! बस उत्सुक: 1000 के लिए समय क्या है?

— डॉ। बेलिसोरियस

@ सबिसिसरियस: 0.86। 10 साल पुराने हार्डवेयर पर। 2000 के लिए 3.26 एस।

— जेबी

Answer 3

रूबी 1.9, ६२ ५ 62 ५४ अक्षर

f=->r{1+4*eval((0..r).map{|i|"%d"%(r*r-i*i)**0.5}*?+)}

उदाहरण:

f[1001]
=> 3147833

t=Time.now;f[1001];Time.now-t
=> 0.003361411

Answer 4

पायथन 55 चार्ट

f=lambda n:1+4*sum(int((n*n-i*i)**.5)for i in range(n))

Comments

f=lambda n:1+4*sum(int((n*n-i*i)**.5)for i in range(n))17 अक्षर छोटा है।

— वेंटरो

Answer 5

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

f n=1+4*sum[floor$sqrt$n*n-x*x|x<-[0..n]]

क्वाड्रंट में अंक गिनता है x>=0, y>0, 4 से गुणा करता है, केंद्र बिंदु के लिए 1 जोड़ता है।

Answer 6

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

f n|w<-[-n..n]=sum[1|x<-w,y<-w,x*x+y*y<=n*n]

Comments

मैं हास्केल के लिए नया हूं: आप कैसे लिख सकते हैं w<-[-n..n]जहां (आमतौर पर) एक बूलियन मूल्य होता है?

— दोष

@flawr ये पैटर्न गार्ड हैं , जो एक पैटर्न से मेल खाने पर सफल होते हैं, लेकिन छोटी लेट के रूप में गोल्फ में इस्तेमाल किए जा सकते हैं। इस टिप को देखें ।

— xnor

धन्यवाद, मुझे इस धागे के बारे में पता नहीं था!

— दोष

Answer 7

जावास्क्रिप्ट (ईएस 6), 80 बाइट्स (गैर-प्रतिस्पर्धा क्योंकि ईएस 6 बहुत नया है)

n=>(a=[...Array(n+n+1)].map(_=>i--,i=n)).map(x=>a.map(y=>r+=x*x+y*y<=n*n),r=0)|r

वैकल्पिक संस्करण, 80 बाइट्स:

n=>[...Array(n+n+1)].map((_,x,a)=>a.map((_,y)=>r+=x*x+(y-=n)*y<=n*n,x-=n),r=0)|r

ES7 संस्करण, 80 बाइट्स:

n=>[...Array(n+n+1)].map((_,x,a)=>a.map((_,y)=>r+=(x-n)**2+(y-n)**2<=n*n),r=0)|r

Answer 8

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

f=lambda n,i=0:i>n or(n*n-i*i)**.5//1*4+f(n,i+1)

FR0DDY के समाधान की तरह , लेकिन पुनरावर्ती, और एक फ्लोट देता है। एक इंट वापस आ रहा है 51 बाइट्स:

f=lambda n,i=0:i>n or 4*int((n*n-i*i)**.5)+f(n,i+1)

Answer 9

सी (जीसीसी) , 60 बाइट्स

r,a;f(x){for(a=r=x*x;a--;)r-=hypot(a%x+1,a/x)>x;x=4*r+1;}

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

पहले चतुर्थांश पर लूप, परिणाम को 4 से गुणा करता है और एक जोड़ता है। थोड़ा कम गोल्फ वाला

r,a;
f(x){
  for(a=r=x*x;a--;)
    r-=hypot(a%x+1,a/x)>x;
  x=4*r+1;
}

Answer 10

एपीएल (डायलाग विस्तारित) , 14 बाइट्स

{≢⍸⍵≥|⌾⍀⍨⍵…-⍵}

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

i:J की निर्मिति में (-n से n तक) समावेशी सीमा का अभाव होने के बावजूद , APL विस्तारित के पास अन्य क्षेत्रों में छोटे वाक्यविन्यास हैं।

{≢⍸⍵≥|⌾⍀⍨⍵…-⍵}            Monadic function taking an argument n.
           ⍵…-⍵             n, n-1, ..., -n
      ⌾⍀                   Make a table of complex numbers
                            (equivalent to ∘.{⍺+1J×⍵} in Dyalog APL)
         ⍨                  with both real and imaginary parts from that list.
      |                       Take their magnitudes.
    ⍵≥                        1 where a magnitude are is at most n, and 0 elsewhere.
 ⍸                           Get all indices of truthy values.
≢                            Find the length of the resulting list.

Answer 11

जाप -x , 12 बाइट्स

òUn)ï Ëx²§U²

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

स्पष्टीकरण:

òUn)            #Get the range [-input ... input]
    ï           #Get each pair of numbers in that range
      Ë         #For each pair:
       x        # Get the sum...
        ²       # Of the squares
         §      # Check if that sum is less than or equal to...
          U²    # The input squared
                #Output the number of pairs that passed the check

Comments

12 बाइट्स

— झबरा

Answer 12

PHP, 85 83 बाइट्स

कोड:

function f($n){for($x=$n;$x;$c+=$x,$y++)for(;$n*$n<$x*$x+$y*$y;$x--);return$c*4+1;}

इसका परिणाम ( कई PHP संस्करणों के लिए https://3v4l.org/bC0cY देखें ):

f(1001)=3147833
time=0.000236 seconds.

अनगोल्ड कोड:

/**
 * Count all the points having x > 0, y >= 0 (a quarter of the circle)
 * then multiply by 4 and add the origin.
 *
 * Walk the lattice points in zig-zag starting at ($n,0) towards (0,$n), in the
 * neighbourhood of the circle. While outside the circle, go left.
 * Go one line up and repeat until $x == 0.
 * This way it checks about 2*$n points (i.e. its complexity is linear, O(n))
 *
 * @param int $n
 * @return int
 */
function countLatticePoints2($n)
{
    $count = 0;
    // Start on the topmost right point of the circle ($n,0), go towards the topmost point (0,$n)
    // Stop when reach it (but don't count it)
    for ($y = 0, $x = $n; $x > 0; $y ++) {
        // While outside the circle, go left;
        for (; $n * $n < $x * $x + $y * $y; $x --) {
            // Nothing here
        }
        // ($x,$y) is the rightmost lattice point on row $y that is inside the circle
        // There are exactly $x lattice points on the row $y that have x > 0
        $count += $x;
    }
    // Four quarters plus the center
    return 4 * $count + 1;
}

एक भोली कार्यान्वयन जो $n*($n+1)अंक की जांच करता है (और 1000 धीमी चलाता है लेकिन अभी भी f(1001)0.5 सेकंड से कम समय में गणना करता है) और टेस्ट सूट (प्रश्न में प्रदान किए गए नमूना डेटा का उपयोग करके) जीथब पर पाया जा सकता है ।

Answer 13

क्लोजर / क्लोजुरस्क्रिप्ट, 85 वर्ण

#(apply + 1(for[m[(inc %)]x(range 1 m)y(range m):when(<=(+(* x x)(* y y))(* % %))]4))

Brute, y अक्ष सहित पहले चतुर्थांश को बल देता है लेकिन x अक्ष को नहीं। प्रत्येक बिंदु के लिए एक 4 उत्पन्न करता है, फिर उन्हें मूल के लिए 1 के साथ जोड़ता है। 1000 के इनपुट के लिए 2 सेकंड से कम में चलता है।

forएक चर को परिभाषित करने और कुछ पात्रों को बचाने के लिए नरक से बाहर निकलता है। rangeकिसी भी वर्ण को बचाने के लिए एक उपनाम बनाने के लिए ऐसा करने से (और यह काफी धीमी गति से चलता है), और यह संभावना नहीं है कि आप एक वर्ग फ़ंक्शन बनाकर कुछ भी सहेजने जा रहे हैं।

Comments

यह काफी पुराना प्रश्न है, क्या आपको यकीन है कि इस उत्तर ने उस समय काम किया होगा?

— ब्लू

@ मड्डीफिश ने उम्र पर ध्यान नहीं दिया, बस इसे शीर्ष के पास देखा। क्लोजर प्रश्न पूर्वसूचक है, लेकिन मैं इसके इतिहास को भाषा परिवर्तनों के बारे में जानने के लिए पर्याप्त नहीं जानता।

— मट्टपुत्तनम

Answer 14

पाइके, 14 बाइट्स, गैर-प्रतिस्पर्धात्मक

QFXQX-_,B)s}}h

यहाँ यह कोशिश करो!

Answer 15

गणितज्ञ, 35 वर्ण

f[n_]:=Sum[SquaresR[2,k],{k,0,n^2}]

Https://oeis.org/A000328 से उठा

https://reference.wolfram.com/language/ref/SquaresR.html

SquaresR[2,k]दो वर्गों के योग के रूप में k का प्रतिनिधित्व करने के तरीकों की संख्या है, जो कि त्रिज्या k ^ 2 के एक वृत्त पर जाली बिंदुओं की संख्या के समान है। त्रिज्या n के एक वृत्त पर या उसके अंदर सभी बिंदुओं को खोजने के लिए k = 0 से k = n ^ 2 तक का योग।

Comments

2~SquaresR~k~Sum~{k,0,#^2}&इसे छोटा करने के लिए

— मक्खन

Answer 16

Tcl, 111 बाइट्स

lassign {1001 0 -1} r R x
while {[incr x]<$r} {set R [expr {$R+floor(sqrt($r*$r-$x*$x))}]}
puts [expr {4*$R+1}]

सरल असतत क्वाड्रेंट I पर एक्स लूप, प्रत्येक चरण में पायथागॉरियन प्रमेय का उपयोग करते हुए सबसे बड़ी वाई की गणना करता है । रिजल्ट एक से अधिक बार (केंद्र बिंदु के लिए) 4 गुना है।

कार्यक्रम का आकार आर के मूल्य पर निर्भर करता है । के {1001 0 -1}साथ बदलें "$argv 0 -1"और आप इसे r के लिए किसी भी कमांड-लाइन तर्क मान के साथ चला सकते हैं ।

कंप्यूटर्स f (1001) → 3147833.0लगभग 1030 माइक्रोसेकंड में, AMD Sempron 130 2.6GHz 64-बिट प्रोसेसर, विंडोज 7।

_{जाहिर है, बड़ा त्रिज्या, पीआई के समीप सन्निकटन: f (10000001) लगभग 30 सेकंड में 15-अंकीय मान का उत्पादन करता है, जो IEEE दोहरे की सटीकता के बारे में है।}

Answer 17

स्टैक्स , 11 बाइट्स

ä÷²M╨⌐■╝^₧░

इसे चलाएं और डीबग करें