Herkes geometriyi sever. Peki neden golf oynamayı deniyoruz? Bu zorluk, harf ve rakamları almayı ve buna bağlı olarak şekiller oluşturmayı içerir.

Girdi

Giriş şeklinde olacaktır (shapeIdentifier)(size)(inverter).

Ama shapeIdentifier, size ve invertör nedir?

Şekil tanımlayıcısı, *s ile yapacağınız şekil türünün tanımlayıcısıdır . Şekil tanımlayıcıları aşağıdadır:

• s - Kare
• t - Üçgen

Boyut arasında olacak 1-20ve bu rakamın boyutudur.

Evirici, şeklin a +veya a ile gösterilen ters çevrilmiş olup olmayacağıdır -. Not: s3-== (eşittir) s3+çünkü kareler simetriktir. Ancak t5-,! = (Eşit değil) t5+.

Çıktıda beyaz boşluk var, ancak baştaki boşluk yok.

Çıktı Örnekleri

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

Input: t5+

Output:
  *
 ***
*****

Input: t3-
Output:
***
 *

Özel notlar

Üçgen giriş her zaman tek bir sayı olacaktır, bu nedenle üçgenler her zaman *en üstte 1 ile bitecektir .

Üçgenin boyutu, invertör ise tabanın boyutu ve invertör ise +üst boyuttur -.

Pyth, 40 36 34 32 bayt

-1 bayt by @isaacg

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

Bir lambda içindeki bir noktalı virgül artık lambda değişkeninin global değeridir, bir bayttan tasarruf sağlar.

                         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.

Burada dene .

Test paketi .

Pyth, 38 bayt

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

Test odası

Temel olarak alır gibi basit. Keşke iki şekil için bir miktar mantık birleştirebilseydim, ama şu anda ayrı.

JavaScript (ES6), 142 146 147

Düzenle 1 byte kaydedilen thx @ETHproductions Düzenleme 2 bytes 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`
`)

Test (FireFox'ta çalıştır)

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>

Python 2, 106 bayt

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)

Çıktı mükemmel bir dikdörtgen, her satırın OP'deki yorumlara göre tamam olduğunu düşündüğüm takip boşluklarıyla dolgulu.

Not: Yine inputde Python 2'de bu gibi sorunlar için izin verilip verilmediğinden emin değilim ...

Japt, 62 60 55 52 51 bayt

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

Çevrimiçi deneyin!

Yapmamız gereken ilk şey, şeklimizin ne kadar büyük olması gerektiğini bulmak. Bu oldukça basit:

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

Şimdi çıktının şeklini düzenliyoruz:

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.

Şimdiye kadar, çıktının boyutuna ve şekline dikkat ettik. Geriye kalan tek şey rotasyon. Üçgenler şu anda işaretli, bu yüzden üçüncü karakter ise onları çevirmemiz gerekiyor+ :

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

Ve örtük çıktıyla, burada işimiz bitti. :-)

Python 2, 235 193 167 157 Bayt

Güncelleştirme:

Liste anlama ve str.center () kullanarak bazı önemli optimizasyonlar yapıldı. Biraz daha tho yapabilirim, daha sonra bakacağım.

Güncelleme 2

Sherlock9 önerileri ile 10 Bayt kurtardı. Çok teşekkürler! :)

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

Eski cevap

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

Oldukça sağlam yaklaşım. Sonunda çıkardığım bir dizgede satır başına satır yazma. Üçgenler daima ters çevrilir ve gerekirse ters çevrilir. Bir dizgiyi bir Tamsayı ile çarpmanız beni çok fazla bayt kurtardı!

Bunu daha sonra biraz daha aşağıya indirmeye çalışacağım, bu arada önerileri takdir ediyorum, çünkü henüz fazla tecrübeli değilim.

düzenleme: yorumlarda yardımı ile çok aşağı Golfed ve diğer python-cevaplardan birinden boyut hesaplama çalmak. Sanırım bu algoritma ile yapabileceğim en fazla şey bu.

JavaScript, 220 bayt.

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

İle koş f(input here)

Burada dene !

Karelerin takip eden yeni hatları var, ama üçgenler yok. Açıklama:

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

Python 2, 157 132 bayt

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)

İlk girişim +/-sonunda sonun isteğe bağlı olduğunu ve bundan kurtulmamın bir demet tıraş olmamı sağladı.

Buradaki fikir, genel bir çıktıya atılabilecek bir liste yapmaktır. En zor kısım uzunluğu girişten ayırmaktı.

Retina , 102 85 bayt

Bayt sayısı, kaynak kodunun ISO 8859-1 olarak kodlandığını varsayar.

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

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

G`.
T`ts:` *

Çevrimiçi deneyin.

Bunu daha sonra golf oynamaya çalışacağım.

Cidden, 54 bayt

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

Çevrimiçi Deneyin

,#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: Gördün #dXdXεjmü? STRING SLICING ????

ES6, 178 172 159 bayt

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

Bu, yaptığım ilginç bir gözlem nedeniyle işe yarıyor. Eğer tekrar olursa nboşluklar ve nyıldız işaretleri sen (örn için olsun n=5bu):

     *****

Şimdi, aynı başlangıç ​​ve uzunluktaki alt dizileri alın:

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

Bu alt diziler tam olarak ihtiyaç duyduğumuz dizelerdir t5.

Düzenleme: @ edc65 sayesinde 6 bayt kaydedildi.

Düzenleme: u+=vÜçüncü argümanı gizleyerek, substrbu şekilde ilklendirmeyi basitleştirmeme izin veren 13 bayt kaydedildi .

MATL , 48 bayt

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

Dilin / derleyicinin geçerli sürümünü (10.1.0) kullanır .

Tüm: Kod herhangi bir sırada girdi karakterleri kabul s11+, 11s+ve hatta1+s1 geçerli girdi dizeleri olacaktır.

DÜZENLEME (2016 30 Temmuz): bağlantılı kod cümledeki 1L3$)tarafından Y)dilinde son değişikliklere uyum sağlamak

Çevrimiçi deneyin!

açıklama

' *'        % 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

C, 259 bayt

#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("");
    }
}

Öneriler ve eleştiriler çok açıktır.

Ruby, 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))}}

Kenarların eğimini bırakarak bir kare veya yükseklik nve ortalama genişlik n üçgeni hesaplar (böylece hesaplanan üçgen genişliği tabanda 2n-1, ucunda 1'dir.) Ancak, yalnızca aşmayan satırları yazdırır.n karakterleri .

test programında 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]

Jolf, 37 bayt, rekabetçi olmayan

Bu zorluğun yayınlanmasından sonra fonksiyonlar ekledim, bu yüzden bu kabul olarak kabul edilemez. Bu ISO-8859-7'de kodlanmıştır. Tüm test durumlarını burada deneyin .

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

Bölüm 1: dize ayrıştırma

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)

Bölüm 2: sonucu elde etmek

γ?='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

Bölüm 3: sonucu tersine çevirmek

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