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

इस चुनौती का उद्देश्य इस तरह के सरलीकृत एनीमेशन के एकल 2 डी फ्रेम को आकर्षित करना है, जिसमें त्रिकोणों के लिए एक चौड़ाई और भागों के बीच दिए गए रिक्ति हैं।

इनपुट

इनपुट दो पूर्णांकों के होते हैं: एक चौड़ाई और एक रिक्ति मूल्य । $w\ge1$ $s\ge0$

उत्पादन

फ्रेम को निम्नलिखित विनिर्देशों के अनुसार खींचना होगा:

         /\
        /  \____________ this part is horizontally centered
       /    \
      /______\
                    \___ s empty lines
                    /
   /\          /\
  /  \        /  \______ w+1 backslashes
 /    \      /    \
/______\    /______\
                \_______ 2w underscores
        |__|
          \_____________ 2s spaces

उपरोक्त उदाहरण में, हमारे पास और । $w=3$ $s=2$

और ज्यादा उदाहरण

, : $w=1$ $s=0$

   /\   
  /__\  
 /\  /\ 
/__\/__\

, : $w=2$ $s=0$

     /\     
    /  \    
   /____\   
  /\    /\  
 /  \  /  \ 
/____\/____\

, : $w=3$ $s=3$

          /\          
         /  \         
        /    \        
       /______\       



   /\            /\   
  /  \          /  \  
 /    \        /    \ 
/______\      /______\

, : $w=4$ $s=1$

          /\          
         /  \         
        /    \        
       /      \       
      /________\      

    /\          /\    
   /  \        /  \   
  /    \      /    \  
 /      \    /      \ 
/________\  /________\

नियम

प्रत्येक पंक्ति पर अनुगामी रिक्त स्थान वैकल्पिक हैं।
प्रत्येक पंक्ति पर अतिरिक्त अग्रणी स्थान की अनुमति नहीं है।
आप एक एकल अतिरिक्त अग्रणी नई लाइन और / या एक अतिरिक्त अतिरिक्त नई रूपरेखा का उत्पादन कर सकते हैं।
यह कोड-गोल्फ है ।

code-golf ascii-art

— Arnauld
स्रोत

10

पायथन 2 , 197 194 169 167 155 144 बाइट्स

w,s=input()
l=['']*(2*-~w+s)
for i in range(-~w):W=w-i;b='/'+'_ '[i<w]*2*i+'\\';l[i::w-~s]=' '*(w+s-~W)+b,' '*W+b+'  '*(W+s)+b
print'\n'.join(l)

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

बचाया:

-3 बाइट्स, मिस्टर एक्सकोडर की बदौलत

— TFeld
स्रोत

8

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

←×_Ｎ↗⊕θ‖Ｍ≔⁺⊕θＮηＣη±η‖ＢＯ⊗⊕θ

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

←×_Ｎ

इनपुट wऔर ड्रा w _एस।

↗⊕θ

ड्रॉ w+1 /s।

‖Ｍ

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

≔⁺⊕θＮη

इनपुट sऔर बाईं और मध्य त्रिकोण के बीच ऑफसेट गणना।

Ｃη±η

बाएं त्रिकोण को बीच में कॉपी करें।

‖ＢＯ⊗⊕θ

ट्रिफ़ोर्स को पूरा करने के लिए मध्य त्रिकोण के चारों ओर प्रतिबिंबित करें।

— नील
स्रोत

उह, इस पर अपना गणित जांचें। यह 25 वर्ण का हो सकता है , लेकिन यह 50 से 65 बाइट्स (यह निर्भर करता है कि आप क्रमशः UTF-16 या UTF-8 प्रतिनिधित्व का उपयोग करते हैं)।

— स्टुअर्ट पी। बेंटले

मेरी गलती; जाहिर है, चारकोल और कैनवस के अपने चरित्र मानचित्रण हैं , जो मुझे एक स्पर्श मूर्खतापूर्ण लगता है (यदि आप मनमाने प्रतीकों का उपयोग करने जा रहे हैं, तो मौजूदा चयन का उपयोग क्यों नहीं करें), लेकिन जो भी हो।

— स्टुअर्ट पी। बेंटले

@ StuartP.Bentley इस साइट का बिंदु गोल्फ प्रोग्राम आकार है। कई भाषाओं (वहाँ कई हैं, सिर्फ कैनवस और चारकोल की तुलना में कई अधिक) ने प्रति बाइट 8 बिट का उपयोग करने का विकल्प चुना, क्योंकि यह अधिकतम गोल्फ के करीब पहुंचने का एक बहुत अच्छा तरीका है। सुंदर यूनिकोड सिर्फ कोड को पढ़ने और लिखने में आसान बनाने के लिए है (आप सी में प्रोग्रामिंग की कोशिश करते हैं

— बायटेकोड

8

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

w,s=input()
n=2*-~w+s
while n:n-=1;I=w-n+(n>w)*(w-~s);print' '*n+('  '*(n+s)).join(['/'+I*2*' _'[I>=w]+'\\'][I>w:]*-~(n<=w))

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

— OVS
स्रोत

7

कैनवस , 20 19 16 बाइट्स

＋├：⁸╵＼Ｌ_×；∔║ω╋║↕

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

स्पष्टीकरण:

+├                s + w + 2
  :               duplicated (for both X & Y)
   ⁸╵\            w+1 sized diagonal
      L_×         "_"*width of the diagonal
         ;∔       prepended before the diagonal
           ║      palindromize that
            ω     and push the argument of ║ (aka the unpalindromized version)
             ╋    overlap the upside down half-triangle over the upside down triangle at (s+w+2; s+w+2)
              ║   and palindromize the whole thing
               ↕  reverse everything vertically

नोट: इसे बनाने में मैंने कोड में एक गलती तय की है, उस फिक्स के बिना, यह 18 बाइट्स होगा ।

— dzaima
स्रोत

नील के जवाब की तरह , यह 16 वर्ण हो सकता है , लेकिन यूनिकोड के संदर्भ में, यह 32 या 44 बाइट्स है, जिसके आधार पर आप यूटीएफ का उपयोग करते हैं। (मुझे लगा कि यह कोड पेज 437 की तरह एक विरासत सिंगल-बाइट कैरेक्टर में प्रतिनिधित्व करने योग्य हो सकता है , लेकिन वहां कोई ⁸ या ω उपलब्ध नहीं है, इसलिए ऐसा लगता है कि आपको एक यूनिकोड ट्रांसफॉर्मेशन फॉर्मेट के साथ जाना होगा।)

— Startart पी। बेंटले

@ StuartP.Bentley कैनवास एक कस्टम कोडपेज का उपयोग करता है, जैसा कि मेरी पोस्ट के शीर्षक में जुड़ा हुआ है। चारकोल के लिए गीथूब विकी में इसका कोडपेज भी है। PPCG पर यह सहमति है कि यदि एक कोडपेज / कन्वर्टर इसे बैकअप दे रहा है तो यूनिकोड स्वरूपित उत्तरों के साथ उत्तर देना ठीक है।

— दिज़िमा

Tcsh, ठीक है (हालाँकि इस बिंदु पर कि आप मनमाने रूप से कन्वर्टर्स का उपयोग कर रहे हैं, यह मुझे लगता है कि आप पूरी तरह से नाम के साथ एक भाषा में लिख सकते हैं और एक संकलित VM बाइटकोड निर्देश लंबाई को माप सकते हैं)।

— स्टुअर्ट पी। बेंटले

@ StuartP.Bentley चारकोल उत्तर लिंक की जाँच करें - इसमें मानव पठनीय कोड है! (हां हां, 2 परिवर्तन: पी) यहां लोग असेंबली स्कोरिंग का जवाब मशीन कोड के रूप में देते हैं, इसलिए वीएम में भी जवाब देने का कोई कारण नहीं है

— dzaima

7

आर , 225 , 224 , 214 , 211 , 208 बाइट्स

function(w,s){M=matrix
C=cbind
h=w+1
k=C(apply(m<-diag(h)*60,1,rev)/4,m)
k[row(k)==h&!k]=63
z=rbind(C(a<-M(0,h,h+s),k,a),M(0,s,h*4+2*s),C(k,M(0,h,2*s),k))
z[]=intToUtf8(z+32,T)
apply(z,1,cat,sep='','
')
rm()}

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

Giuseppe के लिए -1 बाइट धन्यवाद
-10 दृष्टिकोण परिवर्तन के बाद बाइट्स
-3 बाइट्स ASCII कोड का विस्फोट
-3 बाइट्स जेसीई के लिए धन्यवाद

— digEmAll
स्रोत

चूँकि मुझे इसे जोड़ने के लिए कुछ भी नहीं मिला ... मैंने बस नाम बदला चर और मैं भी चुपचाप लौटने के लिए एक और अवसर का सुझाव दे रहा हूं ... जिसे मैं टीबीएच से पूरी तरह से संतुष्ट नहीं हूं। खोजते रह जाओगे! TIO

— JayCe

ओह रुको ... if(F)0सुनिश्चित करने के लिए स्वीकार्य है और एक बाइट बचाता है। या rm()3 बाइट्स के लिए भी बेहतर है ।

— JayCe

q()मेरी पहली टिप्पणी में उपयोग करने का मेरा सुझाव इस मेटा के

— JayCe

@JayCe: rm () का उपयोग करके शानदार ट्रिक!

— DigEmAll

4

पास्कल (एफपीसी) , 296 264 बाइट्स

const A='/';B='\';var w,s,i:word;u:string;begin read(w,s);u:=StringOfChar('_',2*w);for i:=1to w do writeln(A:w+3+s+w-i,B:i*2-1);writeln(A:w+2+s,u,B);for i:=1to s do writeln;for i:=1to w do writeln(A:w+2-i,B:i*2-1,A:2*(s+w-i)+3,B:i*2-1);write(A,u,B,A:2*s+1,u,B)end.

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

— AlexRacer
स्रोत

4

पायथन 2 , 256 248 240 228 199 195 बाइट्स

एक लंबा कार्यक्रम, लेकिन थोड़ा अलग दृष्टिकोण:

f,b,o='/\ '
O=o*2
w,s=input()
l=f+'__'*w+b
a=l+O*s+l
m=n=[]
p=lambda g:(len(a)-len(g))/2*o+g
for i in range(w):m=m+[p(f+O*i+b)];t=f+O*i+b;n+=p(t+O*(w-i+s)+t),
print'\n'.join(m+[p(l)]+[o]*s+n+[a])

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

अनुगामी व्हॉट्सएप को नजरअंदाज करने के लिए बहुत से बाइट्स को बचाया, और @ovs से कुछ ट्रिक को शामिल
करके पहले एक चर को परिभाषित करके और भी अधिक बचत की।

— micsthepick
स्रोत

मुझे इसे कल ठीक करना होगा (यह काम करता है, लेकिन मैं और बेहतर कर सकता हूं)

— micsthepick

218 बाइट्स ।

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

216 बाइट्स

— ओवी

बाइट गिनती तय की।

— mbomb007

जब दो

— micsthepick 8

3

रूबी , 126 बाइट्स

->w,s{(-v=w+1).upto(v){|i|j= ~-i%-~v;$><<[$/*s,$/+' '*(v+s)+t="/#{(j<w ?' ':?_)*j*2}\\".center(w*2+2)+' '*s*2,$/+t*2][0<=>i]}}

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

— स्तर नदी सेंट
स्रोत

2

रेटिना 0.8.2 , 141 बाइट्स

\d+
$* 
(?=( *),( *))
¶$1/$`$`\$1$2$2$1/$`$`\
T` `\_`/ *\\(?=.*,)
s`¶(.*),( *)
$1¶$.2$*¶$1
\G(( *)/(  |__)*\\)\2(  )*\1 *¶
$2 $#3$* $#4$* $1¶

इसे ऑनलाइन आज़माएं! नोट: आउटपुट में कुछ अनुगामी व्हाट्सएप। स्पष्टीकरण:

\d+
$*

आदानों को रिक्त स्थान में परिवर्तित करें। (दूसरी पंक्ति एक स्थान के साथ समाप्त होती है।)

(?=( *),( *))
¶$1/$`$`\$1$2$2$1/$`$`\

उपयुक्त रिक्ति के साथ नीचे के दो त्रिभुज बनाएं।

T` `\_`/ *\\(?=.*,)

त्रिकोण के आधार में भरें।

s`¶(.*),( *)
$1¶$.2$*¶$1

उचित ऊर्ध्वाधर रिक्ति के साथ त्रिकोणों को दोहराएं।

\G(( *)/(  |__)*\\)\2(  )*\1 *¶
$2 $#3$* $#4$* $1¶

ऊपरी त्रिकोणों को एकल केन्द्रित त्रिकोण में परिवर्तित करें।

— नील
स्रोत

2

सी (जीसीसी), 404 389 बाइट्स

#define p(x)putchar(x);
#define F for
W;S;i;a=32;b=47;c=92;f(w,s){W=w,S=s;F(;w;--w){F(i=W+w+s+1;i--;)p(a)p(b)F(i=w*2;i++-2*W;)p(a)p(c)p(10)}F(i=W+s+1;i--;)p(a)p(b)F(i=0;i++-2*W;)p(95)p(c)F(;s--+1;)p(10)F(w=W;w;--w){F(i=w;i--;)p(a)p(b)F(i=w*2;i++-2*W;)p(a)p(c)F(i=w*2+S*2;i--;)p(a)p(b)F(i=w*2;i++-2*W;)p(a)p(c)p(10)}p(b)F(i=0;i++-2*W;)p(95)p(c)F(i=S*2;i--;)p(a)p(b)F(i=0;i++-2*W;)p(95)p(c)}

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

रोडोलवर्टिस से -14 बाइट्स

-1 लूप वैरिएबल डिक्रिप्शन को फिक्स करके

_{404 को पार कर जाना अभी भी लगभग 404 है}

Ungolfed:

#define p(x)putchar(x); // save 7 bytes per putchar call (+24, -182)
#define F for // save 2 bytes per for loop (+14, -28)
int W, S, i; // W is w backup, S is s backup, i is an counter variable;
int a = ' '; // save 1 byte per space printed (+5, -8) (use a instead of 32)
int b = '/'; // save 1 byte per slash printed (+5, -6) (use b instead of 47)
int c = '\\'; // save 1 byte per backslash printed (+5, -6) (use c instead of 92)
// This isn't worth it for '\n' (-5, +3) (10), or '_' (-5, +3) (95)
int f(int w, int s) {
    W = w; // Backup w and s, as we will modify them later, 
    S = s; // but will need their original values
    for(; w != 0; --w) { // Top triangle (not the bottom line)
        for(i = W+w+s+1; i != 0; --i) // leading spaces
            putchar(' ');
        putchar('/'); // left side of triangle
        for(i = 2*w; i != 2*W; ++i) // inner spaces
            putchar(' ');
        putchar('\\'); // right side of triangle
        putchar('\n'); // newline
    }
    for(i = W+s+1; i != 0; --i)
        putchar(' '); // leading spaces for the bottom line
    putchar('/'); // left side
    for(i = 0; i != 2*W; ++i)
        putchar('_'); // the bottom line
    putchar('\\'); // right side
    for(; s-- + 1 != 0;)
        putchar('\n'); // newline after the bottom line and S empty lines
    for(w = W; w != 0; --w) { // Bottom triangles
        for(i = w; i != 0; --i)
            putchar(' '); // leading spaces
        putchar('/'); // left of left triangle
        for(i = w*2; i != 2*W; ++i)
            putchar(' '); // inside of left triangle
        putchar('\\'); // right of left triangle
        for(i = w*2+S*2; i != 0; --i)
            putchar(' '); // spaces between left and right triangles
        putchar('/');
        for(i = w*2; i != 2*W; ++i)
            putchar(' '); // inside of right triangle
        putchar('\\'); // right of right triangle
        putchar('\n'); // newline
    }
    putchar('//'); // left of left
    for(i = 0; i != 2*W; ++i)
        putchar('_'); // bottom of left triangle
    putchar('\\'); // right of left
    for(i = S*2; i != 0; --i)
        putchar(' '); // space between triangles
    putchar('/'); // left of right
    for(i = 0; i != 2*W; ++i)
        putchar('_'); // bottom of left triangle
    putchar('\\'); // right of right
}

— pizzapants184
स्रोत

1

#define f कुछ बाइट्स बचाती है

— रॉडोल्फिटो

क्या आप नहीं कर सकते #define p putchar?

— आर.के.

1

@RK। अगर मैंने किया, तो मुझे (5:01, -6) = +20 बाइट्स के p(x);बजाय उपयोग करना होगा p(x)। मैक्रो का विस्तार होने पर अर्धविराम को शामिल किया जाता है।

— pizzapants184

284 बाइट्स

— छत

1

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

+‘⁶ẋ;Ɱ®Y
‘⁼þ`a”/o"”_o⁶Ṛ;ṚØ^yƊ$€©ż`j€Ḥ⁶ẋƊ}Y,@çj‘⁷ẋƊ}

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

— आउटग्रॉफर को एरिक करें
स्रोत

चलो ट्राइफर्स को आकर्षित करते हैं

इनपुट

उत्पादन

और ज्यादा उदाहरण

नियम

पायथन 2 , 197 194 169 167 155 144 बाइट्स

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

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

कैनवस , 20 19 16 बाइट्स

आर , 225 , 224 , 214 , 211 , 208 बाइट्स

पास्कल (एफपीसी) , 296 264 बाइट्स

पायथन 2 , 256 248 240 228 199 195 बाइट्स

रूबी , 126 बाइट्स

रेटिना 0.8.2 , 141 बाइट्स

सी (जीसीसी), 404 389 बाइट्स

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