문제

비슷한 일 을하는 이전의 도전 에서 영감을 얻음

양의 정수 입력 n출력에 다음 패턴을 따르는 모양이 제공됩니다.

입력 n=1:

* *
 *
* *

입력 n=2:

**  **
 ****
  **
 ****
**  **

입력 n=3:

***   ***
 *** ***
  *****
   ***
  *****
 *** ***
***   ***

등등...

다음과 같은 속성이 있습니다.

n*2+1 키가 큰 줄

"무기"는 n 합칠 때를 제외하고 넓습니다.

중심선이 n넓다

경우 n에도 선 위 가운데 아래에있는 n*2넓은

만약 n홀수 및 상기 중심 아래 선은 n*2-1넓은

규칙

• 후행 줄 바꿈 허용
• 표준 허점 적용
• 최단 바이트 승리
• 출력물이 인쇄되거나 문자열 또는 문자열 배열 일 수 있음

편집

• n=0 처리 할 필요가 없습니다
• 후행 공백 허용

숯 , 13 12 바이트

바이트에 대한 @ErikTheOutgolfer 덕분에

ＦＮ«ＰX⁺*×*Ｉθ→

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

이것은 내 첫 번째 숯불 답변이며 골프는 물론 골프도되지 않았다고 확신하지만 어딘가에서 시작할 것이라고 생각했습니다.

 ＦＮ«            # For input() (i in range(0,input()))
     Ｐ           # Print
       X          # In an 'X' shape
        ⁺*×*Ｉθ   # '*'+'*'*int(first_input)
               →  # Move the cursor right one

MATL , 16 바이트

EQXyG:Y+tP+g42*c

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

설명

2예를 들어 입력 을 고려하십시오 . 스택 내용은 아래에 최신 내용으로 표시됩니다.

EQ    % Implicitly input n. Push 2*n+1
      %   STACK: 5
Xy    % Identity matrix of that size
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1]
G:    % Push [1 2 ... n]
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1],
                 [1 2]
Y+    % 2D convolution, extending size
      %   STACK: [1 2 0 0 0 0;
                  0 1 2 0 0 0;
                  0 0 1 2 0 0;
                  0 0 0 1 2 0;
                  0 0 0 0 1 2]
tP+   % Duplicate, flip vertically, add
      %   STACK: [1 2 0 0 2 1;
                  0 1 2 1 2 0;
                  0 0 1 4 0 0;
                  0 1 2 1 2 0;
                  1 2 0 0 1 2]
g     % Convert to logical
      %   STACK: [1 1 0 0 1 1;
                  0 1 1 1 1 0;
                  0 0 1 1 0 0;
                  0 1 1 1 1 0;
                  1 1 0 0 1 1]
42*   % Multiply by 42.
      %   STACK: [42 42  0  0 42 42;
                   0 42 42 42 42  0;
                   0  0 42 42  0  0;
                   0 42 42 42 42  0;
                  42 42  0  0 42 42]
c     % Convert to char. Char 42 is '*'. Char 0 is displayed as space
      %   STACK: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']

젤리 , 15 바이트

Ḥ‘Ḷ⁶ẋ;€”*ẋ$»Ṛ$Y

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

V , 18 17 바이트

@DJMcMayhem의 입력 트릭 덕분에 바이트가 절약되었습니다.

Àé*ÄJÀälÀñ2ÙÀl2x>

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

설명

Àé*ÄJÀäl

이 삽입 [n]*'*'+[n]*' '+[n]*'*'

        Àñ        ' [arg] times
          2Ù      ' Duplicate the current line down twice
            Àl    ' Move right [arg] times
              2x  ' Delete two characters
                > ' Indent this line one space

버퍼가가는 루프의 각 반복

|**   ***

에

***   ***
 |** ***
***   ***

아래에 |커서가있는 곳에*

05AB1E , 18 바이트

Å4bS{I·ƒDÂ~„ *èJ,À

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

설명

예 n=2

Å4                   # push a list of 4s with length as the input
                     # STACK: [4,4]
  b                  # convert each to binary
                     # STACK: [100, 100]
   S{                # split into digit list and sort
                     # STACK: [0, 0, 0, 0, 1, 1]
     I·ƒ             # input*2+1 times do
        D            # duplicate top of stack
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 0, 0, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
         Â~          # or each item in the duplicate with its reverse
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 1, 1, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
           „ *èJ     # use the resulting binary list to index into the string " *"
                     # 1st iteration: [0, 0, 0, 0, 1, 1], "**  **"
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], " **** "
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], "  **  "
                ,    # print
                 À   # rotate list left

V , 23 바이트

Àé*ÄJÀälÀñÙãlxx>ñyHæGVp

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

16 진 덤프 :

00000000: c0e9 2ac4 4ac0 e46c c0f1 d9e3 6c78 783e  ..*.J..l....lxx>
00000010: f179 48e6 4756 70                        .yH.GVp

어떤 이유로 든,이 도전은 마지막 도전보다 V에서 상당히 어렵습니다. n 번의 일반적인 접근 방식으로 'x'를 키 웁니다. 를 키우면 여기에서 작동하지 않습니다. 대신 X의 상단을 구성하고 복사하여 뒤집은 다음 두 부분을 함께 연결합니다.

설명:

Àé*ÄJÀäl                " Insert ('*' * n) + (' ' * n) + ('*' * n) 
                        " The obvious way would be 'Àé*ÀÁ ÀÁ*', but this 
                        " non-obvious way saves us a byte
        Àñ      ñ       " 'n' times:
          Ù             "   Duplicate this line (below us)
           ãl           "   Move to the center of this line
             xx         "   Delete two characters
               >        "   And indent this line with one space.

루프 끝 에서 들여 쓰기를 수행하면 암시적인 끝을 활용할 수 있습니다 . 이것은 또한 ' + '의 정확히 절반 인 n + 1 라인을 편리하게 생성 합니다. 입력이 4라고 가정 해 봅시다.이 시점에서 버퍼는 다음과 같습니다.

****    ****
 ****  ****
  ********
   ******
    ****

그리고 우리는 마지막 줄에 있습니다. 그럼 우리는 :

                yH      " Copy the whole buffer and move to the first line
                  æG    " Reverse every line
                    Vp  " And paste what we just copied *over* the current
                        " line, deleting it in the process

C #, 139130 바이트

문자열을 작성하고을 호출하여 -1 바이트 WriteLine이므로 새 행에 대한 검사를 저장합니다.
Kevin과 그의 마스터 골프 기술 덕분에 -6 바이트!
로 교체 n*3-n하여 -2 바이트 n*2.
Kevin이 친절하게 올바른 방향으로 나를 지적한 후 -15 바이트 : 문자열을 인쇄하는 대신 반환하여 호출을 절약 할 수 System.Console.WriteLine()있습니다. 그리고 다른 팁들도 ...

n=>{var s="";for(int i,j=0;j<=n*2;j++,s+='\n')for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>=n*2-j?'*':' ';return s;}

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

언 골프 드 :

class Program
{
    static void Main(string[] args)
    {
        System.Func<int, string> g = n =>
        {
            var s = "";
            for (int i, j = 0; j <= n*2; j++, s += '\n')
                for (i = 0; i < n*3;)
                    s += i >= j & i < j+n | i <= n*3-j-1 & i++ >= n*2-j ? '*' : ' ';
            return s;
        };

        System.Console.Write(f(1));
        System.Console.Write(f(2));
        System.Console.Write(f(3));
        System.Console.Write(f(5));
        System.Console.Write(f(8));

        System.Console.ReadKey();
    }
}

큰 X를 인쇄하는 데 필요한 공간의 행과 열을 반복 하고 조건에 따라 a '*'또는 a를 인쇄합니다 ' '.

하스켈 , 88 87 86 바이트

@Laikoni에게 -1 감사합니다

(!)=replicate
x n=[zipWith max(reverse m)m|m<-[i!' '++n!'*'++(n*2-i)!' '|i<-[0..n*2]]]

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

젤리 , 24 23 16 바이트

Ḥ‘Ḷ⁸+þṬ+Ṛ$a”*o⁶Y

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

MATLAB, 153126 바이트 (17.6 % ↓)

덕분에 LuisMendo의 코멘트 @ 기능 disp()따옴표없이 출력 할 수 문자, 따라서 나는 사용하지 못할 수 fprintf와 formats몇 바이트를 생략합니다. 게다가, 그의 의견은 (널) char(32)보다는 공백을 제시 하기 위해 사용해야한다는 것을 상기시킵니다 char(0).

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=10
disp([a+32 ''])

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

MATLAB, 153 바이트

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1 
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=42
fprintf([repmat('%c',1,c),'\n'],char(a)')

결과 예 : n = 10

**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

파이썬 2 , 93 90 89 83 바이트

^{Leaky Nun 덕분에 -3 바이트
Zachary T 덕분에 -1 바이트
xnor 덕분에 -6 바이트}

n=input()
x=n*'*'+n*'  '
exec"print`map(max,x,x[::-1])`[2::5];x=' '+x[:-1];"*(n-~n)

[온라인으로 사용해보십시오!] [TIO-j3xwsktf]

'*** 'for 와 같은 문자열로 시작n=3 적용, map/max을 선택하는 *다음 각 위치에 대한 공간을 통해 공간을 추가하고, 문자열에서 마지막 문자를 제거하고 모두 다시 이렇게.

하스켈 , 70 바이트

f n=[[last$' ':['*'|y<-[1..n],(c-n-y)^2==r^2]|c<-[1..3*n]]|r<-[-n..n]]

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

문자열 목록을 출력합니다.

행의 각 위치에 대해 r열 c은 수식을 사용하여 두 대각선 밴드 중 하나에 해당하는지 여부를 결정합니다 *.

자바 8, 119118 바이트

n->{String r="";for(int i=0,j;i<=n*2;i++,r+="\n")for(j=0;j<n*3;r+=j>=i&j<i+n|j<=n*3-i-1&j++>=n*2-i?"*":" ");return r;}

@CarlosAlejo 의 놀라운 C # 답변의 포트 는 몇 가지 골프 를 쳤 습니다. 따라서 그를 공표해야합니다!

여기에서 시도하십시오.

자바 (ES2017) 155 157 바이트

n=>[...e=[...Array(n+1)].map((a,i)=>[...d=((b=''.padEnd(n))[c='slice'](i)+'*'.repeat(n)+b[c](0,i))[c](n/2)].reverse().join``+d[c](n%1)),...e.reverse()[c](1)]

문자열 배열을 반환합니다. 어레이에서 작업을 수행 한 다음 미러링합니다. 이것은 아마도 다른 답변과 같은 행렬로 최적화 될 수 있지만 독창적이기를 원했습니다.

편집 : Neil이 지적한 것처럼의 짝수 값은 n중심선이 n넓지 않았 으므로 열을 슬라이싱 할 때 짝수 / 홀수를 감지하는 계수를 추가했습니다.

n=5
['*****     *****',
 ' *****   ***** ',
 '  ***** *****  ',
 '   *********   ',
 '    *******    ',
 '     *****     ',
 '    *******    ',
 '   *********   ',
 '  ***** *****  ',
 ' *****   ***** ',
 '*****     *****']

언 골프

n => {
  e = [...Array(n+1)].map((a, i) => {   // Create and iterate over array with n+1 elements
    b = ''.padEnd(n)                    // String of n spaces
    d = (b.slice(i) + '*'.repeat(n) + b.slice(0, i)).slice(n/2) // Create row string
    return [...d].reverse().join`` + d.slice(1) // Mirror and combine row horizontally
  })
  return [...e,...e.reverse().slice(1)] // Mirror and combine vertically
}

사분면

n=5
   *****
  ***** 
 *****  
*****   
****    
***     

수평으로 미러링

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     

수직으로 미러링

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     
    *******    
   *********   
  ***** *****  
 *****   ***** 
*****     *****

Mathematica, 148 바이트

T=Table;(a=Join[T[T["*",i],{i,(n=#)+2,2n,2}],T[Join[t=T["*",n],T[" ",y],t],{y,1,n,2}]];Column[Row/@Join[Reverse@a,{T["*",n]},a],Alignment->Center])&

R, 102 바이트

암호:

n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)

테스트:

> n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)
1: 10
2: 
Read 1 item
**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

CJam, 24 바이트

{:T2*){S*T'**+}%_W%..e>}

이것은 스택에서 숫자를 가져와 스택에 행 목록을 출력하는 블록입니다.

설명:

{                        e# Stack:           | 2
 :T                      e# Store in T:      | 2, T=2
   2*                    e# Multiply by 2:   | 4
     )                   e# Increment:       | 5
      {                  e# Map over range:  | [0
       S                 e#   Push space:    | [0 " "
        *                e#   Repeat string: | [""
         T               e#   Push T:        | ["" 2
          '*             e#   Push char '*': | ["" 2 '*
            *            e#   Repeat char:   | ["" "**"
             +           e#   Concatenate:   | ["**"
              }%         e# End:             | ["**" " **" "  **" "   **" "    **"]
                _        e# Duplicate:       | ["**" " **" "  **" "   **" "    **"] ["**" " **" "  **" "   **" "    **"]
                 W%      e# Reverse:         | ["**" " **" "  **" "   **" "    **"] ["    **" "   **" "  **" " **" "**"]
                   ..e>  e# Overlay:         | ["**  **" " ****" "  **" " ****" "**  **"]
                       } e# End

파이썬 2 , 110 바이트

x=a=0
n=c=input()
while x<2*n+1:
    print ' '*a+'*'*n+' '*c+'*'*(2*n-2*a-c)
    x+=1
    a=n-abs(n-x)
    c=max(0, n-2*a)

이 프로그램은 각 선을 첫 번째 공백, 첫 번째 별, 두 번째 공백 및 두 번째별로 네 부분으로 나눕니다. X의 각 수평선에 대해 선의 4 개 섹션 각각에 필요한 별 또는 공간 수를 계산 한 다음 해당 문자열을 구성하고 인쇄합니다.

레티 나 144 바이트

.+
 $&$* $&$* $&
 
$`#$'¶
¶\d+$

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1
( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3
+` (# +#)
$1 
+` #...
#
##

온라인으로 사용해보십시오! 설명:

.+
 $&$* $&$* $&

입력 값 앞에 2n + 1 공백을 추가하십시오 (각 출력 라인마다 하나씩).

$`#$'¶

각 공간을 a #로 바꾸고 결과를 수집하십시오. 이렇게하면 #입력 값에 접미사가 붙은 양쪽에 공백으로 채워진 대각선 s가 나타납니다.

¶\d+$

각 줄에 사본이 있으므로 원래 입력 값을 삭제하십시오.

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1

한 쌍의 s로 묶인 공백 *의 구분 기호 열을 사용하여 n 개의 대각선 2 개를 만듭니다.n#

( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3

*s가 중간에 더 가까운 라인에서 두 반쪽을 바꿉니다. 이것은 닮은 모양을 제공합니다 > | | <.

+` (# +#)
$1 

| |s를 최대한 왼쪽으로 움직여 일종의 >> > <모양을 만듭니다.

+` #...
#

#s 사이의 각 공백에 대해 다음 세 문자를 삭제하십시오. 이는 합류 > <로 X.

##

이제 불필요한을 삭제하십시오 #.