음수가 아닌 정수가 주어지면 X그 중 큰 것을 인쇄하십시오 . X는 input의 출력 0이며 각 방향의 입력과 동일한 슬래시를 추가 X하여 더 큰 입력 을 위해 확장합니다 .

테스트 사례

0

X

1

\ /
 X
/ \

2

\   /
 \ /
  X
 / \
/   \

...

10

\                   /
 \                 /
  \               /
   \             /
    \           /
     \         /
      \       /
       \     /
        \   /
         \ /
          X
         / \
        /   \
       /     \
      /       \
     /         \
    /           \
   /             \
  /               \
 /                 \
/                   \

규칙

출력을 인쇄하거나 함수에서 문자열 또는 문자열 목록을 반환 할 수 있습니다. 영향을 미치지 않는 추가 공백은 물론 후행 줄 바꿈이 허용됩니다.

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다!

캔버스 , 3 바이트

╵＼┼

여기 사용해보십시오!

차콜 답변 크기의 절반 : D

╵    increment the input
 \   create a diagonal that long
  ┼  and quad-palindromize, mirroring what's required, with 1 overlap;
     This overlaps the `/` and `\`, resulting in `X`

숯 , 6 바이트

ＰX⁺¹ＮX

너의 말도 안돼;)

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

자바 스크립트 (ES6), 79 바이트

그리드를 따라 이동하고 문자를 기준으로 출력 문자를 작성 하는 재귀 함수 g 를 사용합니다 .

n=>(g=x=>`/\\ X
`[~x?x-y?x+y-w&&2:x-n?1:3:4]+(~y?g(~x--?x:y--&&w):''))(y=w=n*2)

방법?

변수 x 와 y 는 2n 에서 -1 까지 반복되며 , 여기서 n 은 입력입니다.

각 위치 그리드의 (x, y) 에 대해 다음 문자 중 하나를 선택합니다.

• 0 : /
• 1: \
• 2 : 공간
• 삼: X
• 4 : 줄 바꿈

다음 테스트를 사용하십시오.

• ~x: x == -1 인 경우 거짓 : 우리는 줄의 끝에 도달했습니다.
• x-y: x == y 인 경우 Falsy : 대각에 위치합니다.
• x+y-w: x + y == w : 거짓이면 대각선에 위치합니다.
• x-n: x == n 인 경우 거짓 :이 테스트는 x == y 일 때만 수행 되므로 그리드의 정확한 중심에 위치합니다.

그리고 다음 의사 결정 트리 :

데모

let f =

n=>(g=x=>`/\\ X
`[~x?x-y?x+y-w&&2:x-n?1:3:4]+(~y?g(~x--?x:y--&&w):''))(y=w=n*2)

console.log(f(0))
console.log(f(1))
console.log(f(4))

MATL , 16 바이트

'\/X 'iEQXytEP+)

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

2예를 들어 입력 을 고려하십시오 . 스택은 여기에 거꾸로 표시됩니다. 즉, 더 낮은 요소가 가장 최근에 밀린 것입니다.

'\/X '  % Push this string
        %   STACK: '\/X '
iEQ     % Input a number, n. Multiply by 2, add 1: gives 2*n+1
        %   STACK: '\/X '
                   5
Xy      % Identity matrix of that size
        %   STACK: '\/X '
                   [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]
tEP     % Duplicate, multiply each entry by 2, flip vertically
        %   STACK: '\/X '
                   [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]
                   [0 0 0 0 2;
                    0 0 0 2 0;
                    0 0 2 0 0;
                    0 2 0 0 0;
                    2 0 0 0 0]
+       % Add the two matrices
        %   STACK: '\/X '
                   [1 0 0 0 2;
                    0 1 0 2 0;
                    0 0 3 0 0;
                    0 2 0 1 0;
                    2 0 0 0 1]
)       % Index into the string. Indexing is 1-based and modular, so 1 picks
        % the first character ('\'), ..., 0 picks the last (space)
        %   STACK: ['\   /';
                    ' \ / ';
                    '  X  ';
                    ' / \ ';
                    '/   \']
        % Implicit display

C, 108106 바이트

a;g(n){for(int b=2*n,i=1,c=47;a+=i;b?puts(""):(i=-i,c=92),b-=2*i)printf("%*c%*c",a,b?c+45*i:88,b,b?c:10);}

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

(MD XF 덕분에 -2 골프)

두 문자 (처음 c = 47에는 슬래시 인,c + 45동적 필드 너비와 함께 백 슬래시 인)를 인쇄합니다.

필드 너비는 1및 2n에서 시작하고 각 반복에서 첫 번째 너비는 1 씩 증가하고 두 번째 너비는 2 씩 감소합니다.

두 번째 필드 너비가 0 'X'이되면 일반 문자 대신 개행을 출력 하고 증분 방향 ( i)을 반대로합니다 . 개행은 다른 모든 행에 대해 별도로 인쇄됩니다 ( puts("")).

shortC , 111 바이트

s(x){Wx--)R" ")}j;f(x){O;j<x;j++)s(j),P92),s((x-j)*2-1),R"/\n");s(x);R"X\n");Wj--)s(j),P47),s((x-j)*2-1),R"\\\n

내 C 답변을 기반으로 합니다. 전환 :

• R -> printf(
• P -> putchar(
• W -> while(
• O -> for(
• 자동 삽입 마감 ");}

또한 \및에 ASCII 코드를 사용합니다 /.

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

파이썬 2 , 81 바이트

r=range(2*input()+1)
for i in r:print''.join(' \/X'[i==j::2][r[~i]==j]for j in r)

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

C, 168 (155) 150 바이트

^{Computronium 덕분에 -5}

#define p printf(
s(x){while(x--)p" ");}j;f(x){for(;j<x;j++)s(j),p"\\"),s((x-j)*2-1),p"/\n");s(x);p"X\n");while(j--)s(j),p"/"),s((x-j)*2-1),p"\\\n");}

확실히 골프를 칠 수 있습니다. 나는 그렇게하고있다. 온라인으로 사용해보십시오!

언 골프 드 :

int space(int x)
{
    while (x--)
        putchar(' ');
}

int f(int x)
{
    for (int j = 0; j < x; j++) {
        space(j);
        printf("\\");
        space((x-j)*2-1);
        printf("/\n");
    }

    space(x);
    puts("X");

    while (j--) {
        space(j);
        putchar('/');
        space((x-j)*2-1);
        printf("\\\n");
    }
}

V , 21 바이트

éXÀñ>HÄÒ r\Á/YGpr/$r\

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

16 진 덤프 :

00000000: e958 c0f1 3e48 c4d2 2072 5cc1 2f59 4770  .X..>H.. r\./YGp
00000010: 722f 2472 5c                             r/$r\

설명:

éX                      " Insert an 'X'
  Àñ                    " Arg1 times:
    >H                  "   Add a space to every line.
                        "   Conveniently, this also puts us on the first line
      Ä                 "   Duplicate this line
       Ò                "   And replace the whole line with spaces
         r\             "   Replace the first char with '\'
           Á/           "   Append a '/' char
             Y          "   Yank this line
              G         "   Move to the last line
               p        "   And paste the line we yanked
                r/      "   Replace the first character with a '/'
                  $     "   Move to the end of the line
                   r\   "   And replace the last character with a '\'

기본적 으로 X를 삽입하고 슬래시를 n 번 확장합니다 .

그러나 처음으로 슬래시를 추가해야하기 때문에 그렇게 간단하지 않습니다. 슬래시가 이미 있으면 슬래시 를 다음과 같이 확장 할 수 있습니다.

>HÄX2pGÙX2p

6 바이트를 절약 할 수 있습니다.

C #을 157 122 120 바이트

_=d=>"".PadLeft(d)
a=>{var s=_(a)+"X\n";for(int i=0;++i<=a;)s=$@"{_(a-i)}\{_(i*2-1)}/
{s+_(a-i)}/{_(i*2-1)}\
";return s;}

언 골프 버전 :

 Func<int, string> _ = (d) =>"".PadLeft(d);
        Func<int, string> func = a => {

            var s = _(a) + "X\n";

            for (int i = 0; ++i <= a;) {

                s = $@"{_(a - i)}\{_(i * 2 - 1)}/
{s + _(a - i)}/{_(i * 2 - 1)}\
";

            }
            return s;
        };

Mathematica, 71 바이트

(Jenny_mathy의 104 바이트 솔루션에서 부분적으로 영감을 얻음)

""<>#&/@(#"\\"+Reverse@#"/"&@IdentityMatrix[2#+1]/.{0->" ",a_+_->"X"})&

문자열 목록을 반환합니다.

설명 : IdentityMatrix[2#+1]대각선을 따라 1과 다른 곳에 0을 사용하여 올바른 크기의 행렬을 만듭니다. 다음으로, 우리는 다중이로 "\\"백 슬래시는 백 슬래시 물론 1 번부터, 그것은 다른 대각선을 따라 백 슬래시과 0과 매트릭스한다 (이스케이프 백 슬래시), 및 0입니다 슬래시 0 번 우리는이를 추가 "/"메이크업에 배 역을 X 모양. 우리는 도처에 여전히 0이 있고 가운데는 "\\" + "/"입니다. 우리는 " "for 0와 "X"for 를 대체하여이 두 가지를 고치는데 a_+_, 이는 두 가지의 합과 일치합니다 ( _+_Mathematica가 자신의 이익을 위해 너무 영리하고이를 2 배로 해석해야한다는 것을 제외하고 _). 마지막 ""<>#&/@으로 이것을 문자열 목록 으로 바꿉니다.

자바 (OpenJDK 8) 135 바이트

i->{int k=0,j,l=2*i+1;String[]s=new String[l];for(;k<l;k++)for(s[k]="",j=0;j<l;j++)s[k]+=j==k?j==i?"X":"\\":j==l-1-k?"/":" ";return s;}

문자열 배열을 가져 와서 정수로 반환하는 람다 식

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

언 골프 드 :

i->{
    int k=0,j,l=2*i+1;                // Some variables to be used
    String[]s=new String[l];            // Return array (size 2*i+1)
    for(;k<l;k++)                       // For each array entry
        for(s[k]="",j=0;j<l;j++)        // Set each character to 
            s[k]+=j==k?j==i?"X":"\\"    // \ or X if it's the jth character of the jth row
                 :j==l-1-k?"/"          // / if it's the opposite char
                 :" ";                  // else blank
    return s;
}

T-SQL, 201 바이트

DECLARE @ INT SELECT @=a FROM t DECLARE @i INT=@
WHILE @>0BEGIN PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'SET @-=1 END
PRINT SPACE(@i)+'X'WHILE @<@i BEGIN SET @+=1 PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'END

형식화 :

DECLARE @ INT 
SELECT @=a FROM t 
DECLARE @i INT=@
WHILE @>0
    BEGIN
        PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'
        SET @-=1 
    END
PRINT SPACE(@i)+'X'
WHILE @<@i 
    BEGIN 
        SET @+=1 
        PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'
    END

입력 열 경유 라는 이름의 테이블에 t , 우리의 가이드 라인에 따라 .

루비 , 66 바이트

재귀 기능.

f=->x{?X[x]||"\\#{s=' '*(2*x-1)}/
#{f[x-1].gsub /^/,' '}
/#{s}\\"}

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

설명

f=->x{                  # Start of recursive function named `f`
      ?X[x]||           # Return 'X' if x==0, otherwise the following:
"\\#{s=' '*(2x-1)}/     #  Top edge of the cross. Save no. of spaces needed
#{f[x-1]                #  Get result of f[x-1]
        .gsub /^/,' '}  #  Regex sub to left-pad every line w/ a space
/#{s}\\"                #  Bottom edge of cross (insert saved no. of spaces)

젤리 , 24 17 바이트

Ḥ‘=þ`µḤ+Uị“/\x ”Y

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

작동 원리

Ḥ‘=þ`µḤ+Uị“/\x ”Y   main link, input a
Ḥ‘                  input doubled and incremented
   þ                Make a table: Apply  
  =                 "equals"/ to      
    `               each element in range(2a+1) cartesian multiplied with itself.
                      eg. For input 1: [1=1,1=2,1=3],[2=1,2=2,2=3],[3=1,3=2,3=3]      
     µ              on this array:
       +            add: 
      Ḥ             double of it to
        U           its reverse (changes south-east to north-west)
         ị“/\x ”    index into the string "/\x " to get the right characters
                Y   join by newlines for the final output.

@LeakyNun 및 -1 바이트 덕분에 -6 바이트 , 추가 개선

배치, 201 바이트

@echo off
set s= /
for /l %%i in (2,1,%1)do call set s=  %%s%%
set s=\%s%
for /l %%i in (-%1,1,%1)do call:c
exit/b
:c
echo %s%
set s=%s:\ = \%
set s=%s:X =/\%
set s=%s:\/=X %
set s=%s: /=/ %

맨 위 줄을 작성하여 시작한 다음 각 줄을 인쇄 한 후 \오른쪽 공간과 /왼쪽 공간을 한 번 이동 X하여 중간에 오도록합니다 .

PHP , 115 바이트

for(;$i<$c=1+2*$argn;$b?:$t[$i-1]="\\".!$t[$c-$i]="/",$o.="$t\n")$t=str_pad(" X"[$b=$argn==+$i++],$c," ",2);echo$o;

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

레티 나 , 74 바이트

.+
$* X
+`^ ( *).( *)
$1\  $2/¶$&
+`¶ ( *).( *).?$
$&¶$1/  $2\
m` (\W)$
$1

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

.+
$* X

을 배치하십시오 X.

+`^ ( *).( *)
$1\  $2/¶$&

에서 시작하여 X위쪽으로 작업 \할 때마다 대각선으로 왼쪽에 배치하십시오 . 마지막 시간 /이후에 공백을 두 개 더 배치하십시오 /.

+`¶ ( *).( *).?$
$&¶$1/  $2\

에서 시작하여 X아래쪽으로 /내려갈 때마다 대각선으로 왼쪽에 배치하십시오 . 마지막 시간 \이후에 공백을 두 개 더 배치하십시오 /.

m` (\W)$
$1

두 대각선 사이의 공백 수는 홀수 여야하므로 각 행의 마지막 공백 (원래 X행 제외 )이 삭제됩니다.

Mathematica, 131 바이트

(F[x_,y_]:=Table[x<>StringJoin@Table[" ",i]<>y,{i,1,#*2,2}];Column[Join[Reverse@F["\\","/"],{"X"},F["/","\\"]],Alignment->Center])&

수학, 104 바이트

그리드를 사용하는 또 다른 접근법이 있습니다.

(S=DiagonalMatrix[Table["\\",r=2#+1]];Table[S[[r+1-i,0+i]]="/",{i,r}];S[[#+1,#+1]]="X";Grid@S/. 0->" ")&

APL (Dyalog) , 25 바이트

⎕IO←0많은 시스템에서 기본값이 필요합니다 .

' \/X'[(⊢+2×⌽)∘.=⍨⍳1+2×⎕]

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

' \/'[…로 ] 문자열을 색인

 ⎕ 입력 받기

 2× 2를 곱하다

 1+ 하나 추가

 ⍳ 많은 정수보다

 ∘.=⍨ 동등성 테이블 (즉, 동일성 매트릭스; NW-SE 대각선)

 (… ) 그것에 다음의 암묵적 기능을 적용하십시오

  ⊢ 논쟁 거리

  + ...을 더한

  2× 두 번

  ⌽ 수평으로 대칭 된 인수 (즉, NE-SW 대각선)

배쉬 , 138 바이트

for i in `seq $1;seq $[$1-1] -1 1`
{ $[a++]
printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`
}|sed 's/22/X/'|tr 12 /\\

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

정말 길다, bash는 '\ and /'

덜 골프

 for i in {1..10} {9..1};{
   $[a++];                      #argument as padding, prints 1 for \ and 2 for /
   printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`;
  }|sed 's/22/X/g' | tr 12 /\\

파이썬 2 , 95 84 바이트

@FelipeNardiBatista 덕분에 -10 바이트

f=lambda s,i='\n':i+(s and'\\'+'  '*~-s+' /'+f(s-1,i+' ')+i+'/'+'  '*~-s+' \\'or'X')

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

05AB1E , 21 바이트

F'\Nú}'X¹ú).B€.∞ø€.∞»

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

Perl 5, 110 + 1 = 111 바이트

-n플래그를 사용합니다 .

$x=$_;$,="\n";push@x,$"x($x-$_)."\\".$"x(2*--$_+1)."/"while$_>0;say@x,$"x$x."x";for(reverse@x){y!\\/!/\\!;say}

QBIC , 90 바이트

~b=0|?@X`\[0,:-1|X=space$(a)┘Z=Z+X+@\`+space$((b-a)*2-1)+@/`+X+@┘`]Z=Z+space$(b)+A+_fZ

이 괴물이 어떻게 작동 하는가는 독자를위한 운동으로 남아 있습니다 ...

샘플 출력 :

Command line: 3
\     /
 \   / 
  \ /  
   X
  / \  
 /   \ 
/     \

비주얼 Basic.Net , 454 450 바이트

Option Strict Off
module m
sub main(a As String())
dim v=Convert.toInt32(a(0))
for i as Integer=v to 1 step -1
for j as Object=1 to v-i
w(" ")
next
w("\")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("/")
next
console.writeline(new String(" ",v)&"X")
for i as Object=1 to v
for j as Object=1 to v-i
w(" ")
next
w("/")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("\")
next
end sub
sub w(s)
console.write(s)
end Sub
end module

하지 않도록하기위한 FUNC 만드는 여부를 writeline가리키는 몇 가지 바이트를 스티븐 S 덕분에 절약 할 수 as ...도 변경 제거 integer에 object 마지막 편집을 첫 번째 백을 변경

05AB1E , 22 바이트

F'\IN-úR.∞})Âí'Xs)˜.c»

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

설명

F                        # for N in [0...input-1] do
 '\                      # push a backslash
   IN-ú                  # prepend input-N spaces
       R                 # reverse
        .∞               # mirror
          }              # end loop
           )             # wrap stack in a list
            Â            # bifurcate
             í           # reverse each item
              'Xs        # push an "X" between the 2 lists on the stack
                 )˜      # wrap in flattened list
                   .c    # pad lines to equal length
                     »   # join on newlines

대체 22 바이트 솔루션

F'\N·>ú'/ì})Âí'X¸«ì.c»

파이크, 14 바이트

\XQV.X \   /\/

여기 사용해보십시오!

\X             - "X"
  QV           - repeat input times:
    .X \   /\/ -  surround(^, all=" ", 
                              tl="\", 
                              left=" ",  
                              right=" ",  
                              lower=" ",  
                              tr="/",  
                              br="\",  
                              bl="/")

tcl, 134

proc P {x s b} {time {puts [format %[incr ::i $x]s%[expr ($::n-$::i)*2+2]s $s $b]} $::n}
P 1 \\ /
puts [format %[incr i]s X]
P -1 / \\

데모

n첫 줄에 설정하십시오 .

재귀 접근 방식을 사용하여 더 골프를 칠 수 있습니까?

R , 75 72 바이트

y=diag(b<-2*scan()+1);write(c(" ",'\\','/','X')[y+2*y[,b:1]+1],'',b,,'')

이 답변 에서 영감을 받아 암시 적 행렬을 생성하고 stdout에 씁니다. stdin에서 크기를 읽습니다. 공백 문자의 행렬을 작성하고 sep=''b / c를 사용해야합니다. 그렇지 않으면 간격 문제가 있습니다.

diag(b)                     # generates a main diagonal of 1, rest 0
2*diag(b)[,b:1]             # the other diagonal is 2
                            # [,b:1] reverses columns
                            # [b:1,] reverses the rows; they're equivalent
diag(b)+2*diag(b)[,b:1]     # sums, so we get 1 for main diagonal
                            # 2 for other diagonal, 3 for center
diag(b)+2*diag(b)[,b:1]+1   # add 1 since R is 1-indexed
                            # the result is indices for the vector
c(' ','\\','/','X')

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