कोड गोल्फ - π दिन

95

चुनौती

एसओ पर कोड-गोल्फ के लिए दिशानिर्देश

वर्ण का सबसे छोटा कोड वर्ण Rका उपयोग करते हुए त्रिज्या के एक चक्र का प्रतिनिधित्व प्रदर्शित करने के लिए गणना करता है *, इसके बाद character का एक अनुमान है।

इनपुट, एक संख्या है R।

चूंकि अधिकांश कंप्यूटरों में लगभग 2: 1 अनुपात लगता है, इसलिए आपको केवल आउटपुट लाइनें चाहिए, जहां yविषम हो। इसका मतलब है कि जब Rआप विषम होते हैं तो आपको R-1लाइनों को प्रिंट करना चाहिए । R=13स्पष्ट करने के लिए एक नया टेस्टकेस है ।

जैसे।

Input
    5
Output      Correct                          Incorrect

        3    *******                    4      *******
        1   *********                   2     *********
       -1   *********                   0    ***********
       -3    *******                   -2     *********
           2.56                        -4      *******
                                            3.44

संपादित करें: के विषम मूल्यों के कारण व्यापक भ्रम के कारण R, नीचे दिए गए 4 परीक्षण मामलों को पारित करने वाले किसी भी समाधान को स्वीकार किया जाएगा

Approxim के सन्निकटन द्वारा *वर्णों की संख्या से दोगुना भाग करके दिया जाता है R²।
सन्निकटन कम से कम 6 महत्वपूर्ण अंकों के लिए सही होना चाहिए।
आगे या पीछे शून्य की अनुमति दी जाती है, तो के किसी भी उदाहरण के लिए 3, 3.000000, 003की जानकारी के लिए स्वीकार किया जाता है 2और 4।

कोड गणना में इनपुट / आउटपुट (यानी, पूरा कार्यक्रम) शामिल है।

परीक्षण के मामलों

Input
    2
Output
     *** 
     *** 
    3.0

Input
    4
Output
      *****  
     ******* 
     ******* 
      *****  
    3.0

Input
    8
Output
         *******     
      *************  
     *************** 
     *************** 
     *************** 
     *************** 
      *************  
         *******     
    3.125

Input
    10
Output
          *********      
       ***************   
      *****************  
     ******************* 
     ******************* 
     ******************* 
     ******************* 
      *****************  
       ***************   
          *********      
    3.16

बोनस टेस्ट केस

Input
    13
Output

           *************       
        *******************    
       *********************   
      ***********************  
     ************************* 
     ************************* 
     ************************* 
     ************************* 
      ***********************  
       *********************   
        *******************    
           *************                                          
    2.98224852071
language-agnostic  code-golf  rosetta-stone 
— जॉन ला रोय
स्रोत
आप स्पष्ट करना चाह सकते हैं कि "इनपुट" कमांड लाइन पर है, या स्टड पर।
— ग्रेग हेवगिल
1
@ ग्रेग हेविगिल, जो भी भाषा आप उपयोग कर रहे हैं, उसके लिए सबसे सुविधाजनक चुनने के लिए स्वतंत्र महसूस करें :)
— जॉन ला रोय
@Greg Hewgill, कुछ (जो बहुत कम हैं) प्रोग्रामिंग भाषा कार्यान्वयन में "कमांड लाइन" की धारणा नहीं है।
— जोए एडम्स
1
मुझे लगता है कि उत्तर में से कुछ ही लाइनों के नियम का पालन करते हैं जहां y विषम है। R के एक विषम मान (परीक्षण मामलों में नहीं दिखाया गया है) को देखते हुए, अधिकांश उत्पादन लाइनें जहां y भी है!
— माउंटन व्यूमार्क
6
नियम का दुरुपयोग चुनौती: केवल 4 आवश्यक परीक्षण मामलों का समर्थन करके कोड बनाएं जो किसी और के कोड से कम है ।
— ब्रायन

जवाबों:

15

डीसी में: 88 और 93 93 94 96 102 105 129 138 138 141 वर्ण

बस के मामले में, मैं इस बिंदु पर OpenBSD और कुछ कथित गैर-पोर्टेबल एक्सटेंशन का उपयोग कर रहा हूं।

93 वर्ण। यह फोरट्रान समाधान (परीक्षण मामलों की तुलना में थोड़ा अलग परिणाम) के रूप में एक ही सूत्र पर आधारित है। हर Y के लिए X ^ 2 = R ^ 2-Y ^ 2 की गणना करता है

[rdPr1-d0<p]sp1?dsMdd*sRd2%--
[dd*lRr-vddlMr-32rlpxRR42r2*lpxRRAP4*2+lN+sN2+dlM>y]
dsyx5klNlR/p

88 चरस। Iterative समाधान। परीक्षण मामलों से मेल खाता है। हर X और Y चेक के लिए अगर X ^ 2 + Y ^ 2 <= R ^ 2

1?dsMdd*sRd2%--sY[0lM-[dd*lYd*+lRr(2*d5*32+PlN+sN1+dlM!<x]dsxxAPlY2+dsYlM>y]
dsyx5klNlR/p

चलाने के लिए dc pi.dc।

यहाँ एक पुराना एनोटेट संस्करण है:

# Routines to print '*' or ' '. If '*', increase the counter by 2
[lN2+sN42P]s1
[32P]s2
# do 1 row
# keeping I in the stack
[
 # X in the stack
 # Calculate X^2+Y^2 (leave a copy of X)
 dd*lYd*+ 
 #Calculate X^2+Y^2-R^2...
 lR-d
 # .. if <0, execute routine 1 (print '*')
 0>1
 # .. else execute routine 2 (print ' ')
 0!>2 
 # increment X..
 1+
 # and check if done with line (if not done, recurse)
 d lM!<x
]sx
# Routine to cycle for the columns
# Y is on the stack
[
  # push -X
  0lM- 

  # Do row
  lxx 
  # Print EOL
  10P
  # Increment Y and save it, leaving 2 copies
  lY 2+ dsY 
  # Check for stop condition
  lM >y
]sy
# main loop
# Push Input value
[Input:]n?
# Initialize registers
# M=rows
d sM
# Y=1-(M-(M%2))
dd2%-1r-sY
# R=M^2
d*sR
# N=0
0sN
[Output:]p
# Main routine
lyx
# Print value of PI, N/R
5klNlR/p
— डैन एंड्राट्टा का पता चलता है
स्रोत
1
लिनक्स dc के साथ काम नहीं करता है, लेकिन मैं यह पुष्टि कर सकता हूँ कि यह ओपनबेस पर काम करता है । बहुत बढ़िया!
— जॉन ला रोय
@ चेतावनी, हां (ऑपरेटर सुनिश्चित है कि आसान है। बहुत बुरा यह dc में अनिमित रहता है जो linux के साथ आता है
— John La Rooy
@gnibbler - "bn (3) बड़ी संख्या दिनचर्या का उपयोग करते हुए dc कमांड का एक पूर्ण पुनर्लेखन पहले OpenBSD 3.5 में दिखाई दिया।" मुझे नहीं पता था। कुछ अच्छे नए ऑपरेटर शामिल हैं, लेकिन उन्हें "गैर-पोर्टेबल एक्सटेंशन" के रूप में चिह्नित किया गया है।
— कार्लोस गुतिरेज
हाँ, एक ऑपरेटर ने अकेले 6 स्ट्रोक करने की अनुमति दी!
— डैन एंड्रीटाटा
119

C: 131 चार्ट

(जॉय द्वारा C ++ समाधान पर आधारित)

main(i,j,c,n){for(scanf("%d",&n),c=0,i|=-n;i<n;puts(""),i+=2)for(j=-n;++j<n;putchar(i*i+j*j<n*n?c++,42:32));printf("%g",2.*c/n/n);}

( विषम संख्या मामलों के समर्थन को हटाने के i|=-nलिए इसमें बदलाव करें i-=n। यह केवल चार की गिनती को 130 तक कम कर देता है।)

एक सर्कल के रूप में:

      main(i,j,
   c,n){for(scanf(
  "%d",&n),c=0,i=1|
 -n;i<n;puts(""),i+=
 0x2)for(j=-n;++j<n;
 putchar(i*i+j*j<n*n
 ?c++,0x02a:0x020));
  printf("%g",2.*c/
   n/n);3.1415926;
      5358979;}
— दर्शाता है
स्रोत
1
मुझे पसंद है कि आपने इसे एक मंडली में बदलने के लिए कोड में मंडलियों को कैसे जोड़ा। क्या +000 बेहतर होगा?
— पोटाटोसवेटर
बधाई हो, j * j ++ अपरिभाषित व्यवहार है
— बेचना
1
यह केवल एक चरित्र नहीं होगा ...?
— पोंकडूडल
1
main()चार intतर्क कैसे लेते हैं?
— डेविड आर ट्रिब्बल
2
@ लाद: ५.१.२.२.१ / १: प्रोग्राम स्टार्टअप नामक फ़ंक्शन का नाम है main। इसे परिभाषित किया जाएगा ... या कुछ अन्य कार्यान्वयन-परिभाषित तरीके से । ऐसा इसलिए है क्योंकि कार्यान्वयन इस फॉर्म को स्वीकार कर सकता है।
— kennytm
46

XSLT 1.0

बस मनोरंजन के लिए, यहाँ एक XSLT संस्करण है। वास्तव में कोड-गोल्फ सामग्री नहीं है, लेकिन यह अजीब-कार्यात्मक-XSLT तरह तरह की समस्या हल करती है :)

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:msxsl="urn:schemas-microsoft-com:xslt" >
  <xsl:output method="html"/>

  <!-- Skip even lines -->
  <xsl:template match="s[@y mod 2=0]">
    <xsl:variable name="next">
      <!-- Just go to next line.-->
      <s R="{@R}" y="{@y+1}" x="{-@R}" area="{@area}"/>
    </xsl:variable>
    <xsl:apply-templates select="msxsl:node-set($next)"/>
  </xsl:template>

  <!-- End of the line?-->
  <xsl:template match="s[@x &gt; @R]">
    <xsl:variable name="next">
      <!-- Go to next line.-->
      <s R="{@R}" y="{@y+1}" x="{-@R}" area="{@area}"/>
    </xsl:variable><!-- Print LF-->&#10;<xsl:apply-templates 
      select="msxsl:node-set($next)"/>
  </xsl:template>

  <!-- Are we done? -->
  <xsl:template match="s[@y &gt; @R]">
    <!-- Print PI approximation -->
    <xsl:value-of select="2*@area div @R div @R"/>
  </xsl:template>

  <!-- Everything not matched above -->
  <xsl:template match="s">
    <!-- Inside the circle?-->
    <xsl:variable name="inside" select="@x*@x+@y*@y &lt; @R*@R"/>
    <!-- Print "*" or " "-->
    <xsl:choose>
      <xsl:when test="$inside">*</xsl:when>
      <xsl:otherwise>&#160;</xsl:otherwise>
    </xsl:choose>

    <xsl:variable name="next">
      <!-- Add 1 to area if we're inside the circle. Go to next column.-->
      <s R="{@R}" y="{@y}" x="{@x+1}" area="{@area+number($inside)}"/>
    </xsl:variable>
    <xsl:apply-templates select="msxsl:node-set($next)"/>
  </xsl:template>

  <!-- Begin here -->
  <xsl:template match="/R">
    <xsl:variable name="initial">
      <!-- Initial state-->
      <s R="{number()}" y="{-number()}" x="{-number()}" area="0"/>
    </xsl:variable>
    <pre>
      <xsl:apply-templates select="msxsl:node-set($initial)"/>
    </pre>
  </xsl:template>
</xsl:stylesheet>

यदि आप इसका परीक्षण करना चाहते हैं, तो इसे सहेजें pi.xsltऔर IE में निम्न XML फ़ाइल खोलें:

<?xml version="1.0"?> 
<?xml-stylesheet href="pi.xslt" type="text/xsl" ?> 
<R> 
  10 
</R>
— रे डंको डर्बिएक
स्रोत
42
मेरी <आँखें> </ आँखें>! काले चश्मे, वे <do> कुछ नहीं </ do>!
— जिमी
1
डांग! मुझे डर है कि आप विशिष्टता के लिए मेरे हाइपरकार्ड समाधान को हरा सकते हैं: डी
— जॉय एडम्स
7
मुझे विश्वास नहीं हो रहा है कि आपने "ओपन ... IE" कहा
— harpo
हे, हाँ, दिन में वापस, हमारे पास केवल IE और एक्सएमएलटी के साथ एक्सएमएल हमारी सभी समस्याओं का समाधान था। पुराने अच्छे दिन! :)
— डेंको डर्बीक
XSL संस्करण 1.0 वाह, मुझे 2 संस्करण के लिए आगे देख याद है, लेकिन जब तक यह बाहर आया था मैं पहले से ही चले गए।
— २५:१० पर २:५० से ग्रेडबोट
35

पर्ल, 95 96 99 106 109 110 119 पात्र:

$t+=$;=1|2*sqrt($r**2-($u-2*$_)**2),say$"x($r-$;/2).'*'x$;for 0..
($u=($r=<>)-1|1);say$t*2/$r**2

(नई लाइन को हटाया जा सकता है और स्क्रॉलबार से बचने के लिए केवल यही है)

वाह! सर्कल संस्करण!

    $t+=$;=
 1|2*sqrt($r**
2-($u-2*$_)**2)
,say$"x($r-$;/2
).'*'x$;for 0..
($u=($r=<>)-1|1
 );$pi=~say$t*
    2/$r**2

बिन बुलाए, लंबे संस्करण के लिए:

#!/usr/bin/perl

use strict;
use warnings;
use feature 'say';

# Read the radius from STDIN
my $radius = <>;

# Since we're only printing asterisks on lines where y is odd,
# the number of lines to be printed equals the size of the radius,
# or (radius + 1) if the radius is an odd number.
# Note: we're always printing an even number of lines.
my $maxline = ($radius - 1) | 1;

my $surface = 0;

# for ($_ = 0; $_ <= $maxline; $_++), if you wish
for (0 .. $maxline) {
    # First turn 0 ... N-1 into -(N/2) ... N/2 (= Y-coordinates),
    my $y = $maxline - 2*$_;

    # then use Pythagoras to see how many stars we need to print for this line.
    # Bitwise OR "casts" to int; and: 1 | int(2 * x) == 1 + 2 * int(x)
    my $stars = 1 | 2 * sqrt($radius**2-$y**2);
    $surface += $stars;    

    # $" = $LIST_SEPARATOR: default is a space,
    # Print indentation + stars 
    # (newline is printed automatically by say)
    say $" x ($radius - $stars/2) . '*' x $stars;
}

# Approximation of Pi based on surface area of circle:
say $surface*2/$radius**2;
— व्यापारी
स्रोत
6
अब तक मैंने अपने पूरे जीवन में सबसे अधिक अपठनीय संहिता देखी है
— क्रिस मैरिसिक
13
मुझे लगता है कि आपने कभी एपीएल नहीं देखा है।
— पीटर वॉन
5
@ क्रिस मैरिसिक: क्या आपने टैग किए गए अन्य प्रश्नों / विषयों की जांच की code-golf? :) मैंने कहीं अधिक अपठनीय उदाहरण देखे हैं।
— बालुसक
3
@Peter: अधिकांश के विपरीत, मैंने एपीएल को देखा और लिखा है। इसके विशेष पात्रों के आदी होने में कुछ हफ़्ते का समय लगता है, लेकिन इसके बाद यह काफी पठनीय हो सकता है। एक-दो दशक बाद भी आदी होने के बावजूद, पर्ल अभी भी बहुत खराब है।
— जेरी कॉफिन
1
१११ $r=<>;$t+=$n=1+2*int sqrt($r**2-($u-2*$_)**2),print$"x($r-$n/2).'*'x$n.$/for(0..($u=$r-1+$r%2));print$t*2/$r**2
— चर
25

फोरट्रान - 101 शुल्क

$ f95 piday.f95 -o piday && echo 8 | ./piday



READ*,N
DO I=-N,N,2
M=(N*N-I*I)**.5
PRINT*,(' ',J=1,N-M),('*',J=0,M*2)
T=T+2*J
ENDDO
PRINT*,T/N/N
END



    READ*,N
  K=N/2*2;DO&
 I=1-K,N,2;M=&
(N*N-I*I)**.5;;
PRINT*,(' ',J=&
1,N-M),('*',J=&
0,M*2);T=T+2*J;
 ENDDO;PRINT*&
  ,T/N/N;END;
    !PI-DAY
— gnibbler
स्रोत
रुको, हालांकि मैं फोरट्रान में स्वरूपण महत्वपूर्ण था? आपके पास कॉलम 1 में पत्र हैं!
— जोएल
मैंने अभी तक जो देखा है, उससे अधिकांश लोग अभी भी Fortan77 पर अटके हुए हैं।
— जोएल
8
मुझे यह पसंद है कि सर्कल संस्करण डेथ स्टार की तरह कैसे दिखता है।
— mskfisher
22

x86 मशीन कोड: 127 बाइट्स

इंटेल असेंबलर: 490 वर्ण

    mov si,80h
    mov cl,[si]
    jcxz ret
    mov bx,10
    xor ax,ax
    xor bp,bp
    dec cx
  a:mul bx
    mov dl,[si+2]
    sub dl,48
    cmp dl,bl
    jae ret
    add ax,dx
    inc si
    loop a
    mov dl,al
    inc dl
    mov dh,al
    add dh,dh
    mov ch,dh
    mul al
    mov di,ax
  x:mov al,ch
    sub al,dl
    imul al
    mov si,ax
    mov cl,dh
  c:mov al,cl
    sub al,dl
    imul al
    add ax,si
    cmp ax,di
    mov al,32
    ja y
    or al,bl
    add bp,2
  y:int 29h
    dec cl
    jnz c
    mov al,bl
    int 29h
    mov al,13
    int 29h
    sub ch,2
    jnc x
    mov ax,bp
    cwd
    mov cl,7
  e:div di
    cmp cl,6
    jne z
    pusha
    mov al,46
    int 29h
    popa
  z:add al,48
    int 29h
    mov ax,bx
    mul dx
    jz ret
    dec cl
    jnz e
    ret

यह संस्करण बोनस परीक्षण मामले को भी संभालता है और 133 बाइट्स है:

    mov si,80h
    mov cl,[si]
    jcxz ret
    mov bx,10
    xor ax,ax
    xor bp,bp
    dec cx
  a:mul bx
    mov dl,[si+2]
    sub dl,48
    cmp dl,bl
    jae ret
    add ax,dx
    inc si
    loop a
    mov dl,al
    rcr dl,1
    adc dl,dh
    add dl,dl
    mov dh,dl
    add dh,dh
    dec dh
    mov ch,dh
    mul al
    mov di,ax
  x:mov al,ch
    sub al,dl
    imul al
    mov si,ax
    mov cl,dh
  c:mov al,cl
    sub al,dl
    imul al
    add ax,si
    cmp ax,di
    mov al,32
    jae y
    or al,bl
    add bp,2
  y:int 29h
    dec cl
    jnz c
    mov al,bl
    int 29h
    mov al,13
    int 29h
    sub ch,2
    jnc x
    mov ax,bp
    cwd
    mov cl,7
  e:div di
    cmp cl,6
    jne z
    pusha
    mov al,46
    int 29h
    popa
  z:add al,48
    int 29h
    mov ax,bx
    mul dx
    jz ret
    dec cl
    jnz e
    ret
— स्किज़
स्रोत
12
मैं StackOverflow प्यार करता हूँ!
— ज़ेनगर
2
यह दिलचस्प है कि उच्च स्तरीय भाषाओं में से कुछ में वर्णों की तुलना में कम वर्ण हैं जो इसे पैदा करता है।
— कॉलिन वॅलिएंट
3
@Alcari: यदि आप उच्च स्तरीय भाषाओं के उपयोग के लिए सभी कोड पुस्तकालयों में शामिल करते हैं, तो उनका वर्ण मायने रखता है। असेंबलर में, करना printf("%f",a/b)तुच्छ नहीं है, ऐसा करने के लिए कोई एकल निर्देश नहीं है, और मेरा कार्यान्वयन ऊपर माना जाता है कि 0 <= a / b <10 है और यह ऑपरेशन एक विभाजन है और यह कि a और b पूर्णांक हैं।
— स्किज़
19

पायथन: 101 104 107 110 वर्ण

निकोलस रिले द्वारा अन्य पायथन संस्करण के आधार पर।

r=input()
t=0
i=1
exec"n=1+int((2*i*r-i*i)**.5)*2;t+=2.*n/r/r;print' '*(r-n/2)+'*'*n;i+=2;"*r
print t

कुछ गणित के लिए AlcariTheMad को श्रेय।

आह, विषम संख्या वाले शून्य के साथ अनुक्रमित होते हैं जैसे कि मध्य, सब कुछ समझाता है।

बोनस अजगर: 115 वर्ण (जल्दी से एक साथ हैक)

r=input()
t=0
i=1
while i<r*2:n=1+int((2*i*r-i*i)**.5)*2;t+=2.*n/r/r;print' '*(r-n/2)+'*'*n;i+=2+(r-i==2)*2
print t
— lunixbochs
स्रोत
वाह, हाँ, '+' बीट्स -1 और, किसी भी दिन। फिर भी एक और तकनीक मैंने अपने दिमाग से बाहर कर दी क्योंकि यह लगभग कभी भी सही काम नहीं है :-)
— निकोलस रिले
मैंने अतीत में सी का उपयोग किया है, और कभी पायथन को भी नहीं देखा। यह 104 वर्ण ऊपर C ++ की तुलना में अधिक पठनीय है। गजब का। शायद मुझे अजगर सीखना चाहिए ...
— डीन राथर
@ डीन: पायथन के मुख्य लक्ष्यों में से एक पढ़ना और लिखना आसान है।
— कॉलिन वॅलिएंट
क्या आपके पास अपने 104 चार उत्तर के साथ भी निष्पादन का उपयोग करने के बारे में है? :)
— जॉन ला रोय
मुझे अपनी खुद की कम्प्रेशन - ज़ालिब, मार्शालिंग, इत्यादि को रोल करने की आवश्यकता होगी, सभी वास्तविक कोड से बड़े थे।
— lunixbochs
12

शक्ति कोशिका, 119 113 109 अक्षर

($z=-($n=$args[($s=0)])..$n)|?{$_%2}|%{$l="";$i=$_
$z|%{$l+=" *"[$i*$i+$_*$_-lt$n*$n-and++$s]};$l};2*$s/$n/$n

और यहाँ एक prettier संस्करण है:

( $range = -( $R = $args[ ( $area = 0 ) ] ) .. $R ) | 
  where { $_ % 2 } |
  foreach {
    $line = ""
    $i = $_
    $range | foreach {
        $line += " *"[ $i*$i + $_*$_ -lt $R*$R -and ++$area ]
    }
    $line
 }
 2 * $area / $R / $R
— रे डंको डर्बिएक
स्रोत
@ थोर: मुझे आशा है कि नहीं, लेकिन यह मेरे द्वारा लिखी गई सबसे बदसूरत चीज होनी चाहिए :)
— डैंको डर्बीच
3
उस प्रिटियर संस्करण के लिए धन्यवाद =)
— थोर होवदेन
10

HyperTalk: 237 वर्ण

इंडेंटेशन की आवश्यकता नहीं है और न ही गिना जाता है। यह स्पष्टता के लिए जोड़ा जाता है। यह भी ध्यान दें कि हाइपरकार्ड 2.2 उन गैर-एएससीआईआई रिलेशनल ऑपरेटरों को स्वीकार करता है जिनका मैंने उपयोग किया था।

function P R
  put""into t
  put 0into c
  repeat with i=-R to R
    if i mod 2≠0then
      repeat with j=-R to R
        if i^2+j^2≤R^2then
          put"*"after t
          add 1to c
        else
          put" "after t
        end if
      end repeat
      put return after t
    end if
  end repeat
  return t&2*c/R/R
end P

चूंकि हाइपरकार्ड 2.2 स्टड / स्टडआउट का समर्थन नहीं करता है, इसके बजाय एक फ़ंक्शन प्रदान किया जाता है।

— दर्शाता है
स्रोत
1
हाइपरकार्ड, श्री एडम्स? गंभीरता से? यह बेहद अप्रत्याशित है।
— कावा
1
@ कावा: इसीलिए मैंने इसे पोस्ट किया :), इसके अलावा, कोड गोल्फ एक अच्छा तरीका है जिससे मैं भविष्य में हाइपरटॉक इंटरप्रेटर लिखने का फैसला करता हूं।
— जॉय एडम्स
हा! मैं देखना चाहता हूं कि, XD
— कावा
यदि आप कभी भी उस दुभाषिया को लिखने का निर्णय लेते हैं, या किसी मौजूदा काम में शामिल होना चाहते हैं, तो मुझे बताएं और मैं इसका उल्लेख hypercard.org पर कर सकता हूं और मुझे इस बारे में उत्सुकता होगी कि यह कैसे होता है :-)
— uliwitness
10

C #: 209 202 201 वर्ण:

using C=System.Console;class P{static void Main(string[]a){int r=int.Parse(a[0]),s=0,i,x,y;for(y=1-r;y<r;y+=2){for(x=1-r;x<r;s+=i)C.Write(" *"[i=x*x+++y*y<=r*r?1:0]);C.WriteLine();}C.Write(s*2d/r/r);}}

unminified:

using C = System.Console;
class P {
  static void Main(string[] arg) {
    int r = int.Parse(arg[0]), sum = 0, inside, x, y;
    for (y = 1 - r; y < r; y += 2) {
      for (x = 1 - r; x < r; sum += inside)
        C.Write(" *"[inside = x * x++ + y * y <= r * r ? 1 : 0]);
      C.WriteLine();
    }
    C.Write(sum * 2d / r / r);
  }
}
— गुफ़ा
स्रोत
मैं C # को बहुत अधिक नहीं जानता, लेकिन क्या आपको ( string[]aऔर 1-rइसके बजाय -1+r) उपयोग करने में सक्षम नहीं होना चाहिए ?
— kennytm
@ केनी: आप सही कह रहे हैं। :) कि तीन पात्रों को बचाता है, और फिर मैं पाँच और छुटकारा पाने में कामयाब रहा।
— गुफ़ा
देखा कि पहली बात, पूरी तरह से बात पर याद किया -r+1।
— डायकम
4
इसके अलावा, धब्बेदार x*xx+++y*yभी, लेकिन यह पहली नज़र में विच्छेद करने के लिए एक पागल बात है।
— डायकम
मैंने एक और बाइट को खत्म करने की स्वतंत्रता ले ली ;-)
— जॉय
10

हास्केल 139 145 147 150 230 वर्ण:

x True=' ';x _='*'
a n=unlines[[x$i^2+j^2>n^2|j<-[-n..n]]|i<-[1-n,3-n..n]]
b n=a n++show(sum[2|i<-a n,i=='*']/n/n)
main=readLn>>=putStrLn.b

विषम संख्याओं को संभालना: 148 वर्ण:

main=do{n<-readLn;let{z k|k<n^2='*';z _=' ';c=[[z$i^2+j^2|j<-[-n..n]]|i<-[1,3..n]];d=unlines$reverse c++c};putStrLn$d++show(sum[2|i<-d,i=='*']/n/n)}

150 वर्ण: (C संस्करण पर आधारित)

a n=unlines[concat[if i^2+j^2>n^2then" "else"*"|j<-[-n..n]]|i<-[1-n,3-n..n]]
main=do n<-read`fmap`getLine;putStr$a n;print$2*sum[1|i<-a n,i=='*']/n/n

230 वर्ण:

main = do {r <-read`fmap`getLine; let {p = putStr; d = 2 / fromIntegral r ^ 2; lyn = let cmx = if x> r तो p "\ n" >> अन्य को लौटाएं अगर x * x + y * y <r * r तब p "*"> c (m + d) (x + 1) और p "" >> cm (x + 1) यदि y> r में है तो n और cn प्रिंट करें (-r) >> = एल (y + 2)}; एल (1-r`mod`2-आर) 0}

unminified:

main = do r <- पढें `fmap` getLine
          let p = putStr
              d = 2 / से Integral r ^ 2
              lyn = let cmx = if x> r
                                  फिर पी "\ n" >> एम वापस
                                  और अगर x * x + y * y <r * r
                                       तब p "*" >> c (m + d) (x + 1)
                                       और पी "" >> सेमी (x + 1)
                      अगर में y> आर
                         फिर एन प्रिंट करें
                         और cn (-r) >> = l (y + 2)
          l (1-r`mod`2-r) 0

मैं उम्मीद कर रहा था कि यह कुछ अनिवार्य संस्करणों को हरा देगा, लेकिन मैं इसे इस बिंदु पर आगे संकुचित नहीं कर सकता।

— स्टीव
स्रोत
"डी" से छुटकारा पाने के लिए 2 से काट लें और इसके बजाय 1 जोड़ दें और फिर "2 * n / fromIntegral r ^ 2" प्रिंट करें
— स्टीव
कुछ हस्केल चाल के माध्यम से 3 वर्णों को बंद कर दिया। मुझे पसंद है कि हास्केल में अक्सर कई लाइनों (न्यूलाइन बनाम सेमीकोलन) की कोई कीमत नहीं होती है और इसलिए हमारा कोड-गोल्फ आमतौर पर पठनीय होता है!
— १०:२६ पर MtnViewMark
कड़ाई से बात करें, तो 145-चार संस्करण केवल तभी काम करता है यदि इनपुट सम है। लेकिन बहुत अच्छा तरीका है।
— स्टीव
I / O लाइन को छोटा किया। यह अभी भी संभव है कि फ़ंक्शन दोषों को मुख्य = do {... {{}} ...}} ब्लॉक में धकेलकर कुछ और पात्रों को सहेजना संभव हो, मुझे लगता है।
— comingstorm
@ आगामी तूफान: अच्छा! मैं readLn के बारे में नहीं जानता था। यह कई हास्केल कोड-गोल्फ में मदद करेगा। @Steve: हाँ, मैं अभी भी इसे ठीक करने के लिए सबसे कुशल तरीका निकालने की कोशिश कर रहा हूं।
— माउंटन व्यूमार्क
10

रूबी, 96 वर्ण

(गुफ़ा के # समाधान पर आधारित):

r=gets.to_f
s=2*t=r*r
g=1-r..r
g.step(2){|y|g.step{|x|putc' * '[i=t<=>x*x+y*y];s+=i}
puts}
p s/t

109 चार्ट (बोनस):

r=gets.to_i
g=-r..r
s=g.map{|i|(g.map{|j|i*i+j*j<r*r ?'*':' '}*''+"\n")*(i%2)}*''
puts s,2.0/r/r*s.count('*')
— म्लाडेन जाबलानोविक को दर्शाता है
स्रोत
धन्यवाद! मैं यह देखने के लिए शर्मिंदा हूं कि बिना पढ़े रूबी कैसे हो सकता है ... :)
— मैडलेन जाबलानोविक
आप p sइसके बजाय puts s:)
— जॉन ला रोय
1
वहाँ में अच्छे नए विचार - मुझे यह पसंद है कि आप 2 अलग-अलग स्टेप साइज़ के साथ g का उपयोग कर रहे हैं और <=> कोड को तार्किक से बदलने से बचने के लिए
— John La Rooy
8

आप लोग बहुत कठिन तरीके से सोच रहे हैं।

switch (r) {
   case 1,2:
      echo "*"; break;
   case 3,4:
      echo " ***\n*****\n ***"; break;
   // etc.
}
— मैट हगिन्स
स्रोत
8
कैरेक्टर काउंट थोड़ा हाथ से निकल जाता है, क्या आपको नहीं लगता? :)
— जॉन ला रोय
7
पैमाना नहीं है। Unmaintainable!
— स्पॉल्सन
मैंने यथासंभव परीक्षण मामले को धोखा देने की कोशिश की और यह अभी भी मेरे वास्तविक समाधान से थोड़ा बड़ा है: P
— lunixbochs
5
+1, हमेशा सबसे स्पष्ट बात पहले करें ... यदि कोई इसे पसंद नहीं करता है, तो जोर से शिकायत करें कि कल्पना पर्याप्त स्पष्ट नहीं है
— मिजिपज़ोर
ब्रायन परीक्षण मामलों आवरण विशेष पर एक अर्द्ध गंभीर प्रयास, आप वोट दें चाहिए था उसकी भी अगर आप इस सवाल का जवाब की तरह;) stackoverflow.com/questions/2457995
— जॉन ला Rooy
7

जे: 47 , 46 , 45

अन्य समाधानों के रूप में एक ही मूल विचार, अर्थात r ^ 2 <= x ^ 2 + y ^ 2 , लेकिन J की सरणी-उन्मुख संकेतन अभिव्यक्ति को सरल करता है:

c=:({&' *',&":2*+/@,%#*#)@:>_2{.\|@j./~@i:@<:

आप इसे पसंद करेंगे c 2या c 8या c 10आदि।

बोनस: 49

विषम इनपुट को संभालने के लिए, उदाहरण के लिए 13, हमें आउटपुट के हर दूसरी पंक्ति को लेने के बजाय विषम-मूल्यवान x निर्देशांक पर फ़िल्टर करना होगा (क्योंकि अब सूचकांक या तो एक या विषम संख्या में शुरू हो सकते हैं)। यह सामान्यीकरण हमें 4 वर्णों की लागत देता है:

c=:*:({&' *'@],&":2%(%+/@,))]>(|@j./~2&|#])@i:@<:

Deminimized संस्करण:

c =: verb define
  pythag   =. y > | j./~ i:y-1    NB.  r^2 > x^2 + y^2
  squished =. _2 {.\ pythag       NB.  Odd rows only
  piApx    =. (2 * +/ , squished) %  y*y
  (squished { ' *') , ": piApx
)

J Forums पर Marshall Lochbam के कारण सुधार और सामान्यीकरण ।

— ब्रॉन डैन ब्रॉन
स्रोत
5

अजगर: 118 अक्षर

बहुत सुंदर पर्ल संस्करण का एक सीधा बंदरगाह है।

r=input()
u=r+r%2
t=0
for i in range(u):n=1+2*int((r*r-(u-1-2*i)**2)**.5);t+=n;print' '*(r-n/2-1),'*'*n
print 2.*t/r/r
— निकोलस रिले को दर्शाता है
स्रोत
Python2 के लिए आप बस इस्तेमाल कर सकते हैंr=input()
— John La Rooy
आप के बीच की जगह की जरूरत नहीं है printऔर' '
— जॉन ला Rooy
ठीक है, यह डरावना है, यह अब पर्ल संस्करण से छोटा है। (मैं पूरी तरह से "इनपुट" को अपने दिमाग से बाहर निकालता हूं क्योंकि यह बहुत असुरक्षित है ...)
— निकोलस रिले
4

C ++: 169 वर्ण

#include <iostream>
int main(){int i,j,c=0,n;std::cin>>n;for(i=-n;i<=n;i+=2,std::cout<<'\n')for(j=-n;j<=n;j++)std::cout<<(i*i+j*j<=n*n?c++,'*':' ');std::cout<<2.*c/n/n;}

unminified:

#include <iostream>
int main()
{
    int i,j,c=0,n;
    std::cin>>n;
    for(i=-n;i<=n;i+=2,std::cout<<'\n')
        for(j=-n;j<=n;j++)
            std::cout<<(i*i+j*j<=n*n?c++,'*':' ');
    std::cout<<2.*c/n/n;
}

(हाँ, std का उपयोग :: उपयोग के बजाय using namespace stdकम वर्ण)

यहां आउटपुट मूल पोस्ट में परीक्षण के मामलों से मेल नहीं खाता है, इसलिए यहां एक है जो करता है (पठनीयता के लिए लिखा गया है)। इसे संदर्भ कार्यान्वयन पर विचार करें (यदि Poita_ बुरा नहीं मानता):

#include <iostream>
using namespace std;

int main()
{
    int i, j, c=0, n;
    cin >> n;
    for(i=-n; i<=n; i++) {
        if (i & 1) {
            for(j=-n; j<=n; j++) {
                if (i*i + j*j <= n*n) {
                    cout << '*';
                    c++;
                } else {
                    cout << ' ';
                }
            }
            cout << '\n';
        }
    }
    cout << 2.0 * c / n / n << '\n';
}

C ++: 168 वर्ण (आउटपुट के साथ मेरा मानना ​​है कि सही है)

#include <iostream>
int main(){int i,j,c=0,n;std::cin>>n;for(i=-n|1;i<=n;i+=2,std::cout<<"\n")for(j=-n;j<=n;j++)std::cout<<" *"[i*i+j*j<=n*n&&++c];std::cout<<2.*c/n/n;}
— पीटर अलेक्जेंडर
स्रोत
कोड -n से n तक लूप होता है, इसलिए उदाहरण 4 के इनपुट के लिए यह 9 का व्यास प्रदर्शित करता है, 7 नहीं जैसा कि परीक्षण मामलों में दिखाया गया है।
— गुफ़ा
क्या यह एक आवश्यकता है कि आपका सर्कल ओपी से बिल्कुल मेल खाता है ?
— पीटर एलेक्जेंडर
3
आप इसे बदलने की इच्छा कर सकते हैं #include <iostream.h>जो मूल रूप से #include <iostream> -- using namespace std;पुराने सी ++ कंपाइलर्स के साथ संगतता के लिए है।
— अर्लज़
1
@Carlos, मैंने उस विशेष बिट को नहीं लिखा, लेकिन यह एक द्विआधारी और ऑपरेटर है। यह जांचता है कि अंतिम बिट सेट है, जो करने के बराबर है i%2, लेकिन "तेज" है। यह वास्तव में तेज़ नहीं है क्योंकि कंपाइलर इसे वैसे भी करेगा।
— पीटर अलेक्जेंडर
1
@Poita_: वास्तव में, मैं% 2 और i और 1 नकारात्मक संख्याओं के साथ अलग व्यवहार करता है। (-1) & 1 1 है, जो हम यहां चाहते हैं। (-1)% 2 मेरे सिस्टम पर -1 है, और यह C99 के अनुरूप है। इस प्रकार, हालांकि अगर (i & 1) और अगर (i% 2) एक ही काम करेंगे, तो किसी को अगर (i% 2 == 1) से सावधान रहना चाहिए, जो कि नकारात्मक होने पर काम नहीं करेगा।
— जोए एडम्स
3

PHP: 126 132 138

(गुफ़ा सी # समाधान पर आधारित)

126:

for($y=1-($r=$argv[1]);$y<$r;$y+=2,print"\n")for($x=1-$r;$x<$r;$s+=$i,++$x)echo($i=$x*$x+$y*$y<=$r*$r)?'*':' ';echo$s*2/$r/$r;

132:

for($y=1-($r=$argv[1]);$y<$r;$y+=2){for($x=1-$r;$x<$r;@$s+=$i,++$x)echo($i=$x*$x+$y*$y<=$r*$r?1:0)?'*':' ';echo"\n";}echo$s*2/$r/$r;

138:

for($y=1-($r=$argv[1]);$y<$r;$y+=2){for($x=1-$r;$x<$r;@$s+=$i){$t=$x;echo($i=$t*$x++ +$y*$y<=$r*$r?1:0)?'*':' ';}echo"\n";}echo$s*2/$r/$r;

वर्तमान पूर्ण:

for( $y = 1 - ( $r = $argv[1]); $y < $r; $y += 2, print "\n")
    for( $x = 1-$r; $x < $r; $s += $i, ++$x)
        echo( $i = $x*$x + $y*$y <= $r*$r) ? '*' : ' ';
echo $s*2 /$r /$r;

@पहले बिना हो सकता है, $sलेकिन केवल error_reporting के साथ 0 पर सेट किया गया है (नोटिस आउटपुट सर्कल को गड़बड़ कर रहा है)

— देव-नल-निवासी का पता चलता है
स्रोत
इको $ s * 2 / $ r / $ r में / $ r क्या करता है;
— davidosomething
OHH विभाजन ... रिक्ति ने मुझे फेंक दिया, सोचा कि यह कुछ ऑपरेटर शॉर्टहैंड था जिसे मैंने कभी नहीं देखा
— davidosomething
3

रूबी 1.8.x, 93

r=$_.to_f
q=0
e=r-1
(p(('*'*(n=1|2*(r*r-e*e)**0.5)).center r+r)
q+=n+n
e-=2)while-r<e
p q/r/r

साथ दौड़ो $ ruby -p piday

— DigitalRoss को दर्शाता है
स्रोत
एक अच्छी बात है, लेकिन यह
— जॉन ला रोय
यह 1.9.1 में काम नहीं करता है, और सर्कल के चारों ओर दोहरे उद्धरण प्रिंट करता है।
— म्लाडेन Jablanović
गोल्फ कार्यक्रमों के लिए सामान्य रूप से अलग-अलग भाषा स्तरों पर काम नहीं करना सामान्य है। भाषा के हर संस्करण पर कितने पर्ल या पायथन cg का काम है? यह दिलचस्प है, हालांकि, इस कारण से पता चलता है क्योंकि Integer|Floatअब 1.9 पर फ्लोट के लिए जोर नहीं देता है।
— DigitalRoss
3

एपीएल: ५ ९

यह फ़ंक्शन एक संख्या को स्वीकार करता है और दो अपेक्षित आइटम लौटाता है। बोनस मामलों में सही ढंग से काम करता है।

{⍪(⊂' *'[1+m]),q÷⍨2×+/,m←(2|v)⌿(q←⍵*2)>v∘.+v←2*⍨⍵-⍳1+2×⍵-1}

बोली Dyalog APL है, जिसमें डिफ़ॉल्ट सूचकांक मूल है। कौशल स्तर नौसिखिया है , इसलिए यदि कोई भी एपीएल गुरु इसे 10 पात्रों तक लाना चाहता है, तो मेरे अतिथि बनें!

आप इसे एपीएल पर ऑनलाइन आज़मा सकते हैं , बस इसे पेस्ट कर सकते हैं और इसके बाद एक नंबर डाल सकते हैं:

   {⍪(⊂' *'[1+m]),q÷⍨2×+/,m←(2|v)⌿(q←⍵*2)>v∘.+v←2*⍨⍵-⍳1+2×⍵-1} 13
      *************
   *******************
  *********************
 ***********************
*************************
*************************
*************************
*************************
 ***********************
  *********************
   *******************
      *************
2.98225
— टोबिया का पता चलता है
स्रोत
हालांकि मुझे एपीएल का पता नहीं है, लेकिन यह जे संस्करण की तुलना में सुंदर दिखता है।
— आह्लाद
@ आहाला। एपीएल सुंदर, वैचारिक और सौंदर्य दोनों तरह से है। मैंने J सीखना शुरू किया, लेकिन यादृच्छिक ASCII पागलपन द्वारा बंद कर दिया गया था। एक अच्छी आत्मा ने Node.js (npm install apl) के लिए एक खुला स्रोत APL दुभाषिया लिखा जो बहुत अच्छा है। यह उपरोक्त कोड को केवल एक मामूली परिवर्तन (कोई मोनैडिक ⍪, 2 डी चार) के साथ गणना करता है । आप सभी विक्रेता साइटों पर अच्छे एपीएल प्रलेखन पा सकते हैं, जैसे कि डायलॉग।
— टोबिया जूल
2

पायथन: 148 वर्ण।

विफल (यानी पर्याप्त कम नहीं) नियमों का दुरुपयोग करने और परीक्षण के मामलों को हार्डकोड करने का प्रयास, जैसा कि मैंने मूल पोस्ट के जवाब में उल्लेख किया है। अधिक क्रियात्मक भाषा के साथ इसका दुरुपयोग करना आसान हो सकता है:

a=3.0,3.125,3.16
b="1","23","3677","47899"
r=input()
for i in b[r/3]+b[r/3][::-1]:q=1+2*int(i);print ' '*(int(b[r/3][-1])-int(i))+'*'*q
print a[r/5]
— ब्रायन
स्रोत
2

बीसी: १६५ , १२c , १२६ चर

पायथन संस्करण के आधार पर। 

r=read()
for(i=-1;r*2>i+=2;scale=6){n=sqrt(2*i*r-i*i)
scale=0
n=1+n/1*2
j=r-n/2
t+=2*n
while(j--)" "
while(n--)"*"
"
"}
t/r/r

(अंतिम पंक्ति के बाद नई लाइन को यहां छोड़ा नहीं जा सकता है।)

— रेव्स प्रमोक
स्रोत
1
127 वर्ण: r = पढ़ा (); के लिए (i = 1; मैं <r * 2; स्केल = 6) {n = sqrt (2 * i r-i i); स्केल = 0; n = 1 + n / 1 * 2 ; i + = 2; j = rn / 2; t + = 2 * n; जबकि (j--) ""; जबकि (n -) "*"; ""}; t / r / r
— कार्लोस Gutiérrez
यहाँ एकमात्र समस्या यह है कि यह अब 0 के लिए विफल रहता है, लेकिन वर्तमान नियमों के अनुसार, यह ठीक है।
— प्रेजेमॉक
2

जावास्क्रिप्ट (स्पाइडरमोनी) - 118 वर्ण

यह संस्करण स्टड से इनपुट स्वीकार करता है और बोनस परीक्षण मामलों को पास करता है

r=readline()
for(t=0,i=-r;i<r;i++)if(i%2){for(s='',j=-r;j<r;j++){t+=q=i*i+j*j<r*r
s+=q?'*':' '}print(s)}print(t*2/r/r)

उपयोग: cat 10 | js thisfile.js - jsbin पूर्वावलोकन प्रिंट / रीडलाइन के लिए एक उपनाम जोड़ता है ताकि आप ब्राउज़र में देख सकें

जावास्क्रिप्ट: 213 163

अपडेट किया गया

r=10;m=Math;a=Array;t=0;l=document;for(i=-r;i<r;i+=2){w=m.floor(m.sqrt(r*r-i*i)*2);t+=w*2;l.writeln(a(m.round(r-w/2)).join(' ')+a(w).join('*'));}l.writeln(t/(r*r))

किसी ने नहीं कहा कि इसे ब्राउज़र में सही ढंग से प्रस्तुत करना था - बस आउटपुट। जैसे मैंने पूर्व टैग हटा दिया है और इसे आगे अनुकूलित किया है। आउटपुट को देखने के लिए आपको जनरेट किए गए स्रोत को देखने या उसके अनुसार अपनी स्टाइलशीट सेट करने की आवश्यकता है। पाई इस तरह कम सटीक है, लेकिन यह अब कल्पना करना है।

r=10;m=Math;a=Array;t=0;s='';for(i=-r;i<r;i++){w=m.floor((m.sqrt(m.pow(r,2)-m.pow(i,2)))*2);t+=w;if(i%2){z=a(m.round(r-w/2)).join(' ')+a(w).join('*');s+=z+'\n';}}document.write('<pre>'+(s+(t/m.pow(r,2)))+'</pre>')

unminified:

r=10;
m=Math;
a=Array;
t=0;
s='';
for(i=-r;i<r;i++){
    w=m.floor((m.sqrt(m.pow(r,2)-m.pow(i,2)))*2);
    t+=w;
    if(i%2){
    z=a(m.round(r-w/2)).join(' ')+a(w).join('*');
    s+=z+'\n';
    }
}
document.write('<pre>'+(s+(t/m.pow(r,2)))+'</pre>');
— Iain फ्रेजर
स्रोत
1

जावा: २३४

class C{public static void main(String[] a){int x,y,s=0,r=Integer.parseInt(a[0]);for(y=1-r;y<r;y+=2){for(x=1-r;x<r;++x){boolean b=x*x+y*y<=r*r;s+=b?1:0;System.out.print(b?'*':' ');}System.out.println();}System.out.println(s*2d/r/r);}}

unminified:

class C{
    public static void main(String[] a){
        int x,y,s=0,r=Integer.parseInt(a[0]); 
        for(y=1-r;y<r;y+=2){
            for(x=1-r;x<r;++x) {
                boolean b=x*x+y*y<=r*r;
                s+=b?1:0;
                System.out.print(b?'*':' ');
            }
            System.out.println();
        }
        System.out.println(s*2d/r/r);
    }
}
— dogbane
स्रोत
शायद इसे बचाने के लिए ~ 50 अक्षर scala में लिख सकते हैं
— rwyland
1

GAWK: 136 , 132 , 126 , 125 वर्ण

पायथन संस्करण के आधार पर।

{r=$1
for(i=-1;r*2>i+=2;print""){n=1+int((2*i*r-i*i)**.5)*2
t+=2*n/r/r
printf"%*s",r-n/2,""
while(n--)printf"%c","*"}print t}
— रेव्ज प्रमोक
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.