कुछ ASCII सितारों को ड्रा करें

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो इनपुट के रूप में हथियारों के आकार को देखते हुए, एक ASCII स्टार को खींचता है।

यहाँ आकार का एक तारा है 1

_/\_
\  /
|/\|

यहाँ आकार का एक तारा है 2

   /\
__/  \__
\      /
 \    /
 | /\ |
 |/  \|

यहाँ आकार का एक तारा है 3

     /\
    /  \
___/    \___
\          /
 \        /
  \      /
  |  /\  |
  | /  \ |
  |/    \|

और इसी तरह।

इनपुट

एक एकल सकारात्मक पूर्णांक किसी भी सुविधाजनक प्रारूप में , n > 0।

उत्पादन

उपरोक्त नियमों का पालन करते हुए एक तारे का ASCII- कला निरूपण। नए सिरे या अन्य व्हाट्सएप को लीडिंग / ट्रेलिंग वैकल्पिक है, बशर्ते कि अंक उचित रूप से ऊपर हों।

नियम

• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

क्या यह सिर्फ मेरी स्क्रीन है, या सितारे असामान्य रूप से लंबे और पतले दिखते हैं?

— caird coinheringaahing

मूर्ख ASCII और उथले

— तिरछेपन

@cairdcoinheringaahing एसई द्वारा उपयोग किया जाने वाला फ़ॉन्ट वर्ग नहीं है - लाइनों के बीच महत्वपूर्ण व्हाट्सएप है, जो विरूपण को बढ़ाता है।

— AdmBorkBork

Answer 1

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

-3 बाइट्स नील को धन्यवाद।

Ｎν↙ν↑↑ν↖ν ×_ν↗ν‖Ｍ

इसे ऑनलाइन आज़माएं! लिंक वर्बोज वर्जन के लिए है।

मैं इस गोल्फ के साथ बहुत खुश हूँ ...

व्याख्या

Ｎν                 take a number as input and store in ν
  ↙ν               print / ν times downwards to the left
    ↑              move up once
     ↑ν            print | ν times upwards
       ↖ν          print \ ν times upwards to the left
                   print a space
          ×_ν      print _ ν times
             ↗ν    print / ν times upwards to the right
               ‖Ｍ  reflect horizontally

     /\                           
    /  \    "No, this is Patrick!"
___/    \___                      
\   ☉ ☉    /                      
 \   𝐷    /                       
  \      /                        
  |  /\  |                        
  | /  \ |                        
  |/    \| 

Comments

इसे ऊपर से नीचे खींचना 2 बाइट्स बचाता है।

— नील

किसी कारण के लिए, मुझे तर्क को बढ़ाना होगा Polygon... क्या मैं कुछ गलत कर रहा हूं?

— 21

ऐसा इसलिए है क्योंकि Polygonपिछले चरित्र पर कर्सर छोड़ता है, लेकिन मैं उपयोग नहीं कर रहा था Polygon... वास्तव में मैं सबसे अच्छा कोड का उपयोग नहीं कर रहा था, मैं अब 17 से नीचे हूं।

— नील

मुझे पता नहीं है कि अगर मुझे उसी तरह से 17 मिल गए लेकिन आपने किया ... धन्यवाद!

— पूरी तरह से

पर्याप्त के पास। मेरे पास वास्तव में था Move(:Right); for (n) Print("_");।

— नील

Answer 2

SOGL V0.12 , 27 24 बाइट्स

╔*¹.╚№┼№.╝+ø┐.∙.1ž.╚┼+╬³

यह कोशिश करो!

स्पष्टीकरण:

╔*                        push a string with input amount of underscores
  ¹                       wrap that in an array
   .╚                     push a "/" diagonal of the size of the input (the top lines)
     №                    reverse vertically
      ┼                   add horizontally the underscores behind the array
       №                  reverse vertically back
        .╝+               below that add a "\" diagonal (middle lines)
           ø              push an empty string as the base of the vertical bars
            ┐.∙           get an array of "|" with the length of the input
               .1ž        at [input; 1] in the empty string insert that
                  .╚┼     horizontally append a "/" diagonal
                     +    add that below everything else
                      ╬³  palindromize horizontally

Answer 3

पायथन 2 ,  166 160 157 155  152 बाइट्स

execदृष्टिकोण बिल्कुल एक ही बाइट गिनती है।

i=input();t,z=" \\";y=t*2
for k in range(i*3):s=k%i;o=i+~s;p=i+o;g="_ "[i>k+1]*p;print[g+"/"+y*k+z+g,t*s+z+y*p+"/",~-i*t+"|"+o*t+"/"+y*s+z+o*t+"|"][k/i]

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

जोनाथन फ़्रेच के लिए 3 बाइट्स को सहेजा गया ।

Comments

आप के t=" ";y,z=t*2,"\\"साथ बदलकर कुछ बाइट्स बचा सकता है t,z=" \\";y=t+t।

— जोनाथन फ्रीच

@JonathanFrech आपको धन्यवाद।

— श्री एक्सकोडर

Answer 4

जावा 8, 385 376 344 304 285 280 268 264 252 250 + 19 बाइट्स

n -> {int s = 2 * n, w = 2 * s, e = n-1, i = 0, o, l [] [] = नया int [n * 3] [w]; के लिए; i; <n; एल [मैं] [s + ~ मैं] = एल [n + मैं] [w + ~ मैं] = एल [ओ] [s + ~ मैं] = 47, एल [मैं] [ओ] = एल [ओ] [ ओ] = एल [n + मैं] [मैं] = 92, एल [ई] [i] = एल [ई] [डब्ल्यू - ++ मैं] = 95, एल [ओ] [ई] = एल [ओ] [ s + n] = 124) o = s + i; के लिए (int [] b: l) System.out.println (नया स्ट्रिंग (b, 0, w) .replace (" ", "");});

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

Comments

आप बिटवाइज़ ट्रिक्स का उपयोग करके इसे 10 बाइट्स तक छोटा कर सकते हैं और अपने सभी पूर्णांक घोषणाओं को अपने छोरों ( 270 बाइट्स ) से बाहर ले जा सकते हैं

— बढ़ा सकते हैं मिस्टर एक्सकोडर

और आप अभी भी एक और 2 बाइट्स int o=को लूप के बाहर ले जाकर बचा सकते हैं ( 268 बाइट्स )

— श्री एक्सकोडर

आप लूप ब्रैकेट्स से छुटकारा पाकर और इस तरह ++की अंतिम घटना पर सीधे उपयोग करके 4 और बाइट्स बचा सकते हैं i, जैसे: 264 बाइट्स ।

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

252 बाइट्स

— नेवई

@ नवीन बहुत चालाक, आपको धन्यवाद

— रॉबर्टो ग्राहम

Answer 5

गणितज्ञ, 189 बाइट्स

n(
  s_±x_±y_:=s->Array[If[x==y,s," "]&,{n,n}];
  StringRiffle[Characters@{"_/\\_","\\  /","|/\\:"}/.
    {"_"±#±n,"|"±#2±n,":"±#2±1,"\\"±#±#2,"/"±(n-#+1)±#2," "±0±1}
    /.":"->"|"//ArrayFlatten,"
",""])

लाइन 2 सहायक ऑपरेटर को परिभाषित करता है ±, जिसका उपयोग लाइन 4 का मूल्यांकन करने के लिए किया जाता है:

{"_"  -> Array[If[#1 == n,          "_", " "] &, {n, n}], 
 "|"  -> Array[If[#2 == n,          "|", " "] &, {n, n}], 
 ":"  -> Array[If[#2 == 1,          ":", " "] &, {n, n}], 
 "\\" -> Array[If[#1 == #2,         "\\"," "] &, {n, n}], 
 "/"  -> Array[If[1 + n - #1 == #2, "/", " "] &, {n, n}], 
 " "  -> Array[If[0 == 1,           " ", " "] &, {n, n}]}

पंक्ति 3 में, ReplaceAll( /.) आकार 1 के स्टार के साथ-साथ उपरोक्त नियमों की सूची का प्रतिनिधित्व करने वाला एक मैट्रिक्स लेता है। अंतिम चरणों के लिए, हम उपयोग करते हैं ArrayFlatten, जो की तुलना में छोटा है SubstitutionSystem, और StringRiffle।

Answer 6

जावा 7, 295 बाइट्स

समाधान विधि है f ।

String s(String s,int n){while(n-->0)s=" "+s;return s;}String f(int x){String n="\n",s="/",b="\\",o="",u="_";int i=0;for(x--;i<x;u+="_")o+=s(s,2*x-i+1)+s(b,2*i++)+n;o+=u+s+s(b,2*i)+u+n;while(i>=0)o+=s(b,x-i)+s(s,4*x-2*(x+~i--))+n;while(i++<x)o+=s("|",x)+s(s,x-i)+s(b,2*i)+s("|",x-i)+n;return o;}

इसे ऑनलाइन आज़माएं (JDK 8)

Ungolfed

String s(String s, int n) {
    while (n-- > 0)
        s = " " + s;
    return s;
}

String f(int x) {
    String
        n = "\n",
        s = "/",
        b = "\\",
        o = "",
        u = "_"
    ;
    int i = 0;
    for (x--; i < x; u += "_")
        o += s(s, 2*x - i + 1) + s(b, 2 * i++) + n;
    o += u + s + s(b, 2 * i) + u + n;
    while (i >= 0)
        o += s(b, x - i) + s(s, 4*x - 2*(x + ~i--)) + n;
    while (i++ < x)
        o += s("|", x) + s(s, x - i) + s(b, 2 * i) + s("|", x - i) + n;
    return o;
}

स्वीकृतियाँ

• -1 केविन क्रूज़सेन को धन्यवाद

Comments

आप एक बाइट xको शुरुआत से 1 दाईं ओर कम करके बचा सकते हैं :<T>String s(T s,int n){return"".format("%"+-~n+"s",s);}String f(int x){String n="\n",s="/",b="\\",o="",u="_";int i=0;for(x--;i<x;u+="_")o+=s(s,2*x-i+1)+s(b,2*i++)+n;o+=u+s+s(b,2*i++)+u+n;for(;i-->0;)o+=s(b,x-i)+s(s,4*x-2*(x+~i))+n;for(;++i<=x;)o+=s("|",x)+s(s,x-i)+s(b,2*i)+s("|",x-i)+n;return o;}

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

Answer 7

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

n=input()
b,f,s,v='\/ |'
for i in range(3*n):u=i/~-n*n*'_';d=f+i%n*2*s+b;print[u+d+u,b+s*2*(3*n+~i)+f,v+d.center(2*n)+v][i/n].center(4*n)

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