ASCII सूर्य का विस्तार करें

Question

एक प्रोग्राम लिखें जो (STDIN / कमांड लाइन के माध्यम से) एक गैर-नकारात्मक पूर्णांक एन।

जब N 0 होता है, तो आपके प्रोग्राम को प्रिंट करना चाहिए O(वह कैपिटल ओह है, शून्य नहीं)।

जब N 1 हो, तो आपका प्रोग्राम प्रिंट होना चाहिए

\|/
-O-
/|\

जब N 2 हो तो आपका प्रोग्राम प्रिंट होना चाहिए

\ | /
 \|/
--O--
 /|\
/ | \

जब N 3 हो तो आपका प्रोग्राम प्रिंट होना चाहिए

\  |  /
 \ | /
  \|/
---O---
  /|\
 / | \
/  |  \

बड़े एन के लिए, यह पैटर्न उसी सटीक फैशन में जारी है। "सूर्य" के आठ किरणों से प्रत्येक उचित के एन के प्रयास किए जाने चाहिए -, |, /, या \अक्षर।

विवरण

• एक कार्यक्रम के बजाय, आप एक फ़ंक्शन लिख सकते हैं जो पूर्णांक लेता है। फ़ंक्शन को सामान्य रूप से सूर्य के डिज़ाइन को प्रिंट करना चाहिए या इसे स्ट्रिंग के रूप में वापस करना चाहिए।

• आपको भी होना चाहिए

  • कोई अनुगामी स्थान नहीं है, या
  • केवल पर्याप्त अनुगामी स्थान हैं इसलिए पैटर्न एक पूर्ण (2N + 1) * (2N + 1) आयत है।

• किसी भी या सभी एन के लिए आउटपुट वैकल्पिक रूप से एक अनुगामी न्यूलाइन हो सकता है।

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

एक अग्रणी नईलाइन की अनुमति है? विशेष रूप से दिलचस्प है N=0।

— जकुबे

@ जाकुब नं। केवल अनुगामी।

— केल्विन के शौक

Answer 1

पायथ, 39 38 36 बाइट्स

jbXmXXj\|m*\ Q2d\\_hd\/JhyQQX*\-JQ\O

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

व्याख्या

jbXmXXj\|m*\ Q2d\\_hd\/JhyQQX*\-JQ\O   implicit: Q = input
                       JhyQ            J = 1 + 2*Q
    m                  J               map each d of [0,1,...,2*Q] to:
          *\ Q                           " "*input
         m    2                          list with twice " "*input
      j\|                                join this list by "|"
     X         d\\                       replace the value at d to "\"
    X             _hd\/                  replace the value at -(d+1) to "/"
  X                        Q           replace line Q by:
                             *\-J        "-"*J
                            X    Q\O     replace element at Q with "O"
jb                                     join by "newlines"

एक और 36 बाइट्स समाधान होगा:

jbmXXj\|m*?\-KqdQ\ Q2d\\_hd?\OK\/hyQ

Answer 2

C: 116 102 99 95 95 92 90

s(n){for(int c=-n,r=c;r<=n;c++)putchar(c>n?c=-c,r++,10:c?r?c-r?c+r?32:47:92:45:r?124:79);}

मुझे लगता है कि मैं इस दृष्टिकोण का उपयोग कर एक न्यूनतम समाधान के काफी करीब पहुंच रहा हूं, लेकिन मैं यह महसूस करना बंद नहीं कर सकता कि सी। अनगुल्फेड में बहुत बेहतर दृष्टिकोण है:

void s(int n) {
  for(
    int c = -n, r = c;
    r <= n;
    c++
  )
    putchar(
      c > n
        ? c = -c, r++, '\n'
        : c
          ? r
            ? c - r
              ? c + r
                ? ' '
                : '/'
              : '\\'
            : '-'
          : r
            ? '|'
            : 'O'
    );
}

Comments

"सी ++" में सी ... हे!

— bjb568

मुझे खुशी है कि आपने इसे अनफॉलो किया। यदि वे पागल हैं तो वे त्रिशूल!

— ldam

आप 2 और बाइट्स बचा सकते हैं और इसे vc 2012 के अनुरूप बना सकते हैं;)c,r;s(n){for(r=c=-n;r<=n;c++)putchar(c>n?c=-c,r++,10:c?r?c-r?c+r?32:47:92:45:r?124:79);}

— जोहान डू टिट

Answer 3

GNU सेड, 252 + 1

भतीजी - मैंने php उत्तर को हरा दिया!

-rपैरामीटर का उपयोग करने के लिए स्कोर + 1 ।

सीड लिमिट्स की वजह से, हमें लगभग 100 बाइट्स जलानी पड़ती हैं, बस एन को एन स्पेस के स्ट्रिंग में बदल दें। बाकी मज़ेदार सामान है।

/^0/{y/0/O/;q}
s/./<&/g
s/9/8 /g
s/8/7 /g
s/7/6 /g
s/6/5 /g
s/5/4 /g
s/4/3 /g
s/3/2 /g
s/2/1 /g
s/1/ /g
s/0//g
:t
s/ </<          /g
tt
s/<//g
:
s/ //
s^.*^\\&|&/^;ta
:a
/\\$/q
p
s^\\\|/^-O-^;tn
s^(\\)? (/)?^\2 \1^g;ta
:n
y/ /-/
p
s^-O-^/|\\^
y/-/ /
ta

व्याख्या

• पहली पंक्ति एन = 0 मामले के लिए एक प्रारंभिक निकास है।
• अगली 15 लाइनें (अप करने के लिए :) N को N रिक्त स्थान के स्ट्रिंग में परिवर्तित करती हैं
• s/ // एक स्थान को हटाता है
• s^.*^\\&|&/^;taN-1 रिक्त स्थान को: \+ N-1 रिक्त स्थान + |+ N-1 रिक्त स्थान + में कनवर्ट करता है/
• Iterate, प्रत्येक पुनरावृत्ति को मुद्रित करना, और \एक स्थान को दाईं ओर और /एक स्थान को बाईं ओर ले जाना ...
• ... जब तक हम से मेल खाते हैं \|/, जो साथ बदल दिया है -O-और करने के लिए कूद nलेबल
• के साथ बदलें -और प्रिंट करें
• के -0-साथ बदलें /|\, और साथ बदलें -और मुख्य लूप में वापस कूदें
• Iterate, प्रत्येक पुनरावृत्ति को मुद्रित करना, और \एक स्थान को दाईं ओर और /एक स्थान को बाईं ओर ले जाना ...
• ... जब तक हम मेल खाते हैं \$जो इंगित करता है कि समाप्त हो गया था, और छोड़ दिया।

उत्पादन

 $ for i in {0..3}; do sed -rf asciisun.sed <<< $i ; done
 O
 \|/
 -O-
 /|\
 \ | /
  \|/ 
 --O--
  /|\ 
 / | \
 \  |  /
  \ | / 
   \|/  
 ---O---
   /|\  
  / | \ 
 /  |  \
 $

Answer 4

जे, 37 34 40 बाइट्स

1:echo('O\/-|'{.@#~0=+&|,-,+,[,])"*/~@i:

उपयोग:

   (1:echo('O\/-|'{.@#~0=+&|,-,+,[,])"*/~@i:) 2  NB. prints to stdout:
\ | /
 \|/ 
--O--
 /|\ 
/ | \

स्पष्टीकरण (बाएं से दाएं):

• i: सूची बनाता है -n, -(n-1), ..., n-1, n

• ( )"*/~@i:मैं के डेसकार्टेस उत्पाद बनाता है: एक मैट्रिक्स व्यवस्था में खुद के साथ, उदाहरण के लिए n = 1निम्न 3-by-3मैट्रिक्स बनाता है

  ┌─────┬────┬────┐
  │-1 -1│-1 0│-1 1│
  ├─────┼────┼────┤
  │0 -1 │0 0 │0 1 │
  ├─────┼────┼────┤
  │1 -1 │1 0 │1 1 │
  └─────┴────┴────┘
  

• पूर्णांक वाले प्रत्येक मैट्रिक्स-तत्व के लिए x yहम निम्नलिखित करते हैं

• +&|,-,+,[,] गुणों की सूची की गणना करें

  • +&| abs(x)+abs(y), बराबर 0iff (यदि और केवल अगर) x=0औरy=0
  • -xy, 0iff के बराबर है x=yयानी हम विकर्ण पर हैं
  • +x + y, 0iff के बराबर है x=-yयानी हम एंटी-विकर्ण पर हैं
  • [x, 0iff के बराबर है x=0यानी हम मध्य पंक्ति पर हैं
  • ]y, 0iff के बराबर है y=0यानी हम मध्य स्तंभ पर हैं

• 'O\/-|'#~0=यदि उपरोक्त गुण सत्य है , तो इन गुणों को उपरोक्त मान से तुलना करें 0और iवें से स्ट्रिंग वर्ण लें ।'O\/-|'i

• परिणामी स्ट्रिंग में पहला वर्ण हमेशा वही होगा जिसकी हमें आवश्यकता है, यदि स्ट्रिंग खाली है तो हमें एक स्थान की आवश्यकता है
• {. एक स्ट्रिंग के पहले चरित्र को लेता है और अगर कोई नहीं है तो यह एक अंतरिक्ष चरित्र लौटाता है जैसे कि हमें ज़रूरत होती है
• अब हमारे पास सटीक मैट्रिक्स है जिसकी हमें आवश्यकता है ताकि हम इसे एक बार एक बार stdout में प्रिंट कर सकें 1:echo

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

Comments

यह ungolfed संस्करण है ?! मैं कई बार एक औसत औसत प्रोग्रामर की तरह महसूस करता हूं, और फिर किसी कारण से मैं कोडगुल्फ पर समाप्त होता हूं और उन सामानों को देखता हूं जिन्हें आप खींचते हैं और मदद नहीं कर सकते हैं लेकिन एक बेवकूफ की तरह महसूस करते हैं।

— जस्टसिड

@JustSid खैर, पाठ कोड के साथ अद्यतित नहीं था, लेकिन तकनीकी रूप से मैंने कभी नहीं लिखा कि कोड अपुष्ट है। :)

— यादृच्छिक

यह अभी भी शक्तिशाली या तो प्रभावशाली है

— 15:05

@JustSid यह नहीं है कि यह किसी भी कम प्रभावशाली है, लेकिन जे कोड बहुत अधिक जैसा दिखता है, और यह एक चुनौती की तरह लगता है कि यह एक अच्छी भाषा होगी। यह एक बहुत ही प्रभावशाली उत्तर है, लेकिन इतना सब कुछ जे :) में है

— भूमिगत

Answer 5

PHP, 182 बाइट्स

यह मेरे पहले जवाब के लिए एक मजेदार गतिविधि की तरह लग रहा था। मेरे कोड पर टिप्पणियाँ स्वागत हैं।

<?php function s($n){$e=2*$n+1;for($i=0;$i<$e*$e;$i++){$x=$i%$e;$y=floor($i/$e);echo$y==$x?($x==$n?"O":"\\"):($e-1==$x+$y?"/":($y==$n?"-":($x==$n?"|":" ")));echo$x==$e-1?"\n":"";}}?>

यहाँ टिप्पणियों के साथ गैर-गोल्फ कोड है:

<?php
function s($n) {
    $e=2*$n+1; //edge length
    for($i=0;$i<$e*$e;$i++) {
        $x = $i%$e; // current x coordinate
        $y = floor($i/$e); // current y coordinate

        if ($y==$n&&$x==$n) {
            // center of square
            echo'O';
        }
        else if ($y==$n) {
            // horizontal line
            echo'-';
        }
        else if ($x==$n) {
            // vertical line
            echo'|';
        }
        else if ($y==$x) {
            // diagonal line from top-left to bottom right
            echo'\\';
        }
        else if (($y-$n)==($n-$x)) {
            // diagonal line from bottom-left to top-right
            echo'/';
        }
        else {
            // empty space
            echo' ';
        }
        if ($x==$e-1) {
            // add new line for the end of the row
            echo"\n";
        }
    }
}?>
<pre>
<?php s(10); ?>
</pre>

रॉयवी द्वारा कोड के साथ संपादित किया गया

Comments

हाय :-) अच्छा पहला प्रयास। आप अपने कोड को हालांकि कुछ स्थानों पर सिकोड़ सकते हैं। उदाहरण के लिए के if(($y-$h)==($x-$h))रूप में ही करता है if(($y==$x)। के if($x==y$)foo();else bar();साथ प्रतिस्थापित करके आप किसी अन्य वर्ण को सहेज सकते हैं if($x^$y)bar();else foo();। आपको बयानों के बजाय टर्नरी ऑपरेटरों का उपयोग करने का भी प्रयास करना चाहिए if .. else।

— स्क्विश ओस्फ़रेज

त्रिगुट ऑपरेटरों एक अच्छा टिप है

— निक

174 बाइट्स:function s($n){$e=2*$n+1;for($i=0;$i<$e*$e;$i++){$x=$i%$e;$y=floor($i/$e);echo$y==$x?($x==$n?"O":"\\"):($e-1==$x+$y?"/":($y==$n?"-":($x==$n?"|":" ")));echo$x==$e-1?"\n":"";}}

— रोहिणी

1. इसके लिए कोई ज़रूरत नहीं है $r; बस उपयोग echo( $r.=बाइट्स की समान राशि है echo)। 2. इस्तेमाल किया टर्नरी ऑपरेटर (बहुत सारे पात्रों को बचाता है)। 3. $hबराबरी के बाद से यह बेकार था $n। 4. आप उपयोग करने की आवश्यकता नहीं किया था floorके लिए $x = floor($i%$e);, के बाद से एक पूर्णांक पर एक मापांक गोल नीचे होने की जरूरत नहीं होगी।

— रोहिणी

@squeamishossifrage मैंने ऐसा कभी नहीं सोचा था। सुझावों के लिए धन्यवाद!

— कोदोस जॉनसन

Answer 6

अजगर 2, 99

n=input()
R=range(-n,n+1)
for i in R:print''.join("O\|/ -"[[R,i,0,-i,j].index(j)^(i==0)]for j in R)

प्रिंटों, लाइन द्वारा लाइन देखना हो समन्वय से प्रत्येक पंक्ति बनाने (i,j)(पर केन्द्रित (0,0)) को संतुष्ट करता है j==-i, j==0, j==iया कोई भी हैक के साथ मध्य रेखा काम करने के लिए।

Comments

मुझे लगता है कि आप 1 बाइट बचाने Rके .5लिए उपयोग कर सकते हैं ।

— रैंडम

@randomra यह चतुर है, धन्यवाद। नीचे दो अंकों में!

— xnor

Answer 7

CJam, 48 45 43 41 38 बाइट्स

यह अभी भी बहुत लंबा है और मैं अभी भी कुछ निरर्थक चीजें कर रहा हूं, लेकिन यहां जाता है:

ri:R{_S*"\|/"@R-~S**1$N}%'-R*'O1$W$sW%

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

Answer 8

SpecBAS - 117 बाइट्स

1 INPUT s: LET t=s*2: FOR y=0 TO t: PRINT AT y,y;"\";AT y,t/2;"|";AT t-y,y;"/";AT t/2,y;"-": NEXT y: PRINT AT s,s;"O"

यह एक लूप में स्लैश और डैश प्रिंट करता है, और फिर बीच में "ओ" को डुबोता है।

1, 2 और 9 का उपयोग कर आउटपुट

Comments

एक अनाम उपयोगकर्ता ने दो बाइट को बचाने के लिए बदलने "-": NEXT y: PRINT AT s,s;"O"का सुझाव दिया "-";AT s,s;"O": NEXT y।

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

Answer 9

जावास्क्रिप्ट (ईएस 6) 97 98

यह काफी अलग लगता है ...

// GOLFED
f=n=>(y=>{for(t='';++y<n;t+='\n')for(x=-n;++x<n;)t+='-O /\\|'[y?x?x-y?x+y?2:3:4:5:+!x]})(-++n)||t

// Ungolfed

F=n=>{
  ++n;
  t = '';
  for (y = -n; ++y < n; t += '\n')
    for (x = -n; ++x < n; )
      if (y != 0)
        if (x != 0)
          if (x != y)
            if (x != -y)
              t += ' '
            else
              t += '/'
          else
            t += '\\'
        else
          t += '|'
      else
        if (x != 0)
          t += '-'
        else 
          t += 'O'
  return t;
}
    
// TEST
function test(){ OUT.innerHTML = f(N.value|0); }
test()

input { width: 4em }

N: <input id=N value=5><button onclick="test()">Go</button>
<pre id="OUT"></pre>

Comments

सुंदर। मुझे छोरों के लिए सामान्य उपयोग करने के लिए एक बंद के बारे में सोचना चाहिए था।

— अंडर

मैं यह पसंद है। मैंने एक स्ट्रिंग का उपयोग करके और एक विशिष्ट सूचकांक तक पहुँचने के लिए एक लिखने की कोशिश की थी, लेकिन आपका बहुत छोटा है।

— रोहिणी

Answer 10

"चीटर के संस्करण" के लिए OS / 2 क्लासिक Rexx, 102 ... या 14

इसे "गोल्फ" करने के लिए लाइनफीड को बाहर निकालें।

w='%1'
o=center('O',w,'-')
m='center(space("\|/",w),%1)'
do w
  w=w-1
  interpret "o="m"|o|"m
end l
say o

चीटर का संस्करण, स्क्रिप्ट को नाम दें जो भी स्रोत कोड आपको 255 वर्णों के तहत चाहिए (एचपीएफएस डिस्क की आवश्यकता है):

interpret '%0'

---

संपादित करें: बस स्पष्ट होने के लिए, चीटर के संस्करण को गिनने का इरादा नहीं है! यह सिर्फ मूर्खतापूर्ण होना है और एक बूढ़ा कुत्ता दिखाना अभी भी चालबाजी कर सकता है। :)

उदाहरण के लिए वास्तविक मज़ा और खेल के लिए, एक सूची पुनरावृत्ति पर जावा -8 / C11 शैली "लैम्ब्डा" अभिव्यक्तियों का कार्यान्वयन। परीक्षण नहीं किया गया है, लेकिन 1979 के आईबीएम मेनफ्रेम पर चलना चाहिए। ;)

ForEachInList( 'Months.January.Days', 'Day' -> 'SAY "You have an appointment with" Day.Appointment.Name "on" Day.Appointment.Date' )
EXIT

ForEachInList: 
    SIGNAL ON SYNTAX
    PARSE ARG MyList "," MyVar "->" MyCommand
    INTERPRET ' MyListCount = ' || MyList || '.Count'
    DO ListIndex = 1 TO MyListCount
       INTERPRET MyVar || ' = ' || MyList || '.' || ListIndex
       INTERPRET MyCommand
    END
    RETURN
SYNTAX:
    SAY MyCommand ' is not a valid expression. '
    EXIT

- कॉलिंग कोड मानता है कि आपने पहले से ही एक स्टेम (सरणी) बनाया है, स्वाभाविक रूप से।

Comments

आपके चीटर संस्करण के लिए: यदि किसी प्रोग्राम का फ़ाइल नाम मनमाना नहीं है, तो उसे बाइट काउंट में शामिल करना होगा ।

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

काफी उचित। चीटर का संस्करण बिल्कुल भी गंभीर नहीं था! :) ... यही कारण है कि मैंने 102 पर "वास्तविक" उत्तर पोस्ट किया। यह सिर्फ नवीनता के लिए था।

— लीसा

@ लिसा को छोड़कर, इसका उपन्यास बिल्कुल नहीं;)। इसके अलावा, यह लीडरबोर्ड स्क्रिप्ट को तोड़ देगा यदि इस चुनौती में उपयोग किया जाता है।

— ऑप्टिमाइज़र

Answer 11

हास्केल, 109 98 96 बाइट्स

उनकी मदद के लिए nimi और मौरिस को धन्यवाद!

0#0='O'
0#_='-'
_#0='|'
i#j|i==j='\\'|i== -j='/'|1<2=' '
f n=unlines[map(i#)[-n..n]|i<-[-n..n]]

स्पष्टीकरण:

ऑपरेटर #निर्दिष्ट करता है कि कौन सा वर्ण निर्देशांक (i, j) पर दिखाई देता है, सूरज पर केंद्रित (0,0) के साथ। फ़ंक्शन fपरिणाम का निर्माण करता है स्ट्रिंग #से निर्देशांक के सभी जोड़े पर मैपिंग करके -n से n तक।

उपयोग:

ghci> putStr $ f 2
\ | /
 \|/ 
--O--
 /|\ 
/ | \

Comments

आप एक इन्फ़िक्स ऑपरेटर का उपयोग करने के बजाय द्वारा कुछ बाइट्स बचा सकता है sजैसे, 0#0='O', 0#_='-', आदि और 1<2के बजाय True।

— nimi

शायद map(i#)[-n..n]दो बाइट्स बचाने के लिए।

— लिन

Answer 12

आर, 177 149 बाइट्स

मिकी टी। यार! उन्होंने मुझे अपने मूल गलत समाधान को ठीक करने और 28 बाइट्स को बचाने में मदद की । धन्यवाद, मिक्की!

m=matrix(" ",(w=2*(n=scan()+1)-1),w);m[row(m)==rev(col(m))]="/";diag(m)="\\";m[,n]="|";m[n,]="-";m[n,n]="O";m[,w]=paste0(m[,w],"\n");cat(t(m),sep="")

असंगठित + स्पष्टीकरण:

# Create a matrix of spaces, read n from stdin, assign w=2n+1
m <- matrix(" ", (w <- 2*(n <- scan() + 1) - 1), w)

# Replace the opposite diagonal with forward slashes
m[row(m) == rev(col(m))] <- "/"

# Replace the diagonal with backslashes
diag(m) <- "\\"

# Replace the vertical center line with pipes
m[, n] <- "|"

# Replace the horizontal center line with dashes
m[n, ] <- "-"

# Put an O in the middle
m[n, n] <- "O"

# Collapse the columns into single strings
m[, w] <- paste0(m[, w], "\n")

# Print the transposed matrix
cat(t(m), sep = "")

किसी भी आगे के सुझाव का स्वागत है!

Comments

क्षमा करें, एलेक्स, आप खड़ी किरणों से चूक गए। कुछ चीजें ऐसी हैं जिन्हें सामान्य प्रक्रिया को बदले बिना इसे छोटा किया जा सकता है। scanवास्तव में जरूरत नहीं है w=। इसे डीप कमांड में भी शिफ्ट किया जा सकता है। ifयदि आप जिस तरह से मैट्रिक्स उदाहरणों के एक जोड़े में नियंत्रित किया जाता है बदल छोड़ दिया जा सकता है। इनको लगाने से मुझे मिलता है m=matrix(" ",(w=2*(n=scan()+1)-1),w);m[row(m)-rev(col(m))==0]='/';diag(m)="\\";m[,n]='|';m[n,]="-";m[n,n]="O";m[,w]=paste0(m[,w],'\n');cat(t(m),sep='')। इसके अलावा गोल्फिंग संभव है कि मुझे लगता है।

— मिकट

@ मिक्की: यह शानदार है। मेरी गलती को नोटिस करने और ज्यादा बेहतर समाधान साबित करने के लिए बहुत-बहुत धन्यवाद! मैंने उत्तर संपादित किया।

— एलेक्स ए

Answer 13

सी #, 230 226 बाइट्स

string g(int n){string r="";int s=n*2+1;for(int h=0;h<s;h++){for(int w=0;w<s;w++){if(h==w){if(w==n){r+="O";}else{r+="\\";}}else if(w==s-h-1){r+="/";}else if(w==n){r+="|";}else if(h==n){r+="-";}else{r+=" ";}}r+="\n";}return r;}

जैसा कि अनुरोध किया गया है, अनगुल्ड संस्करण: स्ट्रिंग बदसूरत (इंट एन) {

        // The sting we'll be returning
        string ret = ""; 

        // The width and height of the output
        int s = n * 2 + 1; 

        // for loop for width and height
        for (int height = 0; height < s; height++) 
        {
            for (int width = 0; width < s; width++) 
            {
                // Matches on top-left to bottom-right diagonal line
                if (height == width) 
                {
                    // If this is the center, write the 'sun'
                    if (width == n) 
                    {
                        ret += "O"; 
                    }
                    // If this is not the center, add the diagonal line character
                    else 
                    {
                        ret += "\\"; 
                    }
                }
                // Matches on top-right to bottom-left diagonal line
                else if (width == s - height - 1) 
                { 
                    ret += "/";
                }
                // Matches to add the center line
                else if (width == n) 
                { 
                    ret += "|";
                }
                // Matches to add the horizontal line
                else if (height == n) 
                { 
                    ret += "-";
                }
                // Matches all others
                else 
                { 
                    ret += " "; 
                } 
            } 
            // Add a newline to separate each line
            ret += "\n"; 
        } 
        return ret; 
    }

अगर मैंने कुछ गलत किया है तो यह मेरी पहली पोस्ट है। किसी भी टिप्पणी और सुधार बहुत स्वागत है।

Comments

इसके अलावा, s=2*n+1बल्कि s=(n*2)+1और w==s-h-1बजाय w==(s-h)-1यह थोड़ा कम कर देगा।

— एलेक्स ए।

अच्छा, अपनी स्ट्रिंग निर्माण विधि चुरा सकता है। यह मुझे बताता है कि लूप छोरों की तुलना में लंबा है :(

— इवान

मैंने अनगुल्ड संस्करण जोड़ा है :)

— ट्रांसमिशन

Answer 14

रूबी: 98 92 वर्ण

प्रोक जो सूर्य के साथ एक स्ट्रिंग लौटाता है।

f=->n{x=(0..m=n*2).map{|i|s=?|.center m+1
s[i]=?\\
s[m-i]=?/
s}
x[n]=?O.center m+1,?-
x*?\n}

नमूना रन:

irb(main):001:0> f=->n{x=(0..m=n*2).map{|i|s=?|.center m+1;s[i]=?\\;s[m-i]=?/;s};x[n]=?O.center m+1,?-;x*?\n}
=> #<Proc:0x000000020dea60@(irb):1 (lambda)>
irb(main):002:0> (0..3).each {|i| puts f[i]}
O
\|/
-O-
/|\
\ | /
 \|/ 
--O--
 /|\ 
/ | \
\  |  /
 \ | / 
  \|/  
---O---
  /|\  
 / | \ 
/  |  \
=> 0..3

Answer 15

जंग, 215 वर्ण

fn a(n:usize){for i in 0..n{println!("{}\\{}|{1}/{0}",s(i),s(n-i-1))}println!("{}O{0}",vec!["-";n].concat());for i in(0..n).rev(){println!("{}/{}|{1}\\{0}",s(i),s(n-i-1))}}fn s(n:usize)->String{vec![" ";n].concat()}

मैंने एक स्ट्रिंग स्लाइसिंग विधि का उपयोग करने की कोशिश की ( n-1रिक्त स्थान की एक स्ट्रिंग बनाकर और एक इंडेक्स से स्लाइसिंग) जैसे:

fn a(n:usize){let s=vec![" ";n-(n>0)as usize].concat();for i in 0..n{println!("{}\\{}|{1}/{0}",&s[..i],&s[i..])}println!("{}O{0}",vec!["-";n].concat());for i in(0..n).rev(){println!("{}/{}|{1}\\{0}",&s[..i],&s[i..])}}

लेकिन यह वास्तव में 3 वर्ण लंबा है।

अघोषित कोड:

fn asciisun_ungolfed(n: usize) {
    for i in 0..n {
        println!("{0}\\{1}|{1}/{0}", spaces(i), spaces(n-i-1))
    }
    println!("{0}O{0}", vec!["-"; n].concat());
    for i in (0..n).rev() {
        println!("{0}/{1}|{1}\\{0}", spaces(i), spaces(n-i-1))
    }
}
fn spaces(n: usize) -> String { vec![" "; n].concat() }

मुझे जो पसंद है, वह यह है कि मैं प्रारूपण तारों पर कुछ चार्ट कैसे दाढ़ी करता हूं। उदाहरण के लिए,

f{0}o{1}o{1}b{0}ar

के बराबर है

f{}o{}o{1}b{0}ar

क्योंकि प्रारूप स्ट्रिंग तर्क स्थिति के लिए "ऑटो-इन्क्रीमेंटर" संख्या को मैन्युअल रूप से निर्दिष्ट करने से प्रभावित नहीं होता है, और पूरी तरह से स्वतंत्र रूप से कार्य करता है।

Answer 16

सप्तक 85

हमेशा की तरह मैटरिंग बुलिंग =) eyeएक पहचान मैट्रिक्स का उत्पादन करता है, बाकी मैं स्वयं व्याख्यात्मक हूं।

m=(e=eye(2*(k=input('')+1)-1))*92+rot90(e)*47;m(:,k)='|';m(k,:)=45;m(k,k)='o';[m,'']

Comments

फिर भी मेरे मुकाबले दो बाइट्स बेहतर हैं :( मैंने वास्तव में शुरू में इसी तरह की कुछ कोशिश की थी, लेकिन इसे बहुत छोटा नहीं मिला - मुझे नहीं पता था कि मैं "m (:, k) = '' | '' कर सकता हूं। अच्छा सबमिशन।

— ओबेले

Answer 17

आईडीएल 8.3, 135 बाइट्स

अगर यह अधिक गोल्फ हो सकता है तो डन्नो ... यह बहुत सीधा है। पहले हम खाली तारों की एक m x mसरणी ( m=2n+1) बनाते हैं; तो, हम लाइनों में वर्ण बनाएं ( y=x, y=-x, y=n, और x=n)। फिर हम O को बिंदु पर छोड़ते हैं (n, n), और पूरी चीज़ को प्रिंट करते हैं, mप्रत्येक पंक्ति पर लंबाई 1 के स्ट्रिंग्स के रूप में स्वरूपित किया जाता है ताकि मूल रूप से सरणी को प्रिंट करने से कोई अतिरिक्त रिक्ति न हो।

pro s,n
m=2*n+1
v=strarr(m,m)
x=[0:m-1]
v[x,x]='\'
v[x,m-x-1]='/'
v[n,x]='|'
v[x,n]='-'
v[n,n]='O'
print,v,f='('+strtrim(m,2)+'A1)'
end

परीक्षा:

IDL> s,4
\   |   /
 \  |  / 
  \ | /  
   \|/   
----O----
   /|\   
  / | \  
 /  |  \ 
/   |   \

Comments

"एक कार्यक्रम के बजाय, आप एक फ़ंक्शन लिख सकते हैं जो पूर्णांक लेता है। फ़ंक्शन को सामान्य रूप से सूर्य के डिज़ाइन को प्रिंट करना चाहिए या इसे स्ट्रिंग के रूप में वापस करना चाहिए।"

— सैपरक्विवल

हाहा नो

— वर्ट्स

Answer 18

मतलाब, 93 87 बाइट्स

अफसोस की बात है कि फंक्शन हेडर को इतना बड़ा होना चाहिए ... इसके अलावा मुझे लगता है कि यह बहुत अच्छा है। मुझे आश्चर्य है कि अगर यह ऑक्टेव के कुछ सिंटैक्स मतभेदों के साथ बेहतर किया जा सकता है।

N=input('');E=eye(N)*92;D=rot90(E)*.52;H=ones(1,N)*45;V=H'*2.76;[E V D;H 79 H;D V E '']

Comments

आप केवल N=input('')2 वर्णों को सहेजने के लिए एक कार्यक्रम बना सकते हैं । इसके अलावा आप [E V D;H 79 H;D V E '']पूरे मैट्रिक्स को एक चार सरणी में बदलने के लिए लिख सकते हैं , जो आपको एक और बाइट या दो बचाएगा। (मैंने अभी थोड़ा अलग दृष्टिकोण के साथ एक ऑक्टेव कार्यक्रम प्रस्तुत किया, लेकिन इससे पहले कि मैंने तुम्हारा पाया =)

— त्रुटिपूर्ण

मेरे पास वास्तव में इनपुट लाइन पहले थी, लेकिन किसी कारण से मैंने गलती से सोचा कि इसकी अनुमति नहीं है ... हालांकि अन्य टिप के लिए धन्यवाद!

— ओबेले

Answer 19

जावास्क्रिप्ट ( ईएस 7 ड्राफ्ट ) 115

f=l=>[['O |/\\-'[y^x?z+~x^y?y^l?x^l?1:2:5:3:x^l&&4]for(x in _)].join('')for(y in _=[...Array(z=2*l+1)])].join('\n')


// Snippet demo: (Firefox only)
for(var X of [0,1,2,3,4,5])
    document.write('<pre>' + f(X) + '</pre><br />');

Answer 20

पायथ - 52 बाइट्स

कठिन हिस्सा यह पता लगा रहा था कि प्रत्येक पक्ष के लिए स्लैश को कैसे स्विच किया जाए। मैं एक मेमने को परिभाषित करने के लिए बस गया जो प्रतीकों का उपयोग करने के लिए लेता है।

KdMms[*Kt-QdG*Kd\|*KdH)_UQjbg\\\/p\O*Q\-*\-Qjb_g\/\\

संभावना अधिक गोल्फ हो सकती है, स्पष्टीकरण जल्द ही आ रहा है।

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

Answer 21

पर्ल, 94

यहां बहुत सारे नेस्टर्ड टर्नरी ऑपरेटर हैं, लेकिन मुझे लगता है कि कोड यथोचित सीधा है।

$n=<>;for$x(-$n..$n){for$y(-$n..$n){print$x^$y?$x+$y?$x?$y?$":'|':'-':'/':$x?'\\':'O'}print$/}

इसे यहाँ आज़माएँ : ideone.com/E8MC1d

Comments

88B: for$x(-($n=<>)..$n){map{print$x^$_?$x+$_?$x?$_?$":'|':'-':'/':$x?'\\':O}-$n..$n;print$/}- एक दो ट्वीक्स: नक्शे के लिए आंतरिक रूपांतरित करें और $ y से $ _ में बदलें; इनलाइन ($n=<>)।

— अलेक्जेंडर-ब्रेट

Answer 22

C # - 291 (पूरा कार्यक्रम)

using System;using System.Linq;class P{static void Main(string[] a){Func<int,int,int,char>C=(s,x,i)=>x==(2*s+1)?'\n':i==s?x==s?'O':'-':x==s?'|':x==i?'\\':x==2*s-i?'/':' ';int S=int.Parse(a[0])*2;Console.Write(Enumerable.Range(0,(S+1)*(S+1)+S).Select(z=>C(S/2,z%(S+2),z/(S+2))).ToArray());}}

Comments

इस पर काम करते हुए!!

— इवान

Answer 23

जावास्क्रिप्ट (ईएस 6), 139 135 140 + 1 बाइट्स

( -pकंसोल में नोड के साथ फ्लैग के लिए +1 है )

तय:

t=(n,m)=>(m=2*n+1,(A=Array).from(A(m),(d,i)=>A.from(A(m),(e,j)=>i==j?j==n?"O":"\\":m-1==j+i?"/":i==n?"-":j==n?"|":" ").join("")).join("\n"))

उपयोग:

t(3)
/*
\  |  /
 \ | / 
  \|/  
---O---
  /|\  
 / | \ 
/  |  \
*/

ungolfed:

var makeSun = function (n, m) {
    m = 2 * n + 1;    // there are 2*n+1 in each row/column
    return Array.from(Array(m), function (d, i) {
        return Array.from(Array(m), function (e, j) {
            // if i is j, we want to return a \
            // unless we're at the middle element
            // in which case we return the sun ("O")
            if (i == j) {
                return j == n ? "O" : "\\";
            // the other diagonal is when m-1 is j+i
            // so return a forward slash, /
            } else if (m - 1 == j + i) {
                return "/";
            // the middle row is all dashes
            } else if (i == n) {
                return "-";
            // the middle column is all pipes
            } else if (j == n) {
                return "|";
            // everything else is a space
            } else {
                return " ";
            }
        }).join("");
    }).join("\n");
}

Comments

आपको दो किरणें याद आ रही हैं।

ओह, रफ़ू, मैं उस वापस जोड़ना भूल गया ...

— royhowie

(A=Array).from(A(m))

— श्मिट्टी

@

— मिचेल्ट

@ सुझाव के लिए धन्यवाद! कि बहुत सारे पात्रों को बचाया

— royhowie

Answer 24

पायथन 3, 193 186 बाइट्स

golfed

def f(n):
 s,b,e,d,g=' \\/|-';p,r,i='',int(n),0
 while r:print(s*i+b+s*(r-1)+d+s*(r-1)+e);r-=1;i+=1
 print(g*n+'O'+g*n);r+=1;i=n-1
 while r<n+1:print(s*i+e+s*(r-1)+d+s*(r-1)+b);r+=1;i-=1

उत्पादन

>>> f(3)
\  |  /
 \ | /
  \|/
---O---
  /|\
 / | \
/  |  \

>>> f(5)
\    |    /
 \   |   /
  \  |  /
   \ | /
    \|/
-----O-----
    /|\
   / | \
  /  |  \
 /   |   \
/    |    \

Ungolfed

def f(n):
    s, b, e, d, g = ' \\/|-'
    p, r, i = '', int(n), 0
    while r:
        print(s*i + b + s*(r-1) + d + s*(r-1) + e)
        r -= 1
        i += 1
    print(g*n + 'O' + g*n)
    r += 1
    i = n-1
    while r < n+1:
        print(s*i + e + s*(r-1) + d + s*(r-1) + b)
        r += 1
        i -= 1

Comments

यहाँ कुछ चीजें गढ़ी जा सकती हैं, लेकिन सबसे बड़ी आपकी डिफ़ॉल्ट दलीलें हैं। s=' ',b='\\',f='/',d='|',g='-'है बहुत , लंबे समय ताकि आप जोड़कर चलती बेहतर होगा s,b,f,d,g=" \/|-"दूसरी पंक्ति के लिए।

— Sp3000

मेरा मतलब " \/|-"एक एकल स्ट्रिंग के रूप में था , इसे अलग-अलग वर्णों में विभाजित करने के बजाय। आप एक स्ट्रिंग से अनपैक कर सकते हैं जैसे x,y,z="123", जो बनाता है x="1", y="2"और z="3"।

— Sp3000

फिर से एडिट किया गया। धन्यवाद @ Sp3000

— Zach Gates

Answer 25

सीजेएम, 59 55 बाइट्स

ri:A,W%{_S*"\|/"\*\A\-(S*_@@++}%_Wf%W%['-A*_'O\++]\++N*

यह किसी भी पुरस्कार को नहीं जीतेगा, लेकिन मैं बहुत खुश था कि यह काम किया!

गोल्फ युक्तियाँ के लिए Sp3000 के लिए धन्यवाद।

Comments

अच्छा काम! यहां कुछ सुझाव दिए गए हैं: 1) आप अंतरिक्ष और 2 के लिए संस्करण के Sबजाय उपयोग कर सकते हैं ') क्योंकि '-A*'O'-Aआप '-A*_'O\इसे दो बार लंबा कर सकते हैं, क्योंकि आप कर सकते हैं

— Sp3000

Answer 26

पायथन, 175 129 127 125 बाइट्स

s,q,x=' ','',int(input())
for i in range(x):d=(x-i-1);q+=(s*i+'\\'+s*d+'|'+s*d+'/'+s*i+'\n')
print(q+'-'*x+'O'+'-'*x+q[::-1])

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

Answer 27

रूबी - 130 बाइट्स

def f(n);a=(0...n).map{|i|' '*i+"\\"+' '*(n-1-i)+'|'+' '*(n-1-i)+'/'+' '*i};puts(a+['-'*n+'O'+'-'*n]+a.reverse.map(&:reverse));end

उपयोग:

irb(main):002:0> f(3)
\  |  /
 \ | /
  \|/
---O---
  /|\
 / | \
/  |  \

Comments

पुरानी चाल के एक जोड़े को लागू किया है: f=->n{a=(0...n).map{|i|(s=' ')*i+?\\+s*(m=n-1-i)+?|+s*(m)+?/+s*i};puts(a+[?-*n+'O'+?-*n]+a.reverse.map(&:reverse))}( रूबी में कुछ और के लिए गोल्फ खेलने के लिए टिप्स देखें ।)

— मैनेटवर्क

Answer 28

पर्ल 85 91 90 89 86 बी

map{$_=$r||O;s/^|$/ /mg;s/ (-*O-*) /-$1-/;$r="\\$s|$s/
$_
/$s|$s\\";$s.=$"}1..<>;say$r

Ungolfed:

# usage: echo 1|perl sun.pl

map {
    $_ = $r || O;  # no strict: o is "o". On the first run $r is not defined
    s/^|$/ /mg;    # overwriting $_ saves characters on these regexes
    s/ (-*O-*) /-$1-/;
    $r = "\\$s|$s/
$_
/$s|$s\\";         # Embedded newlines save 1B vs \n. On the first run $s is not defined.
    $s .= $"
} 1..<>;
say $r

Answer 29

प्रोलॉग, 219 बाइट्स

नहीं, यह बहुत अधिक गोल्फ भाषा नहीं है। लेकिन मुझे लगता है कि इस साइट को और अधिक Prolog की आवश्यकता है।

s(N,N,N,79).
s(R,R,_,92).
s(R,C,N,47):-R+C=:=2*N.
s(N,_,N,45).
s(_,N,N,124).
s(_,_,_,32).
c(_,C,N):-C>2*N,nl.
c(R,C,N):-s(R,C,N,S),put(S),X is C+1,c(R,X,N).
r(R,N):-R>2*N.
r(R,N):-c(R,0,N),X is R+1,r(X,N).
g(N):-r(0,N).

swiplलिनक्स पर परीक्षण किया गया। जैसे आह्वान swipl -s asciiSun.prolog:; फिर सूरज के अपने इच्छित आकार के लिए प्रश्न:

?- g(3).
\  |  /
 \ | /
  \|/
---O---
  /|\
 / | \
/  |  \
true .

Ungolfed:

 % Args to sym/4 are row, column, N and the character code to be output at that location.
sym(N,N,N,79).
sym(R,R,_,'\\').
sym(R,C,N,'/') :- R+C =:= 2*N.
sym(N,_,N,'-').
sym(_,N,N,'|').
sym(_,_,_,' ').

 % Args to putCols/3 are row, column, and N.
 % Recursively outputs the characters in row from col onward.
putCols(_,C,N) :- C > 2*N, nl.
putCols(R,C,N) :- sym(R,C,N,S), put_code(S), NextC is C+1, putCols(R,NextC,N).

 % Args to putRows/2 are row and N.
 % Recursively outputs the grid from row downward.
putRows(R,N) :- R > 2*N.
putRows(R,N) :- putCols(R,0,N), NextR is R+1, putRows(NextR,N).

putGrid(N) :- putRows(0,N).

Answer 30

जावास्क्रिप्ट (ईएस 6), 142 140 134 117 बाइट्स

n=>(g=x=>x?`${t=` `[r=`repeat`](n-x--)}\\${s=` `[r](x)}|${s}/${t}
`+g(x):`-`[r](n))(n)+`O`+[...g(n)].reverse().join``

---

कोशिश करो

f=
n=>(g=x=>x?`${t=` `[r=`repeat`](n-x--)}\\${s=` `[r](x)}|${s}/${t}
`+g(x):`-`[r](n))(n)+`O`+[...g(n)].reverse().join``
i.addEventListener("input",_=>o.innerText=f(+i.value))
o.innerText=f(i.value=1)

<input id=i type=number><pre id=o>