একটি জ্যামিতিক চ্যালেঞ্জ

Question

প্রত্যেকে জ্যামিতি পছন্দ করে। তাহলে আমরা কেন চেষ্টা করব না এবং এটি গল্ফ কোড করব? এই চ্যালেঞ্জের মধ্যে চিঠি এবং সংখ্যা নেওয়া এবং এর উপর নির্ভর করে আকার তৈরি করা জড়িত।

ইনপুট

ইনপুটটি আকারে হবে (shapeIdentifier)(size)(inverter)।

তবে আকৃতিপরিচয়কারী, আকার এবং বৈদ্যুতিন সংকেতের মেরু বদল কী কী?

আকৃতি শনাক্তকারী হ'ল ধরণের ধরণের জন্য আপনি *শব্দের সাথে কী আকার তৈরি করবেন তা সনাক্তকারী । নীচে আকৃতি শনাক্তকারী:

• s - স্কয়ার
• t - ত্রিভুজ

আকারটি এর মধ্যে হবে 1-20এবং এটি চিত্রের আকার।

বৈদ্যুতিন সংকেতের মেরু বদল আকারটি উল্টো হবে কিনা, যা একটি +বা একটি দ্বারা চিহ্নিত করা হয় -। নোট করুন: s3-== (সমান) s3+কারণ স্কোয়ারগুলি প্রতিসম হয়। তবে t5-,! = (সমান নয়) t5+।

আউটপুটে শ্বেত স্পেস অনুসরণ করা ঠিক আছে তবে শীর্ষস্থানীয় সাদা জায়গা নেই।

আউটপুট উদাহরণ

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

Input: t5+

Output:
  *
 ***
*****

Input: t3-
Output:
***
 *

বিশেষ নোট

ত্রিভুজ ইনপুট সর্বদা একটি বিজোড় সংখ্যা হবে, তাই ত্রিভুজটি সর্বদা *শীর্ষে 1 দিয়ে শেষ হবে ।

ইনভার্টারটি যদি ত্রিভুজটির আকার হয় তবে বেসটির +আকার এবং ইনভার্টারটি যদি শীর্ষের আকার হয় -।

Comments

যে কেউ এই মুহূর্তে জ্যামিতি নিচ্ছেন, (এবং জ্যামিতির ফাইনালের জন্য অধ্যয়ন করছেন) হিসাবে, আমি 100% নিশ্চিত করে বলতে পারি: জ্যামিতি একেবারেই মজাদার নয় ... ডি:

— আশ্বিন গুপ্ত

Answer 1

পাইথ, 40 36 34 32 বাইট

-১ বাইট @ আইস্যাচজি দ্বারা

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 বাইট হারিয়ে এটি কীভাবে গল্ফ হবে তা দেখার জন্য আমি অপেক্ষা করতে পারি না :)

— ETH প্রোডাকশনগুলি

চমৎকার সমাধান! আপনি প্রতিস্থাপন দ্বারা একটি বাইট সংরক্ষণ করতে পারবেন qez\+সঙ্গে }\+z, কারণ +করতে পারেন শুধুমাত্র গত অবস্থানে প্রদর্শিত হবে।

— isaacg

Answer 2

পাইথ, 38 বাইট

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

পরীক্ষা স্যুট

মূলত এটি হিসাবে হিসাবে সোজা। আমি আশা করি আমি দুটি আকারের জন্য কিছু যুক্তি সংযুক্ত করতে পারতাম, তবে বর্তমানে এটি পৃথক।

Answer 3

জাভাস্ক্রিপ্ট (ES6), 142 146 147

সম্পাদনা করুন 1 বাইট ধন্যবা @ETHproductions সংরক্ষিত সম্পাদনা 2 বাইট Sve ধন্যবা @ 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-> ., যেহেতু আগে এবং পরে একেবারে একটি অ-অঙ্কের নিশ্চয়তা রয়েছে

— ETH প্রোডাকশনগুলি

@ ইথ প্রডাকশনগুলি ঠিক আছে, ধন্যবাদ

— এডক 65

খুশী হলাম। আমি মনে করি এটি জেএসের সর্বোত্তম অ্যালগরিদম, একটি ছোটও খুঁজে পাবে না।

— ETH প্রোডাকশনগুলি

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

— ব্যবহারকারী81655

@ ব্যবহারকারী 81655 সুন্দর ইঙ্গিত, ধন্যবাদ

— 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-

এটি অনলাইন চেষ্টা করুন!

আমাদের প্রথমে আমাদের যা করতে হবে তা হ'ল আমাদের আকৃতিটি কত বড় হওয়া দরকার figure এটি বেশ সহজ:

      // 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.

এতক্ষণে, আমরা আউটপুটটির আকার এবং আকারের যত্ন নিয়েছি। যা বাকি আছে তা ঘোরানো is ত্রিভুজগুলি বর্তমানে চিহ্নিত করা হয়েছে, সুতরাং তৃতীয় চরটি হলে আমাদের সেগুলি ফ্লিপ করতে হবে +:

!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 বাইট

হালনাগাদ:

তালিকা উপলব্ধি এবং স্ট্রেনসেন্টার () ব্যবহার করে কিছু উল্লেখযোগ্য অপ্টিমাইজ করা হয়েছে। আমার অনুভূতি আছে যে আমি আরও কিছু করতে পারি, পরে এটিকে নতুন করে দেখাব।

আপডেট 2

শার্লক 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 এর বাইট গণনা দেয় I আমি কি ভুল করছি?

— ბიმო

এটি প্রকৃতপক্ষে 235 বাইট। গল্ফিংয়ের পরামর্শ: দুটি স্পেসের পরিবর্তে ট্যাব ব্যবহার করুন যা পাইথন 2 এ বৈধ এবং 5 বাইট শেভ করবে।

— ডোরকনবব

এছাড়াও আপনার 4 বাইট সংরক্ষণ raw_inputকরে ব্যবহার করার দরকার নেই input। আরও আপনার দ্বিতীয় লাইনে বন্ধনী প্রয়োজন নেই, এটি এবং ভেরিয়েবলটি মোটেও ব্যবহার না করা x(ব্যবহার করে if"s"in d) আপনাকে অন্য 9 বাইট সংরক্ষণ করে ।

— 3

উইন্ডোতে গণনা করার সময় @ ডেনারএফি, প্রতিটি নতুন লাইনের জন্য 1 বাইট বিয়োগ করুন

— নিউলাইনগুলি

প্রথমত, আপনি []প্রতিটি 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 টি অক্ষর। এটি প্রদর্শন করতে আমার এক মনিটর এবং দেড় ঘন্টা লাগে।

— ইসানানে

@ আইসানা এটি এখানে 220 বলেছে।

— লুভজো

আমি এলোমেলো টিনিয়্যুর লিঙ্কে ক্লিক করব না, তবে আবার চেক করুন। যাই হোক না কেন, কোড বাক্সগুলিতে স্ক্রোল বারগুলি এড়িয়ে চলার চেষ্টা করুন, এটি পড়া আরও শক্ত করে তোলে।

— ইসানায়ে

@ লভজো আমার ধারণা তিনি ব্যাখ্যাটির প্রথম পংক্তির অর্থ। আমি সাধারণত জাভাস্ক্রিপ্ট উত্তরের জন্য এই স্টাইলের চেয়ে আমার ব্যাখ্যাটি ইনডেন্ট করি যাতে এর অর্ধেকটি দেখার জন্য আপনাকে স্ক্রোল করার প্রয়োজন হবে না।

— ব্যবহারকারী 81655

@ 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)

প্রথম প্রচেষ্টাটি শেষের দিকে .চ্ছিক ছিল তা দৃg় +/-হয়, এ থেকে পরিত্রাণ পেতে আমাকে একগুচ্ছ শেভ করতে দিন

এখানে ধারণাটি হ'ল একটি তালিকা তৈরি করা যা জেনেরিক আউটপুটে নিক্ষিপ্ত হতে পারে। সবচেয়ে শক্তিশালী অংশটি ইনপুট থেকে দৈর্ঘ্যটি আলাদা করছিল।

Comments

দৈর্ঘ্য পাওয়ার জন্য আমি x=int(d[1]if len(d)<4 else d[1:3])ইনপুট স্ট্রিং হয়ে ডি ব্যবহার করেছিলাম । আপনার সমাধানের চেয়ে 5 বাইট কম খাটায়। আপনি এখনও আমার অজগর উত্তর থেকে অনেক এগিয়ে আছেন, আপনি সেখানে কী করেছেন তা বোঝার চেষ্টা করতে হবে এবং পরের বার আপনাকে মারবে! :)

— ডেনকার

প্রকৃতপক্ষে x=int(d[1:-1])এটির জন্য অনেক ছোট, এটি অন্য অজগর উত্তরে দেখেছি saw

— ডেনকার

@ ডেনারএফি, যে কোনও কারণে আমি বৈদ্যুতিন সংকেতের মেরু বদল ,চ্ছিক হওয়ার কথা মনে করি, যাতে এটি কাজ করে না, তবে আমার ধারণা আমি কেবল এটি তৈরি করেছি

— 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পরিবর্তে ব্যবহার করতে সম্পাদনা> EOL রূপান্তর> ইউনিক্স / লিনাক্স ফর্ম্যাটটিতে গিয়েছি \r\n। সামগ্রীর বেস 64: XGQrCiQwJCo6wrYKXigoXHcpKyk6KDorKQokMSQyJDMkMsK2JDAKbWBzJHw6dAoKKWAoLispwrYtKFxEKikKLSQywrYkMQptYF4uCgpHYC4KVGB0czpgICo=(নোটপ্যাড ++ থেকে সরাসরি অনুলিপি)। অদ্ভুতভাবে যথেষ্ট, যে কোনও অনলাইন সমাধান আমাকে 85 বাইট দেয় ... হুম ...

— ইসমাইল মিগুয়েল

@ ইসমাইল মিগুয়েল নোটপ্যাড ++ কীভাবে গণনা করে তাতে কিছু একটা বন্ধ হবে ¶। তারা অবশ্যই আইএসও 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

@ মেগো: দেখুন #dXdXεj? STRING স্লিকিং ????

Answer 11

ES6, 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।

সম্পাদনা করুন: @ এডক 65 এর জন্য 6 টি বাইট সংরক্ষণ করা হয়েছে।

সম্পাদনা করুন: 13 টি বাইট সংরক্ষণ করা u+=vতৃতীয় যুক্তিতে লুকিয়ে রাখার জন্য ধন্যবাদ substrআমাকে এভাবে প্রাথমিককরণ সহজ করার অনুমতি দেয়।

Comments

@ থমাসকওয়া হুহ, আমি tহ্যান্ডলিং কোডটি ঠিক করার পরে এটি পরিণত হয়েছিল wএবং uএটি সমতুল্য হয়ে উঠেছে এবং এটি আমাকে 178-এ নামিয়ে নেওয়ার জন্য যথেষ্ট পরিমাণে বাইট সংরক্ষণ করেছে!

— নীল

[,b,c]=s.matchএবং পরে s<'t'... কিছু বাইট (কেবলমাত্র ফায়ারফক্স) সংরক্ষণ করা উচিত

— এডক 65

@ edc65 ঠিক ম্যাচটি সংরক্ষণ না করে sআমাকে ব্যবহার করতে দেয় s<'t'যা আমাকে 6 বাইট সংরক্ষণ করেছে, ধন্যবাদ

— নীল

Answer 12

এমএটিএল , 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

রুবি, 99

->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পক্ষগুলির opeালু খুব সুন্দর করে এবং গড় প্রস্থের n গণনা করে (সুতরাং গণনা করা ত্রিভুজ প্রস্থটি বেসে 2n-1, ডগায় 1।) তবে এটি কেবল সেই সারিগুলি মুদ্রণ করে যা nঅক্ষর অতিক্রম করে না ।

পরীক্ষা প্রোগ্রামে ungolfed

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 বাইট, নন-কেপটিং ing

এই চ্যালেঞ্জ পোস্ট হওয়ার পরে আমি ফাংশন যুক্ত করেছি, সুতরাং এটি গ্রহণের জন্য বিবেচনা করা যাবে না। এটি আইএসও -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