[Question]
  [
Given a non-negative integer, print out an `X` that is that big. `X` is the output for input `0`, and you will add slashes equal to the input in each direction to extend the `X` for larger inputs.
# Test Cases
0
```
X
```
1
```
\ /
 X
/ \
```
2
```
\   /
 \ /
  X
 / \
/   \
```
...
10
```
\                   /
 \                 /
  \               /
   \             /
    \           /
     \         /
      \       /
       \     /
        \   /
         \ /
          X
         / \
        /   \
       /     \
      /       \
     /         \
    /           \
   /             \
  /               \
 /                 \
/                   \
```
# Rules
You may either print the output, or return a string or list of string from a function. A trailing newline, as well as extra interior whitespace that does not affect appear, is allowed.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins!
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 6 bytes
```
ＰX⁺¹ＮX
```
Your nonsense ain't stopping me ;)
[Try it online!](https://tio.run/##S85ILErOT8z5///9ng0Rjxp3Hdr5fs@6iP//DQE "Charcoal – Try It Online")
[Answer]
## JavaScript (ES6), 79 bytes
Uses a recursive function **g** that walks through a grid and builds the output character by character.
```
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)
```
### How?
Both variables **x** and **y** iterate from **2n** to **-1**, where **n** is the input.
For each position **(x, y)** in the grid, we pick one of these characters:
* 0: `/`
* 1: `\`
* 2: space
* 3: `X`
* 4: newline
using the following tests:
* `~x`: Falsy if **x == -1**: we've reached an end of line.
* `x-y`: Falsy if **x == y**: we're located on the anti-diagonal.
* `x+y-w`: Falsy if **x + y == w**: we're located on the diagonal.
* `x-n`: Falsy if **x == n**: because this test is only performed when **x == y**, this means that we're located in the exact center of the grid.
and the following decision tree:
[![decision tree](https://i.stack.imgur.com/GOOvy.png)](https://i.stack.imgur.com/GOOvy.png)
### Demo
```
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))
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 16 bytes
```
'\/X 'iEQXytEP+)
```
[Try it online!](https://tio.run/##y00syfn/Xz1GP0JBPdM1MKKyxDVAW/P/fyMA "MATL – Try It Online")
Consider input `2` as an example. The stack is shown here upside down, i.e. lower elements are the ones most recently pushed.
```
'\/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
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 3 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
╵＼┼
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXUyNTc1JXVGRjNDJXUyNTND,i=Mw__,v=2)
half of the size of the Charcoal answer :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`
```
[Answer]
# C, ~~108~~ ~~106~~ 104 bytes
```
a;g(n){for(int b=2*n,i=1,c=47;a+=i;!b?i=-i,c=92:puts(""),b-=2*i)printf("%*c%*c",a,b?c^115:88,b,b?c:10);}
```
[Try it online!](https://tio.run/##FY3BCsIwEER/RQPCbt2AqRbbhNA/EZKFhj0YS21PxW@PKcxlHm8Y1om5lOASZNynzwKS11P0bZNJvCH2j6cLVy/uHEfxWioZWjtv6xeUQoq6qoLzUmcTqEvDNYoCxZFfxnS27ykexZobul95B8mAe4IO6@X9QH8 "C (gcc) – Try It Online")
(−2 golfing thanks to MD XF)
(−1 golfing thanks to ceilingcat)
It prints two characters (at first, `c = 47`, which is a slash, and `c + 45`, which is a backslash; then they are swapped) with a dynamic field width.
The field widths start at `1` and `2n`, and at each iteration, the first width is incremented by 1, and the second one is decremented by 2.
When the second field width becomes 0, it outputs `'X'` and a newline instead of the regular characters, and reverses the direction of increments (`i`). A newline is printed for all other lines separately (`puts("")`).
[Answer]
# [shortC](https://github.com/aaronryank/shortC), 111 bytes
```
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
```
Based on [my C answer](https://codegolf.stackexchange.com/a/125419/61563). Conversions:
* `R` -> `printf(`
* `P` -> `putchar(`
* `W` -> `while(`
* `O` -> `for(`
* Auto-inserted closing `");}`
This also uses ASCII codes for `\` and `/`.
[Try it online!](https://tio.run/##K87ILypJ/p@bmJmnoVnNlaZhaKBpzVX7v1ijQrM6vEJXVzNISUFJszbLOg0k4m@dZVNhnaWtrVmskaWpE2BppKlTrKFRoZulqWWka6ipE6SkH5OnpGkN0m8dpBQB5oRnAc2BaDAxx9AQExOT9/8/AA "shortC – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 81 bytes
```
r=range(2*input()+1)
for i in r:print''.join(' \/X'[i==j::2][r[~i]==j]for j in r)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v8i2KDEvPVXDSCszr6C0RENT21CTKy2/SCFTITNPociqoCgzr0RdXS8rPzNPQ10hRj9CPTrT1jbLysooNrooui4zFsiJBWnIAmvQ/P/fCAA "Python 2 – Try It Online")
[Answer]
# C, ~~168~~ ~~155~~ 150 bytes
-5 thanks to 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");}
```
Can certainly be golfed; I'm doing so. [Try it online!](https://tio.run/##bYxBDsIgEEX3nILUzYwtqXU7PYgLNgZBIYqkmEjScHakGHcu/8x7T4mrUqXsLtpYr3ngYbH@ZViEhOv7Zu8akhAYoOMdUnZktod5LkBuTuT6HiM4HCogZYdDhMo73B/F1I6j9NXbalTXqa1v1tXsTx3/mFI2OJfH2XrAlRmYDkgslw8)
Ungolfed:
```
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");
    }
}
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), 21 bytes
```
éXÀñ>HÄÒ r\Á/YGpr/$r\
```
[Try it online!](https://tio.run/##K/v///DKiMMNhzfaeRxuOTxJoSjmcKN@pHtBkb5KUcz///9NAQ "V – Try It Online")
Hexdump:
```
00000000: e958 c0f1 3e48 c4d2 2072 5cc1 2f59 4770  .X..>H.. r\./YGp
00000010: 722f 2472 5c                             r/$r\
```
Explanation:
```
é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 '\'
```
Essentially, we have *Insert an X, n times extend the slashes*.
But it's not quite that simple because we also have to add the slashes the first time. If the slashes were already there, we could write *extend the slashes* as:
```
>HÄX2pGÙX2p
```
Which would save us 6 bytes.
[Answer]
# C#, 157 122 120 bytes
```
_=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;}
```
Ungolfed version: 
```
 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;
        };
```
[Answer]
## Mathematica, 71 bytes
*(Partially inspired by Jenny\_mathy's 104-byte solution)*
```
""<>#&/@(#"\\"+Reverse@#"/"&@IdentityMatrix[2#+1]/.{0->" ",a_+_->"X"})&
```
Returns a list of strings.
Explanation: `IdentityMatrix[2#+1]` makes a matrix of the right size with 1s along the diagonal and 0s elsewhere. Next, we multiply it by `"\\"` (an escaped backslash), which makes it a matrix with backslashes along the diagonal and 0s elsewhere, since of course 1 times backslash is backslash and 0 times backslash is 0. We add this to `"/"` times its reverse to make the X shape. We're nearly done, except there are still 0s everywhere, and the middle is `"\\" + "/"`. We fix these two things by substituting `" "` for `0` and `"X"` for `a_+_`, which matches any sum of two things (like `_+_` should, except Mathematica is too clever for its own good and interprets that as 2 times `_`). Finally, `""<>#&/@` turns this into a list of strings.
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 135 bytes
```
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;}
```
Lambda expression that takes and integer and returns an array of Strings
[Try it online!](https://tio.run/##NY89b4MwEIZn8itOnqCAm7QbjsNWqUOnLJUSBpcY5I8YhE2qKOK300MNy3089753Oi1uIu966fTFzP34Y1UNtRXew5dQ7rGJnswHETDdOnWBK07iYxiUa08ViKH1CQojjavoGJSlzejqoDpHP57F/tMF2cohg9V2gAY4zCo/PJQLYPg205nlby8q3bFV5LmTv6vFVqzphpiZvWUmTZOl8SdTcUIyzbdMI9fIF5ZyzbkpMaiSfJOCnM@kwM7mu9yU5BUJEDbIMA4OPJvmKGL4wbLy/xp4KKChou/tPX5PEjjefZBX2o2B9igI1sU@Qc@0meY/ "Java (OpenJDK 8) – Try It Online")
Ungolfed:
```
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;
}
```
[Answer]
# T-SQL, 201 bytes
```
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
```
Formatted:
```
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
```
Input is via column **a** in named table **t**, [per our guidelines](https://codegolf.meta.stackexchange.com/a/5341/70172).
[Answer]
# [Ruby](https://www.ruby-lang.org/), 66 bytes
Recursive function.
```
f=->x{?X[x]||"\\#{s=' '*(2*x-1)}/
#{f[x-1].gsub /^/,' '}
/#{s}\\"}
```
[Try it online!](https://tio.run/##KypNqvz/P81W166i2j4iuiK2pkYpJka5uthWXUFdS8NIq0LXULNWn0u5Oi0ayIzVSy8uTVLQj9PXAcrXcukDVdbGxCjV/i8oLSlWSItOTy0p1ivJj8@M/W9oAAA "Ruby – Try It Online")
### Explanation
```
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)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~24~~ 17 bytes
```
Ḥ‘=þ`µḤ+Uị“/\x ”Y
```
[Try it online!](https://tio.run/##y0rNyan8///hjiWPGmbYHt6XcGgrkK0d@nB396OGOfoxFQqPGuZG/v//3xQA "Jelly – Try It Online")
**How it Works**
```
Ḥ‘=þ`µḤ+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 bytes thanks to @LeakyNun* and *-1 byte with an additional improvement*
[Answer]
# [///](https://esolangs.org/wiki////), 223 bytes
```
/|/\\\\//i///& /  &// &///> /^b|b^v|v^^$|+^
f|fvv&i|||^$|-^^$|-^$|+^^<|$^<-|$>|->vv&i||||
^^<-|$^<|$^^f|f| ^ f|f^^>|->| ^ >|->^^f|fv|v^||||^^>|->v|v^|||^^^v|v  ^ b|b^>//^/\///b\/>/b\/\/$|+\/\/\/<|$\/\///>$+//>i$+
iX/<$//
<$
```
[Try it online!](https://tio.run/##LU5BCsMwDLvnFT6YXErRB0LesUMQrLDSwG6FnPz3zM4asIQiGfn@vu/rc88JQ/MHdABZIJKBGFQBDzs4bJBqG9Np5xi5m5nrnQvCYDFl2U2r7fVJWOL6Wh5904TiREYoRPByoiA2/tajyCgWz8UNFSD8SBwNNaDBi4MavKAtr@rm0HVL/YWiQCo65w8 "/// – Try It Online")
Seems like a fitting language for the challenge. (suck it, sed)
Input is given in unary spaces, after `/i/`:
```
/|/\\\\//i/<spaces here>//& /  &// &///...
```
Explanation:
don't ask me, I only programmed it ;)
[sorta commented version, lightly ungolfed version](https://tio.run/##VVTbbtswDH3PVxBp0IsbR@9DYPRl@4ENRYFpBmSLroXYkiHJdrOf70gp6do8KBTvPDp0GFToMby/iz@b3yIdRhT5JwQcSzB2miOdMFvlz7Ca2IMKEb0Jp0B6EpUG10GYVIsBgoOzm6FVFlQbZzUMZwiIEHscIVe4LajELaXX8zSYVkXMVbKVLQLC3ERPCcBZinXwivESDc/PMCpqaFI@8iX2hspGugXqDCrufQ8eJ1TR2Ndsp@tA/Y1oI/RuxQU9ZbFniGbEFJdaOMCvHr84U2zrNPevIkzeWKpCs0A7e892NbqZ/ggA7WLYs82CiTDOkQYLLA7mhKmLbwDww/gQ4T4h/ABlBT@xdVZDcZ8UGNsDfFdtT1EW9ymTWzDXZBU4bt2xTVGYxgG5jMr4Q@fdmHxHo/WAB6CBaATVddgyPsMAjsz@gg9qmm4ySI3Tw3GcxbcMepqV7AxubzoWv5b@4h1X05Ke28/PVBUC6kbKpl6kXGqod1I@1raSslqWWyPTrwbSltlYZg@oj1Lu6mNJJzmXn7yltMD2MjnwATXnk7KoCxbyvfxQlKSB7JOauKa5@n1S1qTja0GRqWuoeAyehCh2IQRRQXlPz5zXIOTlIXBpHRiOMyj/wR69pzewZjR/mYQYWjWRcICgRszxFld@UcLeWdqSznkYnDuFDGAtZBas2GTii2tHjPyqzukFtumdKPMWVud5JRMZoueq26ebLfxnv8518e0A2xDnruPNSvFw87S9cHdLYnp08m17imlUe2JHTnbIdLKIOrCuV9NEMRfudInbn7dHOwz2jr8fHWERkcakEae8Zo2LkdhKq8PBL1yUBXzjvWeYEimZsqy@S43e8abHlDxc0c485jZX5XW4Pxmr1UMGr5Gi4gOkYHpJkUQmj7zgW5nN7nFjXjbHHX0GF7kIIkBDaPPJV1iWtK3/AA)
I didn't save the pregolfed code, and I don't understand it enough anymore to take it apart again (or maybe just laziness, who knows)
[Answer]
## Batch, 201 bytes
```
@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: /=/ %
```
Starts by building up the top line, then after printing each line, moves the `\` right one space and the `/` left once space, making sure that they make an `X` in the middle.
[Answer]
# [PHP](https://php.net/), 115 bytes
```
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;
```
[Try it online!](https://tio.run/##JcxLDoIwFEbhuavAm38AtsXA0HLDNkwoMVCRdkIb7NYd19fwy0lOdDF3fXTxgGlfN6aWdH6EvdTwHSw3oj39isbcX5AGeNWMTMZQffzSKviPzyQRaiYks1GFxM@03@J0L6m40oCZ/3sW8EKMElZSQbKt9GJdQNA5v7ag7GTd8gY "PHP – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), 74 bytes
```
.+
$* X
+`^ ( *).( *)
$1\  $2/¶$&
+`¶ ( *).( *).?$
$&¶$1/  $2\
m` (\W)$
$1
```
[Try it online!](https://tio.run/##K0otycxL/P9fT5tLRUshgks7IU5BQ0FLUw9EcKkYxigoqBjpH9qmogaUOrQNIadnr8KlogaUMNQHKYnhyk1Q0IgJ1wSKGv7/b2gAAA "Retina – Try It Online") Explanation:
```
.+
$* X
```
Place the `X`.
```
+`^ ( *).( *)
$1\  $2/¶$&
```
Starting at the `X`, working upwards, place a `\` diagonally to the left each time. Also place a `/` two more spaces after the `/` than last time.
```
+`¶ ( *).( *).?$
$&¶$1/  $2\
```
Starting at the `X`, working downwards, place a `/` diagonally to the left each time. Also place a `\` two more spaces after the `/` than last time.
```
m` (\W)$
$1
```
The number of spaces between the two diagonals needs to be odd, so the last space on each line (except the original `X` line) is deleted.
[Answer]
# Mathematica, 131 bytes
```
(F[x_,y_]:=Table[x<>StringJoin@Table[" ",i]<>y,{i,1,#*2,2}];Column[Join[Reverse@F["\\","/"],{"X"},F["/","\\"]],Alignment->Center])&
```
  
# Mathematica, 104 bytes
here is another approach using Grid 
```
(S=DiagonalMatrix[Table["\\",r=2#+1]];Table[S[[r+1-i,0+i]]="/",{i,r}];S[[#+1,#+1]]="X";Grid@S/. 0->" ")&
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 138 bytes
```
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 /\\
```
[Try it online!](https://tio.run/##LYxBDoIwFET3nGJCSqoQUn@XavQaJrRJK5bQTVHKTjx7LcbVvMmbzN3GMaVhmuHhA0x0LzA6/aJj1JJGSyBTvHO3TaOL5@zDMqCs6r6qowoljOvHCRyc@W10YXSlo9SZd/nB72upN9nZ89@Y4rNG9wCPQkpxE3xdZpCEUCqlRIcv "Bash – Try It Online")
Really long, bash heates '\ and /'
Less golfed
```
 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 /\\
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~95~~ 84 bytes
*-10 bytes thanks to @FelipeNardiBatista*
```
f=lambda s,i='\n':i+(s and'\\'+'  '*~-s+' /'+f(s-1,i+' ')+i+'/'+'  '*~-s+' \\'or'X')
```
[Try it online!](https://tio.run/##VYqxCoAgAAV/xe1pKlJtgf/R4GKIJJSKurT06@badHdw@WlnikvvXl/2PpwlVQQNE7EFTiux0cEYcBCC6ZV1iAL3tMpZhBFgfED9hvGngh2s5xJio56ujPUP "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 21 bytes
```
F'\Nú}'X¹ú).B€.∞ø€.∞»
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fTT3G7/CuWvWIQzsP79LUc3rUtEbvUce8wzugjEO7//83NAAA "05AB1E – Try It Online")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 25 bytes
Requires `⎕IO←0` which is default on many systems.
```
' \/X'[(⊢+2×⌽)∘.=⍨⍳1+2×⎕]
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkGXI862iP@qyvE6EeoR2s86lqkbXR4@qOevZqPOmbo2T7qXfGod7MhWKxvaux/oOL/EVwGXBFchkBsBKINAA "APL (Dyalog Unicode) – Try It Online")
`' \/X'[`…`]` index the string with
 `⎕` get input
 `2×` multiply by two
 `1+` add one
 `⍳` that many integers
 `∘.=⍨` equality table (i.e. identity matrix; NW-SE diagonal)
 `(`…`)` apply the following tacit function on that
  `⊢` the argument
  `+` plus
  `2×` two times
  `⌽` the horizontally mirrored argument (i.e. NE-SW diagonal)
[Answer]
# Perl 5, 110 + 1 = 111 bytes
Uses `-n` flag.
```
$x=$_;$,="\n";push@x,$"x($x-$_)."\\".$"x(2*--$_+1)."/"while$_>0;say@x,$"x$x."x";for(reverse@x){y!\\/!/\\!;say}
```
[Answer]
# [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 90 bytes
```
~b=0|?@X`\[0,:-1|X=space$(a)┘Z=Z+X+@\`+space$((b-a)*2-1)+@/`+X+@┘`]Z=Z+space$(b)+A+_fZ
```
How this monstrosity works, is left as an excercise for the reader...
Sample output:
```
Command line: 3
\     /
 \   / 
  \ /  
   X
  / \  
 /   \ 
/     \
```
[Answer]
## [Visual Basic.Net](https://msdn.microsoft.com/en-us/library/aa903378(v=vs.71).aspx), ~~454~~ 450 Bytes
```
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
```
not sure whether making a func for `writeline` will save some bytes
thanks to Stephen S for pointing at `as ...` removal
also changed `integer` into `object`
last edit changed the first one back
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 22 bytes
```
F'\IN-úR.∞})Âí'Xs)˜.c»
```
[Try it online!](https://tio.run/##ASgA1/8wNWFiMWX//0YnXElOLcO6Ui7iiJ59KcOCw60nWHMpy5wuY8K7//8z "05AB1E – Try It Online")
**Explanation**
```
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
```
Alternative 22 byte solution
```
F'\N·>ú'/ì})Âí'X¸«ì.c»
```
[Answer]
## Pyke, 14 bytes
```
\XQV.X \   /\/
```
[Try it here!](http://pyke.catbus.co.uk/?code=%5CXQV.X+%5C+++%2F%5C%2F&input=3)
```
\X             - "X"
  QV           - repeat input times:
    .X \   /\/ -  surround(^, all=" ", 
                              tl="\", 
                              left=" ",  
                              right=" ",  
                              lower=" ",  
                              tr="/",  
                              br="\",  
                              bl="/")
```
[Answer]
# 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 / \\
```
## [demo](http://rextester.com/NKOT69701)
Set `n` on the first line.
May be I can golf it more using a recursive approach
]