परिचय

*एक निर्दिष्ट आयाम पर एससी-आर्ट स्टार को प्रदर्शित करने के लिए तारांकन वर्ण (स्टार) का उपयोग करने का विचार है । आयाम एक इनपुट संख्या है जो $1$ से अधिक या इसके बराबर है जो स्टार के ऊपरी बिंदु की रेखाओं में ऊंचाई को निर्दिष्ट करता है। यहां के सितारों का इरादा छह नुकीले तारों से है, जिनमें बड़े आकार चित्र के नजरिए से बेहतर दिखते हैं।

सभी मामलों में सितारों की एससी-कला का प्रतिनिधित्व दो त्रिकोणों के रूप में दिखाई देता है जो निम्नलिखित उदाहरणों में दिखाए गए अनुसार ओवरलैप करते हैं।

Parametrics

डेटा की निम्न तस्वीर और तालिका स्टार के पहले सात आकारों के लिए विशेषताओं का वर्णन करती है। मानकों में से प्रत्येक के रूप में एक अंकगणितीय प्रगति में बढ़ता $N$ बढ़ जाती है, को छोड़कर $N=1$ अलग है ।

उदाहरण

1 (पतित मामले) के इनपुट के लिए कार्यक्रम का आउटपुट निम्नानुसार होना चाहिए:

  *
*****
*****
  *

2 का इनपुट:

    *
   ***
*********
 *******
*********
   ***
    *

(3)

       *
      ***
     *****
***************
 *************          
  ***********
 *************
***************
     *****
      ***
       *

(5)

             *
            ***
           *****
          *******
         *********
***************************
 *************************
  ***********************
   *********************
    *******************
   *********************
  ***********************
 *************************
***************************
         *********
          *******
           *****
            ***
             *

चुनौती

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

आप मान सकते हैं कि इनपुट मान हमेशा एक धनात्मक पूर्णांक होता है।
आउटपुट लाइनों पर व्हाट्सएप को पीछे छोड़ना ठीक है।
कार्यक्रम एल्गोरिथ्म किसी भी $N$ इनपुट के लिए स्टार आर्ट आउटपुट का उत्पादन करने के लिए सामान्य रूप से पर्याप्त होना चाहिए । प्रदर्शन आकार के कारण व्यावहारिक सीमाएँ निश्चित रूप से मौजूद हैं।
आउटपुट को STDOUT पर प्रिंट करना चाहिए।
मानक खामियों को मना किया जाता है।
यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं।

स्कोरिंग

यह कोड-गोल्फ है इसलिए कम से कम बाइट्स जीत के साथ कोड!

code-golf ascii-art

— माइकल करस
स्रोत

5

आप यह भी कहते हैं कि यह एक फ़ंक्शन हो सकता है लेकिन इसे "STDOUT में प्रिंट करना" चाहिए। क्या यह जानबूझकर है?

— रॉक गार्फ हंटर

5

हां, एक सामान्य निर्माण नियम बहुत अच्छा होगा ... उदाहरण के लिए मुझे निश्चित रूप से इनपुट के बारे में निश्चित नहीं है, जैसे कि एन = 4 ...

— digEmAll

7

कृपया यह न कहें "तारों का उत्पादन करने के लिए एल्गोरिथ्म प्रोग्रामिंग चुनौती का हिस्सा है।" यह कुछ ऐसा नहीं है, जब अधिकांश ASCII कला चुनौती करते समय अधिकांश गोल्फर आनंद लेते हैं, और ऐसा लगता है कि कुछ ऐसा है जो स्पेसर की जिम्मेदारी है। उस ने कहा, मुझे आश्चर्य है कि लोग यहां निर्माण पर स्पष्ट नहीं हैं; यह दो त्रिकोण हैं जो चुनौती कहते हैं जैसे अतिव्याप्त हैं। क्या यह त्रिभुजों के आकार और ऑफसेट को स्पष्ट रूप से कहने में मदद करेगा?

— 15

9

@TimPederick N = 1 के बारे में अच्छा कैच अलग होना। मैंने एक नोट में रखा है ताकि सॉल्वर को यह याद न हो। मुझे लगता है कि इस विशेष मामले के बिना चुनौती बेहतर होगी।

— xnor

4

@ xnor: चूंकि n = 1 अलग था, इसलिए मैं एक सामान्य नियम का पता नहीं लगा सका ... और IMO नियम को हमेशा ASCII कला के लिए निर्दिष्ट किया जाना चाहिए, अन्यथा मुझे अच्छी तरह से प्रिंट करने की अनुमति है जो मैं परिभाषित सीमा के बाहर चाहता हूं। उदाहरण;)

— digEmAll

7

05AB1E , 21 बाइट्स

3*s≠-L·<sÅ0«Âø€à'*×.C

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

व्याख्या

3*                     # multiply input by 3
  s≠-                  # subtract 1 if the input isn't 1
     L                 # push range [1 ... (3*n-(n!=1))]
      ·<               # multiply by 2 and subtract 1 to get odd numbers
        sÅ0«           # append n zeroes
            Âø         # zip with a reversed copy
              €à       # get the largest number in each pair
                '*×    # repeat "*" for each number in the list
                   .C  # format centered

— Emigna
स्रोत

1

आपके आउटपुट सितारे सही दिखते हैं।

— माइकल करस

1

मैं 3*s≠-L·<जैसे 6*s≠·-ÅÉया के लिए विकल्पों का भार पा सकते हैं ≠3/-6*ÅÉ, लेकिन दुर्भाग्य से कोई भी छोटा नहीं है .. हमेशा की तरह अच्छा जवाब! :)

— केविन क्रूज़सेन

xs3*<ŸRsLì'*×.º.C.∊19 :) के लिए। मैंने झूठ बोला, यह 1 के लिए काम नहीं करता है। प्रेरणा के लिए इसे छोड़कर।

— मैजिक ऑक्टोपस Urn

7

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

एक फ़ंक्शन बनाता है gजो एक नंबर लेता है और एक IOमोनड बनाता है जो स्टार को STDOUT में प्रिंट करता है। मुझे लगता है कि यह ठीक है।

f=replicate
a%b=mapM_(\n->putStrLn$f(a-n)' '++f(2*n-3)'*')$zipWith max<*>reverse$[2..a]++f b 0
g 1=4%1
g a=(3*a)%a

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

व्याख्या

पहले लैम्बडा के बारे में बात करते हैं।

\n->putStrLn$f(a-n)' '++f(2*n-1)'*'

यह एक संख्या लेता है, nसितारों के रूप में तैयार होने के लिए। हम दो बार प्रिंट करते हैं कि कई सितारे और फिर 1 और इसे छवि के आकार के दाईं ओर पैड करते हैं। हम इसे दाईं ओर पैड करते हैंa तारों की रेखा को केंद्र में रखने के लिए रिक्त स्थान हैं। हम प्रत्येक लाइन को खींचने के लिए इस लैम्ब्डा का उपयोग कर सकते हैं।

इस मेमने से हम बनाते हैं (%)।(%)mapM_एक प्रोफ़ाइल को आकार में बदलने के लिए हमारे लैम्ब्डा के साथ करने से शुरू होता है ।

अब हमें बस इतना करना है कि स्टार के लिए प्रोफाइल की एक सूची बनाएं। हम इसे पहले एक त्रिभुज बनाकर कर सकते हैं[1..a] , फिर इसे कुछ शून्य के साथ पैड कर सकते हैं++replicate b 0 । यदि हम त्रिभुज का प्रोफ़ाइल लेते हैं और इसे उल्टा करते हैं तो हमें दूसरे तारे का आधा हिस्सा मिलता है। सुपर थोपने के लिए हम सिर्फ एक नई प्रोफ़ाइल बनाते हैं जहाँ प्रत्येक प्रविष्टि दो त्रिकोणों की अधिकतम होती है। यह वह जगह है zipWith max।

हम इसे दो में से एक तरीके से कहते हैं: जैसा कि 3%1 इनपुट के लिए 1और साथ में(3*a-1)%a अन्यथा।

यहाँ से हम कुछ बाइट्स शेव करने के लिए कुछ मूल्यों के साथ थोड़ी सी फिडिंग करते हैं। चूंकि 3*a-1हम लंबे समय से अपने कुछ अन्य मूल्यों को 1 से ऑफसेट करते हैं, ताकि सबकुछ रद्द हो जाए और हमें 3*aइसके बजाय इच्छित व्यवहार प्राप्त हो । 2इसके बजाय हम अपनी सूची शुरू 1करते हैं और इसके 2*n-3बजाय करते हैं2*n-1 बदलाव लिए बनाते हैं।

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

यह एक बिंदु मुक्त फ़ंक्शन बनाता है (%)<*>min 2

f=replicate
a%b=mapM_(\n->putStrLn$f(3*a-n)' '++f(2*(n-b)+1)'*')$zipWith max<*>reverse$[b..3*a]++f a 0
(%)<*>min 2

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

सभी संभालती है $N>1$

f=replicate
g a=mapM_(\n->putStrLn$f(3*a-n)' '++f(2*n-3)'*')$zipWith max<*>reverse$[2..3*a]++f a 0

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

जैसे सभी मामलों को संभालता है $N=1$

f=replicate
g a=mapM_(\n->putStrLn$f(3*a-n)' '++f(2*n-1)'*')$zipWith max<*>reverse$[1..3*a]++f a 0

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

— पोस्ट रॉक गार्फ हंटर
स्रोत

अब आपका आउटपुट अच्छा लग रहा है।

— माइकल करस

6

आर , 125 107 101 बाइट्स

function(n,S=3*n+!n-1,P=pmax(I<-c(2:S*2-3,!1:n),rev(I)),`~`=strrep)write(paste0(' '~S-1-P/2,'*'~P),1)

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

-24 धन्यवाद @Giuseppe को

पिछला (अलग) दृष्टिकोण:

आर , 150 148 136 135 130 128 बाइट्स

function(n,G=n<2,K=4*n-1+G)for(i in 1:K-1)cat(`[<-`(rep(' ',W<-3*n-2+G),1+W+c(-i:i*(i<K-n),-(j=K-i-1):j*(i>=n)),'*'),sep='','
')

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

-14 @Kirill L को धन्यवाद।
-1 @ t-clausen.dk को धन्यवाद
-7 @Giuseppe को धन्यवाद

— digEmAll
स्रोत

हाँ, मैं भी उन दोहराया S [] = असाइनमेंट को पसंद नहीं करता

— Kirill L.

महान ! मैं ऐसा कुछ सोच रहा था ... लेकिन मैं रात का खाना खा रहा था: पी

— डाइजेक्लेल

लगता है कि आप एक बाइट बचा सकते हैं: i> n-1 को i> = n

— t-clausen.dk

@ t-clausen.dk: हां, धन्यवाद!

— डाइजेक्सिल

1

नए संस्करण पर 117 बाइट्स

— Giuseppe

5

पायथन 2 , 101 99 97 बाइट्स

n=input()
x=2*(n>1)
for i in range(1,8*n,2):print('*'*[i,8*n-i-x][i+x>n*6or i/n/2%2]).center(6*n)

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

_{-2 बाइट्स, लिन का धन्यवाद}

— TFeld
स्रोत

मुझे पूरा यकीन है कि आपको चयनकर्ता की अभिव्यक्ति में पारेंस की आवश्यकता नहीं है, इसलिए i+x>n*6orदो बाइट्स बचाता है।

— लिन

@ लीन थैंक्स :)

— टीएफएलडी

तुम भी जा सकते हैं i+x>~i/n/2%2*6*nया ऐसा कुछ i+x>3*n*(~i/n&2)(दोनों 96 बाइट्स)।

— लिन

5

जावास्क्रिप्ट (V8) , 101 108 बाइट्स

संपादित करें: +7 बाइट्स STDOUT पर प्रिंट करने के लिए

n=>print((k=3*n+!~-n,g=y=>++y<k+n?`
`.padEnd(w=k-Math.max(y>n&&n-y+k,y<k&&y)).padEnd(2*k+~w,'*')+g(y):'')``)

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

टिप्पणी (बिना `print`)

n => (                    // n = input
  k =                     // k is half the maximum width of the star + 1.5
    3 * n + !~-n,         // k = 3n if n > 1 or 4 if n = 1
  g = y =>                // g = recursive function taking y
    ++y < k + n ?         //   increment y; if y is less than k + n:
      `\n`                //     append a line feed
      .padEnd(            //     append w - 1 leading spaces:
        w =               //       where w is defined as
          k -             //       k minus
          Math.max(       //       the maximum of:
            y > n         //         - true (coerced to 1) if y > n
            && n - y + k, //           or n - y + k otherwise (bottom triangle)
            y < k &&      //         - true (coerced to 1) if y < k
            y             //           or y otherwise (top triangle)
          )               //       end of Math.max()
      )                   //     end of padEnd()
      .padEnd(            //     append 2 * (k - w) - 1 stars
        2 * k + ~w,       //       by padding to 2 * k - w - 1
        '*'               // 
      ) +                 //     end of padEnd() 
      g(y)                //     append the result of a recursive call
    :                     //   else:
      ''                  //     stop recursion
)``                       // initial call to g with y = [''] (zero-ish)

— Arnauld
स्रोत

इस चुनौती का सामना करने के लिए जरूरी है कि आपके आउटपुट को सीधे कंसोल पर प्रिंट किया जाए। यह तकनीकी रूप से उस आवश्यकता को पूरा नहीं करता है।

— पोस्ट रॉक गार्फ हंटर

@ श्रीकोटिलिज्म'ओज़िक मुझे बताने के लिए धन्यवाद। यह अब 'निश्चित' है।

— अरनौलद

3

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

×3’+ỊR;Ṭ»Ṛ$”*ẋz⁶ṚZŒBY

एक पूर्ण कार्यक्रम एक सकारात्मक पूर्णांक को स्वीकार करता है जो STDOUT को प्रिंट करता है।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें ।

कैसे?

×3’+ỊR;Ṭ»Ṛ$”*ẋz⁶ṚZŒBY - Main Link: integer, n   e.g. 3
 3                    - three                        3
×                     - multiply (n by)              9
  ’                   - decrement                    8
    Ị                 - insignificant (abs(n)<=1)?   0
   +                  - add                          8
     R                - range                        [1,2,3,4,5,6,7,8]
       Ṭ              - un-truth (n)                 [0,0,1]
      ;               - concatenate                  [1,2,3,4,5,6,7,8,0,0,1]
          $           - last two links as a monad:
         Ṛ            -   reverse                    [1,0,0,8,7,6,5,4,3,2,1]
        »             -   maximum (vectorises)       [1,2,3,8,7,6,7,8,3,2,1]
           ”*         - an asterisk character        '*' 
             ẋ        - repeat (vectorises)          ["*","**",...]
               ⁶      - a space character            ' '
              z       - transpose with filler        ["***********"," ********* ",...]
                Ṛ     - reverse                      ["   *   *   ","   ** **   ",...]
                 Z    - transpose                    ["       *","      **",...]
                  ŒB  - bounce (vectorises)          ["       *       ","      ***      ",...]
                    Y - join with newline characters "       *       \n      ***      \n..."
                      - implicit print

— जोनाथन एलन
स्रोत

2

कैनवस , 25 23 बाइट्स

Ｒ：｛⁸３×４Ｍ∔］∔｛*×］↔⁸１≡？╪］┼

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

बिना हैंडल के 15 बाइट्स1

— dzaima
स्रोत

अच्छे सितारे बनाता है।

— माइकल करस

2

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

×’»ɗ3”*xⱮz⁶ɓ⁶x;»Ṛ$ŒBY

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

एक एकल लिंक को एक एकल पूर्णांक को इसके बाएं तर्क के रूप में स्वीकार किया जाता है और इसके उत्पादन के रूप में स्टार के साथ एक नयालाइन-अलग जेली स्ट्रिंग लौटाता है। जब एक पूर्ण कार्यक्रम के रूप में चलाया जाता है तो स्पष्ट रूप से स्टार को STDOUT में प्रिंट करता है।

व्याख्या

   ɗ3                 | Last three links as a dyad with 3 as right argument:
×                     |   Multiply (by 3)
 ’                    |   Decrease by 1
  »                   |   Maximum of this (and 3)
     ”*xⱮ             | An implicit range from 1 to this many asterisks
         z⁶           | Zip with space as filler
           ɓ          | Start a new dyadic chain with the input as left argument and the list of asterisks as right argument
            ⁶x        | Input many spaces
              ;       | Concatenated to the asterisk list
                 $    | Last two links as a monad:
               »Ṛ     |   Maximum of this list and its reverse
                  ŒB  | Bounce each list (i.e. mirror it without duplicating the middle entry)
                    Y | Join with newlines

— निक केनेडी
स्रोत

1

मैं सराहना करता हूं कि स्टार्ट को स्टाइलिश तरीके से लिखने पर भी ×3’»3लंबाई समान है ^ _ ^

— लिन

1

@ लियोन ने उस बिंदु पर जो मैंने सोचा था कि मैं कई लिंक को मर्ज करने के लिए एक और त्वरित उपयोग करने जा रहा था, और इसका मतलब था कि मैं अधिकतम 4 अनुमति के भीतर ऐसा कर सकता था। हालाँकि, एक बार जब मैंने ɓइसका उपयोग करने का निर्णय लिया तो इससे कोई फर्क नहीं पड़ा लेकिन मैंने इसे रखा क्योंकि मुझे अभी भी यह पसंद है!

— निक केनेडी

2

चारकोल , 25 बाइट्स

Ｇ↙θ←⁺⊗θ¬⊖θ↑⊗θ↘⊕θ*‖Ｏ¬Ｃ⁰¬⊖θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｇ↙θ←⁺⊗θ¬⊖θ↑⊗θ↘⊕θ*

एक अनियमित पंचकोण ड्रा करें जो स्टार के शीर्ष दाहिने हिस्से का प्रतिनिधित्व करता है, लेकिन 1पंक्ति को एक अतिरिक्त स्तंभ व्यापक बनाने के लिए विशेष-आवरण ।

‖Ｏ¬

स्टार को पूरा करने के लिए प्रतिबिंबित।

Ｃ⁰¬⊖θ

स्टार बनाने के लिए अधिक विशेष-आवरण 1अतिरिक्त पंक्ति को लंबा ।

वैकल्पिक समाधान, 25 बाइट्स:

∧¬⊖θ*Ｇ↗↓⊖×³Ｎ*‖Ｏ‖ＯＯ↓∧⊖θ⊖⊗θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

∧¬⊖θ*

*के मामले के लिए एक अतिरिक्त प्रिंट करें 1।

Ｇ↗↓⊖×³Ｎ*

उचित आकार के एक त्रिकोण के बाएं आधे हिस्से को ड्रा करें।

‖Ｏ

त्रिकोण को पूरा करने के लिए प्रतिबिंबित।

‖ＯＯ↓∧⊖θ⊖⊗θ

इसे अपने प्रतिबिंब के साथ ओवरलैप करें, केवल उस मामले को छोड़कर 1, जिस स्थिति में बस इसे प्रतिबिंबित करें।

के लिए विशेष आवरण के बिना 14 बाइट्स 1:

Ｇ<⊖×³Ｎ*‖ＯＯ↑⊖⊗θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｇ<⊖×³Ｎ*

उचित आकार का एक त्रिभुज बनाएँ।

‖ＯＯ↑⊖⊗θ

इसे अपने प्रतिबिंब के साथ ओवरलैप करें।

— नील
स्रोत

2

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

{$_ Z~|[R,] $_}o{.&{|((' 'x--$+$_*3~'*'x$++*2+1)xx$_*3-($_>1)),|($ xx$_)}}

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

वस्तुतः सही अनुपात के साथ एक त्रिकोण बनाता है और स्ट्रिंग या ऑपरेटर का उपयोग करके इसे उल्टा प्रतिलिपि के साथ ओवरलैप करता है (~| ) । एक अग्रणी और अनुगामी लाइन व्हाट्सएप के साथ लाइनों की सूची के रूप में आउटपुट।

स्पष्टीकरण:

                {.&{                                                     }  # Anonymous code block
                      (                        )xx$_*3-($_>1)   # Repeat n*3-(n!=1) times
                       ' 'x--$+$_*3      # With a decreasing indentation
                                   ~'*'x$++*2+1  # Append an increasing triangle
                                       # This creates the triangle
                                                            ,|($ xx$_)  # And add some padding lines
{             }o   # Pass the triangle to the combining function
    Z~|            # Zip string bitwise or
 $_                # The list
       [R,] $_     # With its reverse

— मजाक कर रहा है
स्रोत

2

जे , ५३ ५० बाइट्स

' *'{~[:(+.|.),.@#&0,~[:(|.,}.)"1*@<:>:/~@i.@-~3*]

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

ungolfed

' *' {~ [: (+. |.) ,.@#&0 ,~ [: (|. , }.)"1 *@<: >:/~@i.@-~ 3 * ]

किस तरह

फ़ंक्शन के >:रूप में (अधिक से अधिक या बराबर) का उपयोग करके आधा त्रिकोण बनाने के लिए एक फ़ंक्शन तालिका (एक 3 जी ग्रेड टाइम टेबल की तरह) का उपयोग करें । फिर प्रत्येक पंक्ति को उल्टा करें, आखिरी कॉलम को काटें, और पूर्ण त्रिकोण प्राप्त करने के लिए दोनों पक्षों को एक साथ सिलाई करें (लेकिन 1 और 0 से बना)। nतल पर शून्य की पंक्तियाँ जोड़ें । अंत में पूरी चीज को उल्टा कर दें, और मूल पर इसे ओवरले करें, बूलियन का उपयोग करें या +.परिणाम प्राप्त करने के लिए। फिर 1 से *0 और रिक्त स्थान पर बारी ।

— जोनाह
स्रोत

अच्छा! यहां मेरा समाधान है - समान लंबाई, अलग दृष्टिकोण: इसे ऑनलाइन आज़माएं!

— गालेन इवानोव

1

धन्यवाद। यह निश्चित है कि ऐसा लगता है कि इसे और अधिक चलाया जा सकता है, लेकिन मैंने कुछ अन्य तरीकों की कोशिश की और ऐसा करने में सक्षम नहीं था।

— योना

2

टी-एसक्यूएल, 194 बाइट्स

@ इनपुट मूल्य है

@c शीर्ष त्रिकोण की चौड़ाई को संभालता है

@d चौड़ाई नीचे त्रिकोण संभालती है

@eइसमें @cया तो आउटपुट होता है या @d- यह कुछ बाइट्स को बचाता है

@fइनपुट के रूप में 1 के विशेष मामले को संभालता है। @c*@=3निर्धारित करता है कि कब उपयोग करना है @f। लेखन की तुलना में 5 बाइट सस्ता@c=3and @=1

DECLARE @ INT=8

,@c INT=1,@e INT=1,@d INT,@f INT=0SET @d=@*8-3r:PRINT
space(@*3-@e/2+@f/2)+replicate('*',@e-@f)SELECT
@c=nullif(@c,@*6-3)+2,@f=iif(@c*@=3,2,0),@d-=2-@f,@e=iif(@c>@d
or @c/2<@,@c,@d)IF @d>0goto r

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

— t-clausen.dk
स्रोत

1

जाप `-R` , 25 बाइट्स

+5 बाइट्स के लिए n=1: \

õ cUon3*U-´UÎ)®ç* êÃê!U û

कोशिश करो

õ cUon3*U-´UÎ)®ç* êÃê!U û     :Implicit input of integer U
õ                             :Range [1,U]
  c                           :Concatenate
   Uo                         :  Range [0,U)
     n                        :  Subtract each from
      3*U-                    :    Multiply U by 3 and subtract
          ´U                  :      Decrement U
            Î                 :      Get sign
             )                :End concat
              ®               :Map each Z
               ç*             :  Repeat "*" Z times
                  ê           :  Palindromise
                   Ã          :End map
                    ê!U       :If decremented U is 0, append reverse, else, palindromise
                        û     :Centre pad each line with spaces to the length of the longest
                              :Implicitly join with newlines and output

— झबरा
स्रोत

सितारे बनाते हैं सितारे

परिचय

Parametrics

उदाहरण

चुनौती

स्कोरिंग

05AB1E , 21 बाइट्स

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

व्याख्या

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

सभी संभालती हैएन> 1एन>1N>1

जैसे सभी मामलों को संभालता हैएन= 1एन=1N=1

आर , 125 107 101 बाइट्स

आर , 150 148 136 135 130 128 बाइट्स

पायथन 2 , 101 99 97 बाइट्स

जावास्क्रिप्ट (V8) , 101 108 बाइट्स

टिप्पणी (बिना print)

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

कैसे?

कैनवस , 25 23 बाइट्स

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

व्याख्या

चारकोल , 25 बाइट्स

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

स्पष्टीकरण:

जे , ५३ ५० बाइट्स

ungolfed

किस तरह

टी-एसक्यूएल, 194 बाइट्स

जाप -R , 25 बाइट्स

सभी संभालती है $N>1$

जैसे सभी मामलों को संभालता है $N=1$

टिप्पणी (बिना `print`)

जाप `-R` , 25 बाइट्स