एक ज्यामितीय चुनौती

Question

हर कोई ज्यामिति से प्यार करता है। तो क्यों हम कोशिश करते हैं और यह गोल्फ कोड नहीं है? इस चुनौती में अक्षरों और संख्याओं को लेना और उसके आधार पर आकार बनाना शामिल है।

इनपुट

इनपुट के रूप में होगा (shapeIdentifier)(size)(inverter)।

लेकिन आकृतिकारक, आकार, और इन्वर्टर क्या हैं?

आकार पहचानकर्ता आपके द्वारा बनाए जा रहे आकार के प्रकार के लिए पहचानकर्ता है *। निम्नलिखित आकृति पहचानकर्ता हैं:

• s - वर्ग
• t - त्रिभुज

आकार के बीच होगा 1-20, और यह आकृति का आकार है।

इन्वर्टर आकार उल्टा होगा या नहीं, यह एक +या एक द्वारा दर्शाया जाता है -। ध्यान दें: s3-== (बराबर) s3+क्योंकि वर्ग सममित हैं। हालाँकि; t5-=! (बराबर नहीं है) t5+।

ट्रेलिंग व्हाट्सएप आउटपुट में ठीक है लेकिन प्रमुख व्हाट्सएप नहीं है।

आउटपुट उदाहरण

Input: s3+
Output:
***
***
***

Input: t5+

Output:
  *
 ***
*****

Input: t3-
Output:
***
 *

विशेष टिप्पणीया

त्रिकोण इनपुट हमेशा एक विषम संख्या होगी, इसलिए त्रिकोण हमेशा *शीर्ष पर 1 के साथ समाप्त होंगे ।

यदि इन्वर्टर है तो त्रिकोण का आकार आधार +का आकार है और यदि इन्वर्टर है तो शीर्ष का आकार है -।

Comments

जैसा कि कोई व्यक्ति जो ज्यामिति को अभी ले रहा है, (और एक ज्यामिति फाइनल के लिए अध्ययन कर रहा है), मैं 100% निश्चितता के साथ कह सकता हूं: ज्यामिति बिल्कुल, मज़ेदार नहीं है ... D:

— अश्विन गुप्ता

Answer 1

पायथ, 40 36 34 32 बाइट्स

-1 बाईट @ लिसाकग द्वारा

JstPz_W}\+zjl#m.[J*\*-J*}\tzyd;J

एक लैम्ब्डा के अंदर एक अर्धविराम अब लैम्ब्डा वेरिएबल का वैश्विक मूल्य है, एक विशेषता जो एक बाइट बचाता है।

                         Implicit: z = input
JstPz                    J = size.
_W }\+z                  Reverse if "+" in z
j l# m                J  Join the nonempty lines in map lambda d:... over range(J)
      .[J            ;   Pad the following with spaces (;) to length J
         *\*               "*", this many times:
            -J*}\tzyd        J if "t" not  in z,
                             otherwise the correct number for a triangle.

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

टेस्ट सूट ।

Comments

रास्ता बहुत लंबा है, फिर भी 15 बाइट्स से जाप मार रहा है? मैं यह देखने के लिए इंतजार नहीं कर सकता कि यह कैसे होगा। :)

— ETHproductions

अच्छा समाधान! आप को बदल कर एक बाइट बचा सकता है qez\+के साथ }\+zहै, क्योंकि +कर सकते हैं केवल अंतिम स्थिति में दिखाई देते हैं।

— ईसैक

Answer 2

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

JsPtzj?}\szm*\*JJ_W}\-zm.[J*\*hyd;/hJ2

परीक्षण सूट

मूल रूप से जितना सीधा मिलता है। काश मैं दो आकृतियों के लिए कुछ तर्क मिला सकता, लेकिन वर्तमान में यह अलग है।

Answer 3

जावास्क्रिप्ट (ईएस 6), 142 146 147

संपादित 1 बाइट बचाया thx @ETHproductions संपादित करें 2 बाइट्स sve thx @ user81655

i=>([,a,b]=i.match`.(.+)(.)`,Array(l=i<'t'?+a:-~a/2).fill('*'.repeat(a)).map((r,i)=>l-a?(' '.repeat(i=b<'-'?--l:i)+r).slice(0,a-i):r).join`
`)

परीक्षण (फ़ायरफ़ॉक्स में चलाएं)

F=i=>(
  [,a,b]=i.match`.(.+)(.)`,
  Array(l=i<'t'?+a:-~a/2).fill('*'.repeat(a))
  .map((r,i)=>l-a?(' '.repeat(i=b<'-'?--l:i)+r).slice(0,a-i):r)
  .join`\n`
)

function test() { O.textContent=F(I.value) }

test()

Input: <input id=I oninput="test()" value="t11-"/>
<pre id=O></pre>

Comments

\d-> ., क्योंकि वहाँ से पहले और बाद में बिल्कुल एक गैर-अंक होने की गारंटी है

— ETHproductions

@ETHproductions सही है, धन्यवाद

— edc65

अच्छा लगा। मुझे लगता है कि यह जेएस में इष्टतम एल्गोरिथ्म है, एक छोटा नहीं मिल सकता है।

— ETHproductions 1

i.match(/.(.+)(.)/)->i.match`.(.+)(.)`

— user81655

@ user81655 अच्छा संकेत, धन्यवाद

— edc65

Answer 4

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

s=raw_input()
n=int(s[1:-1])
for i in[range(1,n+1,2),n*[n]][s<'t'][::2*('+'in s)-1]:print('*'*i).center(n)

आउटपुट एक सही आयत है, जिसमें प्रत्येक पंक्ति अनुगामी स्थानों के साथ गद्देदार होती है, जिसे मैं ओपी में टिप्पणियों के आधार पर मान रहा हूं।

नोट: मुझे अभी भी यकीन नहीं है कि inputइन जैसी समस्याओं के लिए अजगर 2 में अनुमति दी गई है ...

Answer 5

जाप, 62 60 55 52 51 बाइट्स

V=Us1 n;U<'t?Vo ç*pV):0oV2 £S²pY iY'*pV-X})·z2*!Uf-

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

सबसे पहले हमें यह पता लगाना होगा कि हमारी आकृति कितनी बड़ी होनी चाहिए। यह बहुत आसान है:

      // Implicit: U = input string, S = space
V=    // Set variable V to
Us1   // everything after the first char of U,
n;    // converted to a number. This turns e.g. "12+" into 12.

अब हम आउटपुट का आकार व्यवस्थित करते हैं:

U<'t?      // If U comes before "t" lexicographically (here, if the first char is "s"),
Vo         //  make a list of V items,
ç*pV)      //  and set each item to V asterisks.
:0oV2      // Otherwise, create the range [0, V) with steps of 2 (e.g. 7 -> [0,2,4,6]),
£       }) //  and map each item X and index Y to:
S²pY       //   Repeat 2 spaces Y times. This creates a string of Y*2 spaces.
iY'*pV-X   //   At position Y in this string (right in the middle), insert V-X asterisks.
·          // Join with newlines.

अब तक, हमने आउटपुट के आकार और आकार का ध्यान रखा है। यह सब छोड़ दिया रोटेशन है। त्रिकोण वर्तमान में इंगित किए जाते हैं, इसलिए हमें तीसरा चर है तो उन्हें फ्लिप करना होगा +:

!Uf-    // Take the logical not of U.match("-").
        // If U contains "-", this returns false; otherwise, returns true.
2*      // Multiply by two. This converts true to 2, false to 0.
z       // Rotate the list 90° that many times.
        // Altogether, this turns the shape by 180° if necessary.

और निहित आउटपुट के साथ, यहां हमारा काम किया जाता है। :-)

Answer 6

पायथन 2, 235 193 167 157 बाइट्स

अद्यतन करें:

सूची समझ और str.center () का उपयोग करके कुछ महत्वपूर्ण अनुकूलन किया। मुझे लग रहा है कि मैं कुछ और चीजें कर सकता हूं, बाद में इस पर नए सिरे से विचार करूंगा।

अपडेट २

शर्लक 9 के सुझावों के साथ 10 बाइट्स बचाए। आपका बहुत बहुत धन्यवाद! :)

d=raw_input()
x=int(d[1:-1])
o="\n".join("*"*x for i in range(x))if d<"t"else"\n".join(("*"*i).center(x)for i in range(x,0,-2))
print o[::-1]if"+"in d else o

पुराना उत्तर

d=raw_input()
x=int(d[1:-1])
if "s" in d:
 for y in range(x):
    o+="*"*x+"\n"
 o=o[:-1]
else:
 b=0
 while x+1:
    o+=" "*b+"*"*x+" "*b+"\n"
    x-=2
    b+=1
 o=o[:-1]
 if d[-1]=="+":
    o=o[::-1]
print o

बहुत सुंदर दृष्टिकोण। एक स्ट्रिंग में पंक्ति प्रति पंक्ति लिखना जो मैं अंत में आउटपुट करता हूं। त्रिकोण हमेशा उलटे होते हैं और ज़रूरत पड़ने पर पलट जाते हैं। तथ्य यह है कि आप एक पूर्णांक के साथ एक स्ट्रिंग गुणा कर सकते हैं मुझे बहुत बाइट्स बचाए!

मैं थोड़ा और बाद में गोल्फ करने की कोशिश करूंगा, इस बीच में सुझावों की सराहना करूंगा, क्योंकि मैं अभी तक इसके साथ ज्यादा एक्सपायरी नहीं हूं।

संपादित करें: टिप्पणियों में मदद और अन्य अजगर-उत्तरों में से एक से आकार-गणना को चुराकर इसे बहुत नीचे दबा दिया। मुझे लगता है कि मैं सबसे अधिक इस एल्गोरिथ्म के साथ कर सकता है।

Comments

कैसे गिना? जब wcयह प्रयोग मुझे 235 की बाइट गिनती देता है। क्या मैं गलत हूं?

— ।

यह वास्तव में 235 बाइट्स है। गोल्फ सलाह: दो स्थानों के बजाय टैब का उपयोग करें, जो कि पायथन 2 में मान्य है और 5 बाइट से दाढ़ी बनाएगा।

— दरवाज़े

इसके अलावा, आपको उपयोग करने की आवश्यकता नहीं है raw_input, inputआपको 4 बाइट्स बचाता है। इसके अलावा, आपको दूसरी पंक्ति में कोष्ठक की आवश्यकता नहीं है, यह और चर का उपयोग नहीं करना x(उपयोग करना if"s"in d) आपको एक और 9 बाइट्स बचाता है।

— ।

@DenkerAffe जब विंडो में गिना जाता है, तो प्रत्येक न्यूलाइन के लिए 1 बाइट घटाएं - विंडोज़ में नई बाइट्स 2 बाइट्स हैं, लेकिन अन्य वातावरणों में 1 बाइट

— edc65

सबसे पहले, आप []प्रत्येक joinफ़ंक्शन कॉल में कोष्ठक हटा सकते हैं। दूसरा, if d<"t"elseछोटा है और "s3+"<"t"<"t3+"अजगर के कारण काम करता है । तीसरा, else"\n".joinऔर .center(x)for। कोई जगह नहीं। इसकी आवश्यकता नहीं है। चौथा, print o[::-1]if"+"in d else oजहाँ मैं (दो बाइट के लिए चीजों को पुन: व्यवस्थित के बीच एक अंतरिक्ष ]और ifऔर एक अन्य के बीच ifऔर "+"।

— Sherlock9

Answer 7

जावास्क्रिप्ट, 220 बाइट्स।

q=s=>+s.slice(1,s.length-1);f=s=>s[0]=="s"?("*".repeat(q(s))+"\n").repeat(q(s)):Array.apply(0,Array(-~(q(s)/2))).map((_,n)=>(s[s.length-1]=="-"?~~(q(s)/2)-n:n)).map(n=>(" ".repeat(q(s)/2-n)+"*".repeat(n*2+1))).join("\n")

साथ दौड़ो f(input here)

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

वर्गों में नई अनुगामी हैं, लेकिन त्रिकोण नहीं हैं। स्पष्टीकरण:

q=s=>+s.slice(1,s.length-1);                                                                                                                                                                                                 Define a function, q, that takes returns the argument, without the first and last character, casted into an integer.
                            f=s=>                                                                                                                                                                                            Define a function, f, that takes one argument, s. (This is the main function)
                                 s[0]=="s"?                                                                                                                                                                                  If the first character of s is "s" then...
                                           ("*".repeat(q(s))     )                                                                                                                                                           Repeat the "*" character q(s) times.
                                           (                +"\n")                                                                                                                                                           Append a newline to that
                                                                  .repeat(q(s))                                                                                                                                              Repeat that q(s) times.
                                                                               :                                                                                                                                             Else... (the first character of s isn't "s")
                                                                                Array.apply(0,Array(          ))                                                                                                             Create an array of length...
                                                                                Array.apply(0,Array(-~(q(s)/2)))                                                                                                             floor(q(s)/2)+1
                                                                                                                .map((_,n)=>                                   )                                                             Map each element, _ with index n to...
                                                                                                                .map((_,n)=>(s[s.length-1]=="-"?              ))                                                             If the last element of s is "-" then...
                                                                                                                .map((_,n)=>(s[s.length-1]=="-"?~~(q(s)/2)-n  ))                                                             floor(q(s)/2)-n
                                                                                                                .map((_,n)=>(s[s.length-1]=="-"?            : ))                                                             Else...
                                                                                                                .map((_,n)=>(s[s.length-1]=="-"?             n))                                                             Just n
                                                                                                                                                                .map(n=>                                        )            Map each element into...
                                                                                                                                                                .map(n=>(" ".repeat(q(s)/2-n)                   )            Repeat " ", q(s)/2-n times.
                                                                                                                                                                .map(n=>(                   )+"*".repeat(n*2+1)))            Append "*", repeated 2n+1 times.
                                                                                                                                                                .map(n=>(" ".repeat(        )+"*".repeat(n*2+1))).join("\n") Join with newlines

Comments

आपकी पहली पंक्ति की लंबाई 338 अक्षर है। यह प्रदर्शन के लिए मुझे एक मॉनिटर और एक आधा ले जाता है।

— isanae

@isanae यह यहां 220 कहता है।

— लोजोवो

मैं एक यादृच्छिक टिनील लिंक पर क्लिक नहीं करूँगा, लेकिन फिर से जाँच करूँगा। किसी भी स्थिति में, कोड बॉक्स में स्क्रॉल बार से बचने की कोशिश करें, इससे पढ़ने में बहुत मुश्किल होती है।

— isanae

@Lovjo मुझे लगता है कि वह स्पष्टीकरण की पहली पंक्ति का मतलब है। मैं आमतौर पर जावास्क्रिप्ट के जवाब के लिए इस शैली के बजाय मेरी व्याख्या पर जोर देता हूं ताकि आपको इसका आधा हिस्सा देखने के लिए स्क्रॉल करने की आवश्यकता न हो।

— user81655

@ user81655 हां, मेरा मतलब स्पष्टीकरण में है। अब मैं भ्रम को समझ गया!

— इसनाए

Answer 8

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

def f(s):
 S=int(s[1:-1])
 for n in([range(1,S+2,2),range(S,0,-2)]['-'in s],[S]*S)['s'in s]:
  print "{:^{S}}".format('*'*n,S=S)

पहले प्रयास ने दृढ़ किया कि +/-अंत में वैकल्पिक था, इससे छुटकारा पाकर मुझे एक झुंड से दागा गया

यहां विचार एक सूची बनाने का है जो एक सामान्य आउटपुट में डाली जा सकती है। सबसे कठिन हिस्सा इनपुट से लंबाई को अलग कर रहा था।

Comments

लंबाई पाने के लिए मैंने x=int(d[1]if len(d)<4 else d[1:3])इनपुट स्ट्रिंग d होने के साथ उपयोग किया । Thats 5 बाइट्स आपके समाधान से कम है। आप अभी भी मेरे अजगर-उत्तर के आगे हैं, मुझे समझ नहीं आया कि आपने वहां क्या किया और अगली बार आपको हरा दिया! :)

— डेनकर

वास्तव x=int(d[1:-1])में इसके लिए बहुत कम है, बस इसे अन्य अजगर जवाब में देखा।

— डेनकर

@DenkerAffe, जो भी कारण से मुझे इन्वर्टर के वैकल्पिक होने की याद है, तो वह काम नहीं करेगा, लेकिन मुझे लगता है कि मैंने अभी-अभी बनाया है

— wnnmaw

Answer 9

रेटिना , 102 85 बाइट्स

बाइट काउंट मानता है कि स्रोत कोड आईएसओ 8859-1 के रूप में एन्कोडेड है।

\d+
$0$*:¶
^((\w)+):(:+)
$1$2$3$2¶$0
m`s$|:t

)`(.+)¶-(\D*)
-$2¶$1
m`^.

G`.
T`ts:` *

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

मैं इसे कुछ और बाद में गोल्फ करने की कोशिश करूँगा।

Comments

नोटपैड ++ का कहना है कि आपका कोड 89 बाइट्स है, 85 नहीं। मैंने ISO-8859-1 एन्कोडिंग का उपयोग किया है, और \nइसके स्थान पर उपयोग करने के लिए Edit> EOL Convertion> UNIX / Linux फॉर्मेट का उपयोग किया है \r\n। सामग्री का बेस 64: XGQrCiQwJCo6wrYKXigoXHcpKyk6KDorKQokMSQyJDMkMsK2JDAKbWBzJHw6dAoKKWAoLispwrYtKFxEKikKLSQywrYkMQptYF4uCgpHYC4KVGB0czpgICo=(नोटपैड ++ से सीधी प्रतिलिपि)। अजीब तरह से, कोई भी ऑनलाइन समाधान मुझे 85 बाइट्स देता है ... हम ...

— इस्माइल मिगुएल

@IsmaelMiguel नोटपैड ++ की गणना कैसे की जाती है, इस बारे में कुछ बताया जाना चाहिए ¶। वे निश्चित रूप से आईएसओ 8859-1 (मूल्य 182 के साथ) में एक एकल बाइट हैं।

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

Answer 10

गंभीरता से, 54 बाइट्स

,#i's=`≈;'**@½≈";#dXdXεj' +"£n`@`≈;'**n`@Iƒ('-=WXa0WXü

यह ऑनलाइन की कोशिश करो

,#i                                                    Take input, push chars separately
   's=                                   Iƒ            IF the first char is "s":
                                `      `@                run the quoted function
                                 ≈;'**n                  make list of n strings of n *'s
      `                       `@                       ELSE run the quoted function:
       ≈;                                                make two copies of int n
         '**                                             use one to make string of n *'s
            @½≈                                          cut the other in half (e.g. 5->2)
               "           "£n                           run n/2 times the quoted function:
                ;#                                        copy the string as list of chars
                  dXdX                                    discard the last 2 *'s
                      εj                                  join back into string
                        ' +                               prepend a space
                                           ('-=WX 0WX  IF the third character is "-":
                                                 a       invert the stack
                                                     ü pop and print the entire stack

@Mego: देखते हैं #dXdXεj? STRING SLICING ????

Answer 11

ईएस 6, 178 172 159 बाइट्स

s=>(p=s.match(/d+|./g),u=n=+p[1],m=n+1>>1,t=' '.repeat(n)+'*'.repeat(n),v=s<'t'?0:p[2]<'-'?(u=m,1):-1,[...Array(s<'t'?n:m)].map(_=>t.substr(u,u,u+=v)).join`
`)

मेरे द्वारा किए गए एक दिलचस्प अवलोकन के कारण यह काम करता है। यदि आप nरिक्त स्थान और nतारांकन दोहराते हैं जो आपको मिलता है (उदाहरण के लिए n=5):

     *****

अब, एक ही शुरुआत और लंबाई के साथ सबस्ट्रिंग लें:

     |*****| (5)
    | ***| (4)
   |  *| (3)

ये सबस्ट्रिंग्स ठीक वही स्ट्रिंग्स हैं जिनकी हमें ज़रूरत है t5।

संपादित करें: @ edc65 के लिए 6 बाइट्स सहेजे गए।

संपादित करें: सहेजे गए 13 बाइट्स u+=vको तीसरे तर्क में छिपाने के लिए धन्यवाद , substrइस प्रकार मुझे प्रारंभिककरण को आसान बनाने की अनुमति मिलती है।

Comments

@ThomasKwa हुह, मैं tहैंडलिंग कोड तय करने के बाद यह निकला wऔर uसमतुल्य हो गया और उसने मुझे वापस 178 पर ले जाने के लिए पर्याप्त बाइट्स बचाए!

— नील

[,b,c]=s.matchऔर बाद में s<'t'... कुछ बाइट्स (फ़ायरफ़ॉक्स केवल)

— edc65

@ edc65 sमुझे मैच बचाने की अनुमति नहीं है s<'t'जो मुझे 6 बाइट बचाने के लिए उपयोग करने की अनुमति देता है , धन्यवाद।

— नील

Answer 12

MATL , 48 बाइट्स

' *'jt4Y2m)U1$l't'Gm?2MQ2/:1L3$)R!P!R'+'Gm?P]]Q)

वर्तमान संस्करण का उपयोग करता है (10.1.0)भाषा / संकलक के का ।

कोड किसी भी क्रम में इनपुट वर्णों को स्वीकार करता है: सभी s11+, 11s+और यहां तक 1+s1कि मान्य इनपुट स्ट्रिंग्स भी होंगे।

संपादित करें (30 जुलाई 2016): लिंक किए गए कोड की जगह 1L3$)द्वारा Y)भाषा में हाल के परिवर्तनों के अनुरूप

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

व्याख्या

' *'        % push string. Will be indexed into to obtain final result
j           % input string
t           % duplicate
4Y2         % predefined literal string '0123456789'
m           % logical index of digits in input string
)           % index into input string to obtain substring with digits
U           % convert to number
1$l         % generate square of ones with that size
't'         % push character 't'
G           % push input string
m           % true if input string contains 't'
?           % if so...
  2M        % push argument of call to function `l`, i.e. square size
  Q2/       % add 1 and divide by 2. Call result T
  :         % generate vector [1, 2, ... T]
  1L        % predefined literal representing Matlab's `:` index
  3$)       % two dimensional index. Transforms square into rectangle
  R         % remove (set to zero) lower-left corner
  !P!       % flip horizontally
  R         % remove lower-left corner. This gives inverted triangle
  '+'       % push character '+'
  G         % push input
  m         % true if input contains '+'
  ?         % if so...
    P       % flip vertically
  ]         % end if
]           % end if
Q           % add 1. This gives array of values 1 and 2
)           % index string ' *' with this array to produce char array
            % implicitly display that char array

Answer 13

सी, 259 बाइट्स

#define x(y);)putchar(y)
#define m(n)for(n=0;n++<
#define T {m(q)i x(32);m(q)s-i*2 x(42);puts("");}
main(q,v,i,s)char**v;{s=atoi(v[1]+1);if(*v[1]=='s')m(i)s*s x(42)&&!(i%s)&&puts("");else if(strchr(v[1],'+'))for(i=s/2+1;i-->0;)T else for(i=-1;i++<s/2+1;)T}

ungolfed

main(q,v,i,size)char**v; // neat way of declaring variables
{
    size=atoi(v[1]+1);
    if(*v[1]=='s')
    {
        for(i=0;i++<size*size;)
        {
            putchar(42); // returns 42 (true)
            if(!(i%size))
                puts("");
        }
    }
    else if(strchr(v[1],'+')) // if finds plus sign
    {
        for(i=size/2+1;i-->0;) // iterate the height of the triangle
        {
            for(q=0;q++<i;)putchar(32); // conveniently i is the number os spaces before each line
            for(q=0;q++<size-i*2;) putchar(42);
            puts("");
        }
    }
    else for(i=-1;i++<size/2+1;) // does the same as above but inverted order
    {
        for(q=0;q++<i;)putchar(32);
        for(q=0;q++<size-i*2;)putchar(42);
        puts("");
    }
}

सुझावों और आलोचनाओं का बहुत स्वागत है।

Answer 14

रूबी, ९९

->s{n=s[1,2].to_i
n.times{|i|d=(s.ord-115)*(s[-1]<=>?,)*(n-1-i*2)
d<1&&puts((?**(n+d)).center(n))}}

पक्षों की ढलान को बहुत कम करके एक वर्ग या ऊंचाई nऔर औसत चौड़ाई के n त्रिकोण की गणना करता है (इसलिए गणना की गई त्रिकोण चौड़ाई आधार पर 2n-1 है, टिप पर।) लेकिन यह केवल उन पंक्तियों को प्रिंट करता है जो nवर्णों से अधिक नहीं हैं ।

परीक्षण कार्यक्रम में अपुष्ट

f=->s{                         #take a string as an argument
  n=s[1,2].to_i                #take 2 characters starting at index 1 and convert to a number for the size
  n.times{|i|                  #iterate through n rows    
    d=                         #calculate how many stars "MORE THAN" n we need on a row
    (s.ord-115)*               #ascii code for 1st character of string - 115 : s-->0, t-->1
    (s[-1]<=>?,)*              #compare last character of input with comma character - --> +1 + --> -1
    (n-1-i*2)                  #row number * 2: 0 at centre, positive above it, negative below it
    d<1&&                      #only output if d is nonpositive (i.e we need less than n or exactly n stars)
    puts((?**(n+d)).center(n)) #print n+d stars, centred in a field of n characters padded by whitespace
  }
}

f[gets.chomp]

Answer 15

जोल्फ, 37 बाइट्स, नॉन-कम्यूटिंग

मैंने इस चुनौती को पोस्ट किए जाने के बाद कार्यों को जोड़ा, इसलिए इसे स्वीकार करने के लिए विचार नहीं किया जा सकता है। यह ISO-8859-7 में एन्कोडेड है। यहां सभी परीक्षण मामलों की कोशिश करें ।

onFiΒ€ioSgiγ?='sn―sΒ'*―TΒ1'*?='-SZiγγ

भाग 1: स्ट्रिंग को पार्स करना

onFiΒ€ioSgi
on          set n to
  Fi         the first entity of i (the shape identifier)
    Β       set Β (beta) to
     €i      the "inside" of i (in this case, the size) as a number
       oS   set S to
         gi  the last entity of i (the inverter)

भाग 2: परिणाम प्राप्त करना

γ?='sn―sΒ'*―TΒ1'*
γ                 set γ (gamma) to the result of the following expression
 ?='sn             if n is the character s,
      ―sΒ'*         then return a pattern "s" (a square) made with "*"s
           ―TΒ1'*    otherwise, return a pattern "T" (triangle) that is centered and
                     has a scale factor of 1, made with "*"s

भाग 3: परिणाम प्राप्त करना

?='-SZiγγ
?='-S     if S is a "-"
     Ziγ   return γ, inverted across its lines
        γ  otherwise, return γ untouched