"कूल एस" ड्रा करें

Question

परिचय

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

nइनपुट के रूप में एक स्केल फैक्टर को देखते हुए (जहाँ ), ASCII कला में कूल S का उत्पादन करता है।$1\leq n\leq 20$

इसे कैसे ड्रा करें

कूल S पर विकिपीडिया पेज से :

उत्पादन

कूल एस जब n= 1 है:

   ^
  / \
 /   \
/     \
|  |  |
|  |  |
\  \  /
 \  \/
 /\  \
/  \  \
|  |  |
|  |  |
\     /
 \   /
  \ /
   v

और के विभिन्न मूल्यों के लिए n, आप बस उत्पादन nसमय को बड़ा बनाते हैं । उदाहरण के लिए, n= 2:

     ^  
    / \
   /   \
  /     \
 /       \
/         \
|    |    |
|    |    |
|    |    |
|    |    |
\    \    /
 \    \  /
  \    \/
  /\    \
 /  \    \
/    \    \
|    |    |
|    |    |
|    |    |
|    |    |
\         /
 \       /
  \     /
   \   /
    \ /
     v

ध्यान दें कि ऊर्ध्वाधर खंड दो गुना लंबे हैं और ऊर्ध्वाधर लाइनों के बीच अंतर दो गुना व्यापक है।

और जब n= 3:

       ^
      / \
     /   \
    /     \
   /       \
  /         \
 /           \
/             \
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
\      \      /
 \      \    /
  \      \  /
   \      \/
   /\      \
  /  \      \
 /    \      \
/      \      \
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
\             /
 \           /
  \         /
   \       /
    \     /
     \   /
      \ /
       v

नोट: यद्यपि आवश्यक नहीं है, आपका कोड भीn= 0का समर्थन करने में सक्षम हो सकता है:

 ^
/ \
\\/
/\\
\ /
 v

जीतना

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

Comments

संबंधित: एक S- चैन ड्रा करें

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

ASCII- बिल्डिंग का 90 का बच्चा मेरे लिए टिप के लिए ^ के बजाय / \ का उपयोग करने का सुझाव देना चाहता है। इस तरह से क्लीनर दिखता है, साथ ही यह एक ही ढलान झुकाव को बनाए रखता है :)

— फ्लेटर

@ केवल समस्या यह है कि / \ दो वर्णों का उपयोग करता है, इसलिए केंद्रीय लंबवत रेखा को ऑफसेट करना होगा जो इसे बहुत अस्वाभाविक लगता है

— बीटा डेके

@ बेताडे: यह एन = 2 और एन = 3 पर ठीक लगता है (क्योंकि यह बिंदु समरूपता को बरकरार रखता है), लेकिन मैं एन = 1 के लिए सहमत हूं। उल्टा V का विकल्प भी है:Λ

— Flater

@ जैकोबगर्बी: मेरा तर्क शैलीगत था, न कि गोल्फ :)

— फ्लेटर

Answer 1

चारकोल , 58 53 47 43 41 बाइट्स

Ｎθ≔⊕⊗θδ↗θ/⊗θ↘δ^‖Ｂ↓‖Ｍ← vＭδ⁰⊗θ↗⊕θＭ⁰δ↗θ/⊗θ⟲Ｔ

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

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

     /----\    /----\     
    /      \  /      \    
   /        \/        \   
  /         /          \  
 /         /            \ 
v     ----/    /----     ^
 \            /         / 
  \          /         /  
   \        /\        /   
    \      /  \      /    
     \----/    \----/     

और फिर मुझे बस कैनवास को 90 डिग्री वामावर्त घुमाने की आवश्यकता है।

Comments

आप कुछ पर हो सकते हैं ... 22 बाइट्स आप सभी को बाहर से मिलती हैं ...

— नील

@ नहीं यह बिल्कुल ऐसा नहीं था, आपके विचार को मामूली सुधार की आवश्यकता थी, लेकिन वास्तव में यह एक महान सुधार रहा है!

— चार्ली

हाँ, मैंने अपनी मूल पोस्ट पर इसी तरह की गलती की है क्योंकि मैंने स्केलिंग के प्रभाव की सही जाँच नहीं की है।

— नील

किसी ने कहा Rotate? इससे मुझे अंदाजा हो जाता है ...

— नील

@ नील हे, आपको वहां काफी सुधार मिला! :-)

— चार्ली

Answer 2

पायथन 3 , 255 249 248 209 बाइट्स

-6 बाइट्स केविन क्रूज़सेन को धन्यवाद

केविन क्रूज़सेन के लिए धन्यवाद

रॉड और जो किंग को -39 बाइट्स धन्यवाद

n=int(input())
m=2*n
a,b,q,c,l='\ \n/|'
f=m*b
s=q+q.join([f[d:]+c+b*2*d+b+a+f[d:]for d in range(m+1)]+[l+f+l+f+l]*m+[d*b+a+f+a+f[d*2:]+c+d*b for d in range(n)]+[n*b+a+f+a+c+n*b])
print(f,'^'+s+q+s[::-1]+f,'v')

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

यह अब n = 0 को हैंडल करता है।

Comments

दोनों o+~dहो सकते हैं m-dऔर range(o)हो सकते हैं range(m+1), और फिर आप o=m+1\n6 बाइट बचाने के लिए निकाल सकते हैं । हालांकि अच्छा जवाब, मेरी ओर से +1।

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

ओह, और बदल कर एक और बाइट p(s)\np(s[::-1])के लिए p(s+q+s[::-1]): 248 बाइट्स

— केविन Cruijssen

आप 6 बाइट्स बचा सकता है यदि आप एक ही का उपयोग printको हटाने के द्वारा, और अधिक 4 []से join([...]), 238 बाइट्स totalizing

— रॉड

आप q.joinबाइट को बचाने के लिए एक चर में भी स्टोर कर सकते हैं

— रॉड

217 । सभी q.joinएस, और अन्य चीजों के एक जोड़े में शामिल हो गए

— जो राजा

Answer 3

चारकोल , 47 42 41 बाइट्स

Ｆv^«↓⊗θ↘⊗⊕θ←↓⊗θ↙⊕⊗θ↖ι↖⊕⊗θ→↑⊗θ↗⊕θＭθ⁺⊗θ⊕θ⟲⁴

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

   ^
  / \
 /   \
/     \
|  1  |
|  1  |
\  2  /
 \  2/
 8\  2
8  \  2
7  |  3
7  9  3
6     4
 6   4
  6 4
   5

5स्ट्रिंग का वर्तमान वर्ण कहाँ है v^। पहले लूप के अंत में कर्सर तब बिंदु पर स्थित होता है 9। पूरे कैनवास को तब घुमाया जाता है ताकि कूल एस के दूसरे हिस्से को खींचा जा सके। (कैनवास वास्तव में दो बार घुमाया जाता है, लेकिन यह सिर्फ एक कार्यान्वयन विवरण है।)

चारकोल समर्थन नहीं करता है, RotateCopy(:Up, 4)लेकिन अगर यह किया तो यह 33 बाइट्स के लिए काम करेगा:

↖^↖⊕⊗θ→↑⊗θ↗⊕θ‖ＢＭ↓↙⊗θ→↓⊗θ⟲Ｃ↑⁴Ｊ⁰¦⁰v

Comments

@BetaDecay इसके बारे में क्षमा करें। मेरे पास वैसे भी गलत बाइट गिनती थी ...

— नील

अच्छा है, यह n = 0 सही भी मिलता है

— बीटा डेके

Answer 4

कैनवस , 36 32 29 बाइट्स

«|＊‼ｌ├／Ｌ１^╋；╶╵＼∔∔│α╶«├：╵╋：↔↕∔

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

ढेर ढेर हेरफेर। (पुराना) स्पष्टीकरण:

«|*                                an array of input*2 "|"s
   ‼                               cast to a 2D object (needed because bug)
    :                              duplicate that (saved for the center line)
     l├                            height+2
       /                           create a diagonal that long
        L1^╋                       and in it, at (width; 1) insert "^"
            ;∔                     append the vertical bars
                               ^
                              /
          so far done:       / 
                            /  
                            |  
                            |  
              ⁸╵                   input+1
                \                  antidiagonal with that size
                 ∔                 appended to the above
                  │                mirror horizontally
                              ^
                             / \
                            /   \
                           /     \
                current:   |     |
                           |     |
                           \     /
                            \   /                                                       |
                   α               get the 2nd to last popped thing - the antidiagonal  |
                    └∔             append it to the vertical line copied way before:    \
                      ⁸«├          input/2 + 2                                            \
                         :╵        duplicate + 1
                           ╋       at (input/2 + 2; input/2 + 3) in the big part insert  ^
                            :↔↕∔   mirror a copy vertically & horizontally and append that to the original

Answer 5

पायथन 2 , 227 208 207 202 196 181 बाइट्स

I=n=2*input()
R,L,S,P='/\ |'
k=n*[2*(P+S*n)+P]
exec"k=[R+S+2*S*I+L]+k+-~I%2*[L+S*n+L+S*I+R];I-=1;"*-~n
print'\n'.join(t.center(2*n+3)for t in['^']+k+[a[::-1]for a in k[::-1]]+['v'])

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

करने के लिए Thks जो राजा 1 बाइट के लिए; और फिर एक और 5 बाइट्स कुल (के माध्यम से n => 2*n)।

n=0साथ ही काम करता है ।

Answer 6

सी (जीसीसी) , 379 353 344 334 बाइट्स

मैंने #defineआंतरिक कार्यों के बीच संवाद करने के लिए उप-प्रादेशिक उन्मूलन और कई ग्लोबल्स के लिए एस का एक जोड़ा इस्तेमाल किया । एस का निर्माण करने के लिए मुख्य लूप {0,1,2,3,3,2,1,0} जाता है।

सुझाव के लिए जोनाथन फ्रेच को धन्यवाद।

#define z(a,b...)printf("%*c%*c%*c\n"+a,b);}
#define y(a){for(i=~-a*t;v*i<v*a*!t+t;i+=v)
i,n,p,r,t,u,v;a(){z(6,r+2,94+t*24)b()y(-~r)z(3,-i-~r,47+u,i*2+2,92-u)c()y(r)z(0,~r,124,~r,124,~r,124)d()y(-~n)z(0,i+1,92-u,2*(n-t*i)+1,92,2*(n-!t*i)+1,47+u)(*x[])()={a,b,c,d};f(s){r=2*s;for(p=0;p<8;x[7*t-p++*(2*t-1)](n=s))t=p>3,v=2*!t-1,u=t*45;}

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

Comments

w -r-1संभवतः गोल्फ हो सकता है w~r।

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

हालाँकि तब इनलाइनिंग एक बाइट छोटी होती है ।

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

344 बाइट्स ।

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

321 बाइट्स

— सीलिंगकैट

Answer 7

सी (जीसीसी) , 260 254 बाइट्स

-6 बाइट्स सीलिंगकैट के लिए धन्यवाद ।

f(n){int s=2*n++,t=s+1,I[]={1,t,s,n,n,s,t,1},A[]={s,1,1,1,2*t,1,t,t,1,t,1,n,t,t,1,t,t,1,1,1,t,s,1,1},x;for(s=8;s--;)for(n=0;n<I[s];n++,puts(""))for(t=3;t--;)x=s*3+t,printf("%*c",n*("AAAA?BAAAAC@?ABAAACA@AAA"[x]-65)+A[x],"w!!!0]}}}]]00]]}}}]!0_!!"[x]-1);}

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

मंद होना

हम आकृति को भागों में विभाजित कर सकते हैं:

 ^           Top cap
/ \          Top slope
|||          Sides
\\/          Twist, part 1
/\\          Twist, part 2
|||          Sides
\ /          Bottom slope
 v           Bottom cap

प्रत्येक भाग को कई पंक्तियों, तीन वर्णों, और तीन रिश्तों द्वारा कुछ मूल्यों के साथ वर्णित किया जा सकता है जो प्रत्येक पंक्ति में क्षेत्र-चौड़ाई का निर्णय लेते हैं।

एक पहला पुनरावृत्ति हुआ:

#define g(x,s,A,B,C)for(i=0;i<x;i++)printf("%*c%*c%*c\n",A,*s,B,s[1],C,s[2]);
f(n)
{
    int s=2*n++,t=s+1,i;

    g(1,  "  ^",  1,      1,  t-1)
    g(t, "/ \\",t-i,      1,2*i+1)
    g(s,  "|||",  1,      t,    t)
    g(n,"\\\\/",i+1,      t,t-2*i)
    g(n,"/\\\\",n-i,  2*i+1,    t)
    g(s,  "|||",  1,      t,    t)
    g(t, "\\/ ",i+1,2*t-2*i,    1)
    g(1,  "  v",  1,      1,  t-1)
}

g()मैक्रो को कॉल बहुत दिखता है जैसे एक मेज का निर्माण किया जा सकता है और उस पर लूप किया जा सकता है। फ़ील्ड-चौड़ाई कभी-कभी इंडेक्स काउंटर से संबंधित होती है, और कभी-कभी नहीं। हम फ़ील्ड-चौड़ाई को सामान्य कर सकते हैं F * i + A, जहाँ F को गुणा करने के लिए कुछ कारक है i, और A को चौड़ाई में जोड़ने के लिए कुछ मूल्य है। -2 * i + tउदाहरण के लिए, चौथे कॉल की अंतिम चौड़ाई होगी ।

इस प्रकार हम प्राप्त करते हैं:

f(n){int s=2*n++,t=s+1,         s = size of "side" parts, t = size of top and bottom slopes
I[]={1,t,s,n,n,s,t,1},          The number of lines per part.
A[]={...},x;                    A[] holds the values to add to each field-width.
for(s=8;s--;)                   Loop through the parts.
for(n=0;n<I[s];n++,puts(""))    I[s] decides how many lines to the part. Ends with newline.
for(t=3;t--;)                   Go through the three chars of each line.
x=s*3+t,                        Calculate offset.
printf("%*c",                   Print the char.
n*("..."[x]-65)+A[x],           Build field-width. The string holds the index factor, A[]
                                holds the offset part.
"..."[x]-1);}                   The char itself is grabbed from the string.
                                Shifted by 1 to eliminated double backspaces.

अंत में यह g()कॉलिंग के एक कड़े संस्करण की तुलना में बहुत कम नहीं था , लेकिन कम छोटा है।

Comments

@ceilingcat चीयर्स।

— गैस्ट्रोपनर

@ceilingcat फ़ंक्शन तर्कों का अपरिभाषित मूल्यांकन क्रम मुझे विराम देता है।

— गैस्ट्रोपनर

Answer 8

जावा, 435 बाइट्स

फ़ंक्शन स्वयं 435 बाइट्स लेता है। निश्चित रूप से सुधार के लिए जगह है, "उच्च स्तर" नियमों के विश्लेषण के बारे में कि किस स्थान पर किस चरित्र को (अंत में एस बिंदु-सममित है), और "निम्न-स्तर", शास्त्रीय गोल्फिंग द्वारा (शायद दूसरे चर को खींचकर या दो for-लूप का संयोजन )। लेकिन यह इस अप्राकृतिक भाषा के साथ पहला शॉट है:

import static java.util.Arrays.*;
import static java.lang.System.*;

public class CoolS
{
    public static void main(String[] args)
    {
        print(1);
        print(2);
        print(3);
    }
    static void print(int n){int i,r,d=3+6*n,w=3+n*4,h=6+n*10,m=n+n,v=w/2,k=h-1,j=w-1;char t[],S='/',B='\\',P='|',s[][]=new char[h][w];for(char x[]:s)fill(x,' ');s[0][v]='^';s[k][v]='v';for(i=0;i<1+m;i++){r=i+1;t=s[r];t[v-r]=S;t[v+r]=B;t=s[k-r];t[v-r]=B;t[v+r]=S;}for(i=0;i<m;i++){r=2+m+i;t=s[r];t[0]=t[v]=t[j]=P;t=s[k-r];t[0]=t[v]=t[j]=P;}for(i=0;i<1+n;i++){r=2+m+m+i;t=s[r];t[i]=t[i+1+m]=B;t[j-i]=S;t=s[d-i];t[i]=S;t[v-i]=t[j-i]=B;}for(char x[]:s)out.println(x);}
}

Comments

नमस्ते। आयात बाइट-काउंट का एक हिस्सा है जिससे मैं डरता हूं, इसलिए आपका वर्तमान उत्तर वास्तव में 478 बाइट्स है । लेकिन आप इसे नीचे कर सकते हैं (संयोग से पर्याप्त) अपने वर्तमान 435 बाइट्स को गोल्फ के लिए कुछ बुनियादी चीजों के साथ।

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

कुछ चरों को हटाकर और बाइट्स को बचाने के लिए थोड़ा कम उपयोग करके 405 बाइट्स के लिए थोड़ा अधिक गोल्फ करने में सक्षम है t=...। यदि आपके द्वारा किए गए किसी भी बदलाव के बारे में आपके कोई प्रश्न हैं, तो मुझे बताएं। :)

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

धन्यवाद @KevinCruijssen, दुर्भाग्य से मैं वर्तमान में अधिक समय यहाँ निवेश नहीं कर सकता - यह सिर्फ एक मनोरंजक बात थी, और जावा की "क्रियाशीलता" को देखते हुए, किसी भी तरह से एक गंभीर प्रतियोगी नहीं; ;-) अपने स्वयं के उत्तर के रूप में अपने समाधान को जोड़ने पर विचार करें, हालांकि - फिर हम कम से कम कुछ इंट्रा-भाषा प्रतियोगिता है :-)

— मार्को

Answer 9

PHP , 378 374 378 377 376 335 331 328 बाइट्स

-3 बाइट्स, मैनटवर्क के लिए धन्यवाद

-4 बाइट्स, str_repeat के बजाय str_pad का उपयोग किया

-41 बाइट्स, मैनटवर्क्स के सुझावों के लिए धन्यवाद

-1 बाइट, दो वेतन वृद्धि को + = 2 में मिला देता है

-1 बाइट, निकाला गया शानदार

-4 बाइट्स एक बार गूंजने से। भूल गए मुझे स्ट्रिंग को फ़ंक्शन में पास करने की आवश्यकता है ताकि यह अधिक बाइट्स हो

N = 0 के लिए भी काम करता है।

function s($b){return str_pad($w,$b);}echo s($i=1+$a=2*$argv[1]).'^
';for(;$i;$j++,$y=$z.$y)echo$z=s(--$i).'/'.s(++$j).'\
';for(;$k<$a;$k++)$x.='|'.s($a).'|'.s($a).'|
';echo$x;for(;$l<=$a/2;)echo s($m++).$c='\\',s($a).$c.s($a-$l++*2).'/
';for(;$m;$n+=2)echo s(--$m).'/'.s($n).$c.s($a).'\
';echo$x.strtr($y,'/\\','\/').s($a+1).v;

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

Comments

चूंकि फ़ंक्शन की घोषणा काफी महंगी है और आप केवल दो बार टी () का उपयोग करते हैं, इसके बिना छोटा होगा । यदि आप 9 नोटिसों के साथ-साथ 1 चेतावनी भी लेते हैं, तो आप 'v'फाइनल में उद्धरणों को निकाल सकते हैं echo।

— मैनटवर्क

आप ऊपर और नीचे तिरछे भागों के लिए एकल लूप का उपयोग कर सकते हैं । $ A और $ i के आरंभ को उनके पहले उपयोग में ले जाकर कॉम्पैक्ट किया जा सकता है।

— मैनटवर्क

ओह, और $i>0और $m>0बस के रूप में लिखा जा सकता है $iऔर $m।

— मैनटवर्क

रिक्त स्थान के साथ , कुछ अन्य समाधानों के रूप में।

— मैनटवर्क

आप $ c की घोषणा को इसके पहले उपयोग के लिए भी स्थानांतरित कर सकते हैं। बस .इसे करने के बाद संघनन बदलें ,। इसे ऑनलाइन आज़माएं!

— मैनेटवर्क

Answer 10

पायथन 3 , 321 307 बाइट्स

14 बाइट बचाने के लिए @EsolangingFruit को धन्यवाद

n=int(input())
b,f='\/'
c,l=4*n+3,10*n+6
r=range
h=c//2
L=[c*[' ']for _ in r(l)]
L[0][h],L[-1][h]='^v'
for i in r(h):a=L[h-i];a[i],a[c+~i]=f,b
for i in r(2*n):L[h-~i][0::h]='|'*3
for i in r(n+1):a=L[h+h+i];a[c+~i],a[i:c-1:h]=f,b*2
for i in r(1,l//2):L[l+~i]=L[i][::-1]
print('\n'.join(''.join(i)for i in L))

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

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

n=int(input())
b,f='\/'
c,l,r=4*n+3,10*n+6,range
h=c/2
L=[c*[' ']for _ in r(l)]
L[0][h],L[-1][h]='^v'
for i in r(h):a=L[h-i];a[i],a[c+~i]=f,b
for i in r(2*n):L[h-~i][0::h]='|'*3
for i in r(n+1):a=L[h+h+i];a[c+~i],a[i:c-1:h]=f,b*2
for i in r(1,l/2):L[l+~1]=L[i][::-1]
print'\n'.join(''.join(i)for i in L)

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

Comments

आप तीन बाइट्स को बचाने के '\\','/'लिए दूसरी पंक्ति से बदल सकते हैं *'\/'।

— फलन

307 बाइट्स: इसे ऑनलाइन आज़माएं!

— फलन

धन्यवाद! @EsolangingFruit! मुझे पायथन में बिट ऑपरेशन के बारे में पता नहीं था। इसके अलावा, यह विभाजन और कोष्ठकों के कारण Python2 का उपयोग करने के लिए कुछ बाइट्स बचाएगाprint

— Pétur

पायथन 2 में, input()स्वचालित रूप eval()से स्ट्रिंग है, तो आप int()कॉल को भी छोड़ सकते हैं ।

— Esulanging Fruit

पायथन 3 के लिए, आप अंतिम पंक्ति को बदल सकते हैं for l in L:print(*l,sep="")(मुझे नहीं लगता कि पायथन 2 में कोई समकक्ष है)।

— बजे फलों का जूल