모두 기하학을 좋아합니다. 그렇다면 왜 골프를 치고 코딩하지 않습니까? 이 도전은 문자와 숫자를 받아 그것에 따라 모양을 만드는 것입니다.

입력

입력 형식은 (shapeIdentifier)(size)(inverter)입니다.

그러나 shapeIdentifier, 크기 및 인버터는 무엇입니까?

모양 식별자는 *s 로 만들 모양의 유형에 대한 식별자입니다 . 다음은 모양 식별자입니다.

• s -광장
• t -삼각형

크기는 사이 1-20이며 그림의 크기입니다.

인버터는 형태가 거꾸로 될지 여부이며, 이는 a +또는 a 로 표시됩니다 -. 메모를 수행합니다 s3-== (같음) s3+사각형 대칭 때문이다. 그러나 t5-! = (같지 않음) t5+.

출력에서 후행 공백은 괜찮지 만 선행 공백은 그렇지 않습니다.

출력 예

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

Input: t5+

Output:
  *
 ***
*****

Input: t3-
Output:
***
 *

특별 노트

삼각형 입력은 항상 홀수이므로 삼각형은 항상 *상단에서 1 로 끝납니다 .

삼각형의 크기는 인버터의 경우 밑면의 크기이고 인버터 +의 경우 상단의 크기입니다 -.

Pyth, 40 36 34 32 바이트

@isaacg에 의해 -1 바이트

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

람다 내부의 세미콜론은 이제 1 바이트를 절약하는 기능인 람다 변수의 전역 값입니다.

                         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.

여기에서 시도 하십시오 .

테스트 스위트 .

Pyth, 38 바이트

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

테스트 스위트

기본적으로 최대한 간단합니다. 두 가지 모양의 논리를 결합 할 수 있기를 원하지만 현재는 분리되어 있습니다.

자바 스크립트 (ES6) 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`
`)

테스트 (FireFox에서 실행)

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>

파이썬 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)

출력은 완벽한 사각형으로 각 줄에 후행 공백이 채워져 있으며 OP의 주석을 기반으로 괜찮다고 가정합니다.

참고 : input파이썬 2에서 이러한 문제가 허용 되는지 는 확실하지 않습니다 ...

Japt, 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.

그리고 암시 적 출력으로 우리의 작업이 완료됩니다. :-)

파이썬 2 235 193 167 157 바이트

최신 정보:

list comprehensions와 str.center ()를 사용하여 상당한 최적화를 만들었습니다. 좀 더 할 수 있다는 느낌이 들었습니다. 나중에 다시 살펴볼 것입니다.

업데이트 2

Sherlock9의 제안으로 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

아주 단호한 접근법. 결국 출력하는 문자열에 한 줄에 한 줄을 씁니다. 삼각형은 항상 반전되어 그려지며 필요한 경우 반전됩니다. Integer로 문자열을 곱할 수 있다는 사실 때문에 많은 바이트가 절약되었습니다!

나는 골프를 조금 더 밟아 내려고 시도 할 것이며, 그 동안 아직 그다지 경험하지 않았기 때문에 그 동안의 제안에 감사 할 것입니다.

편집 : 의견의 도움으로 많은 골프를 쳤고 다른 파이썬 답변 중 하나에서 크기 계산을 훔쳤습니다. 나는이 알고리즘으로 내가 할 수있는 가장 많은 것이라고 생각합니다.

자바 스크립트, 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

파이썬 2, 157132 바이트

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)

첫 번째 시도 +/-는 끝 부분이 선택 사항 이라는 것을 증명했습니다.

여기서 아이디어는 일반 출력으로 던져 질 수있는 목록을 만드는 것입니다. 가장 어려운 부분은 입력에서 길이를 분리하는 것입니다.

망막 , 102 85 바이트

바이트 수는 소스 코드가 ISO 8859-1로 인코딩 된 것으로 가정합니다.

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

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

G`.
T`ts:` *

온라인으로 사용해보십시오.

나는 이것을 나중에 더 골프하려고 노력할 것이다.

진심으로, 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 슬라이싱 ????

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.

편집 : @ edc65 덕분에 6 바이트가 절약되었습니다.

편집 : 초기화를 단순화 할 수 u+=v있다는 세 번째 인수 를 숨겨서 13 바이트를 절약했습니다 substr.

MATL , 48 바이트

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

사용 최신 버전 (10.1.0) 언어 / 컴파일러를.

모든 : 코드는 어떤 순서로 입력 문자를 받아 s11+, 11s+심지어 1+s1유효한 입력 문자열이 될 것입니다.

EDIT (2016 년 7 월 30) : 링크 된 코드를 대체합니다 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

C, 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}

언 골프

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

제안과 비평은 매우 환영합니다.

루비, 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와 평균 너비 의 정사각형 또는 삼각형을 계산합니다 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]

Jolf, 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