Cho một số nguyên không âm, in ra một số Xlớn như vậy. Xlà đầu ra cho đầu vào 0và bạn sẽ thêm các dấu gạch chéo bằng với đầu vào theo mỗi hướng để mở rộng Xcho đầu vào lớn hơn.

Các trường hợp thử nghiệm

0

X

1

\ /
 X
/ \

2

\   /
 \ /
  X
 / \
/   \

...

10

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

Quy tắc

Bạn có thể in đầu ra hoặc trả về một chuỗi hoặc danh sách chuỗi từ một hàm. Một dòng mới, cũng như khoảng trắng bên trong không ảnh hưởng đến xuất hiện, được cho phép.

Đây là mã golf , vì vậy câu trả lời ngắn nhất trong byte thắng!

Canvas , 3 byte

╵＼┼

Hãy thử nó ở đây!

một nửa kích thước của câu trả lời Char than: 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`

Than , 6 byte

ＰX⁺¹ＮX

Sự vô lý của bạn không ngăn cản tôi;)

Hãy thử trực tuyến!

JavaScript (ES6), 79 byte

Sử dụng hàm đệ quy g đi qua lưới và xây dựng ký tự đầu ra theo ký tự.

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)

Làm sao?

Cả hai biến x và y lặp từ 2n đến -1 , trong đó n là đầu vào.

Đối với mỗi vị trí (x, y) trong lưới, chúng tôi chọn một trong các ký tự sau:

• 0: /
• 1: \
• 2: không gian
• 3: X
• 4: dòng mới

sử dụng các xét nghiệm sau:

• ~x: Falsy nếu x == -1 : chúng tôi đã kết thúc dòng.
• x-y: Falsy nếu x == y : chúng tôi nằm trên đường chéo.
• x+y-w: Falsy nếu x + y == w : chúng tôi nằm trên đường chéo.
• x-n: Falsy if x == n : bởi vì thử nghiệm này chỉ được thực hiện khi x == y , điều này có nghĩa là chúng tôi nằm ở trung tâm chính xác của lưới.

và cây quyết định sau:

Bản giới thiệu

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 byte

'\/X 'iEQXytEP+)

Hãy thử trực tuyến!

Hãy xem xét đầu vào 2là một ví dụ. Ngăn xếp được hiển thị ở đây lộn ngược, tức là các yếu tố thấp hơn là những yếu tố được đẩy gần đây nhất.

'\/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, 108 106 byte

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

Hãy thử trực tuyến!

(−2 chơi golf nhờ MD XF)

Nó in hai ký tự (lúc đầu, c = 47là dấu gạch chéo vàc + 45 , là dấu gạch chéo ngược, sau đó chúng được hoán đổi) với chiều rộng trường động.

Độ rộng trường bắt đầu tại 1và 2n, và tại mỗi lần lặp, chiều rộng đầu tiên được tăng thêm 1 và chiều thứ hai được giảm đi 2.

Khi độ rộng trường thứ hai trở thành 0, nó xuất ra 'X'và một dòng mới thay vì các ký tự thông thường và đảo ngược hướng tăng ( i). Một dòng mới được in riêng cho tất cả các dòng khác ( puts("")).

shortC , 111 byte

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

Dựa trên câu trả lời C của tôi . Chuyển đổi:

• R -> printf(
• P -> putchar(
• W -> while(
• O -> for(
• Tự động đóng ");}

Điều này cũng sử dụng mã ASCII cho \và/ .

Hãy thử trực tuyến!

Python 2 , 81 byte

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

Hãy thử trực tuyến!

C, 168 155 150 byte

^{-5 nhờ Computronium}

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

Chắc chắn có thể được chơi golf; Tôi đang làm như vậy. Hãy thử trực tuyến!

Ung dung:

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 byte

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

Hãy thử trực tuyến!

Hexdump:

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

Giải trình:

é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 '\'

Về cơ bản, chúng ta có Chèn X, n lần kéo dài dấu gạch chéo .

Nhưng nó không hoàn toàn đơn giản bởi vì chúng ta cũng phải thêm dấu gạch chéo lần đầu tiên. Nếu các dấu gạch chéo đã có, chúng ta có thể viết các dấu gạch chéo như:

>HÄX2pGÙX2p

Điều này sẽ giúp chúng tôi tiết kiệm 6 byte.

C #, 157 122 120 byte

_=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;}

Phiên bản bị đánh cắp:

 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;
        };

Toán học, 71 byte

(Lấy cảm hứng một phần từ giải pháp 104 byte của Jenny_mathy)

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

Trả về một danh sách các chuỗi.

Giải thích: IdentityMatrix[2#+1]tạo một ma trận có kích thước phù hợp với 1s dọc theo đường chéo và 0s ở nơi khác. Tiếp theo, chúng tôi nhân nó với "\\"(một dấu gạch chéo ngược đã thoát), làm cho nó trở thành một ma trận với các dấu gạch chéo dọc theo đường chéo và 0 ở nơi khác, vì dĩ nhiên 1 lần dấu gạch chéo ngược là dấu gạch chéo ngược và 0 lần dấu gạch chéo ngược là 0. Chúng ta thêm nó vào "/"lần ngược lại hình chữ X Chúng ta sắp hoàn thành, ngoại trừ vẫn còn 0 ở khắp mọi nơi, và ở giữa là "\\" + "/". Chúng tôi sửa chữa hai điều này bằng cách thay thế " "cho 0và "X"cho a_+_, mà phù hợp với bất kỳ tổng của hai vật (như _+_nên, ngoại trừ Mathematica là quá thông minh vì lợi ích riêng của mình và diễn giải rằng khi 2 lần _). Cuối cùng, ""<>#&/@biến điều này thành một danh sách các chuỗi.

Java (OpenJDK 8) , 135 byte

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;}

Biểu thức Lambda lấy và số nguyên và trả về một chuỗi Chuỗi

Hãy thử trực tuyến!

Ung dung:

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 byte

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

Định dạng:

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

Đầu vào là thông qua cột a trong bảng t có tên , theo hướng dẫn của chúng tôi .

Ruby , 66 byte

Hàm đệ quy.

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

Hãy thử trực tuyến!

Giải trình

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)

Thạch , 24 17 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ḥ‘=þ`µḤ+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.

-6 byte nhờ @LeakyNun và -1 byte với một cải tiến bổ sung

Batch, 201 byte

@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: /=/ %

Bắt đầu bằng cách xây dựng dòng trên cùng, sau đó sau khi in từng dòng, di chuyển \bên phải một không gian và /bên trái một lần, đảm bảo rằng chúng tạo một Xkhoảng giữa.

PHP , 115 byte

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;

Hãy thử trực tuyến!

Võng mạc , 74 byte

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

Hãy thử trực tuyến! Giải trình:

.+
$* X

Đặt X.

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

Bắt đầu từ X, làm việc lên trên, đặt một \đường chéo bên trái mỗi lần. Cũng đặt /thêm hai khoảng trống sau /lần trước.

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

Bắt đầu từ X, làm việc hướng xuống dưới, đặt một /đường chéo bên trái mỗi lần. Cũng đặt một\ thêm hai khoảng trống sau /lần trước.

m` (\W)$
$1

Số lượng khoảng trắng giữa hai đường chéo cần phải là số lẻ, vì vậy khoảng trắng cuối cùng trên mỗi dòng (trừ Xdòng gốc ) sẽ bị xóa.

Toán học, 131 byte

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

Toán học, 104 byte

Đây là một cách tiếp cận khác bằng cách sử dụng Grid

(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 byte

Yêu cầu ⎕IO←0mặc định trên nhiều hệ thống.

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

Hãy thử trực tuyến!

' \/'[... ] chỉ số chuỗi với

 ⎕ nhận đầu vào

 2× nhân với hai

 1+ cộng một

 ⍳ hơn nhiều số nguyên

 ∘.=⍨ bảng đẳng thức (tức là ma trận danh tính; đường chéo NW-SE)

 (... ) áp dụng các chức năng ngầm sau trên đó

  ⊢ tranh luận

  + thêm

  2× hai lần

  ⌽ đối số được nhân đôi theo chiều ngang (nghĩa là đường chéo NE-SW)

Bash , 138 byte

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

Hãy thử trực tuyến!

Thực sự lâu, bash nóng '\ và /'

Ít chơi gôn

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

Python 2 , 95 84 byte

-10 byte nhờ @FelipeNardiBatista

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

Hãy thử trực tuyến!

05AB1E , 21 byte

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

Hãy thử trực tuyến!

Perl 5, 110 + 1 = 111 byte

Sử dụng -ncờ.

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

QBIC , 90 byte

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

Làm thế nào sự quái dị này hoạt động, được để lại như một bài tập cho người đọc ...

Đầu ra mẫu:

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

Visual Basic.Net , 454 450 byte

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

không chắc chắn việc tạo một func cho writelinesẽ lưu một số byte nhờ vào Stephen S vì đã chỉ ra as ...việc xóa cũng đã thay đổi integerthành object chỉnh sửa cuối cùng đã thay đổi lần đầu tiên trở lại

05AB1E , 22 byte

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

Hãy thử trực tuyến!

Giải trình

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

Giải pháp thay thế 22 byte

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

Pyke, 14 byte

\XQV.X \   /\/

Hãy thử nó ở đây!

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

bản giới thiệu

Đặt ntrên dòng đầu tiên.

Tôi có thể chơi golf nhiều hơn bằng cách sử dụng phương pháp đệ quy

R , 75 72 byte

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

Lấy cảm hứng từ câu trả lời này , tạo ra một ma trận ẩn và viết nó vào thiết bị xuất chuẩn; đọc kích thước từ stdin. Nó phải xây dựng một ma trận các ký tự sep=''khoảng trắng và sử dụng b / c nếu không nó có vấn đề về khoảng cách.

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

Hãy thử trực tuyến!