[Question]
  [
# Problem
Inspired by a [previous challenge](https://codegolf.stackexchange.com/questions/125383/draw-a-big-slash-x) doing something similar
Given positive integer input `n` output a shape that follows this pattern:
input `n=1`:
```
* *
 *
* *
```
input `n=2`:
```
**  **
 ****
  **
 ****
**  **
```
input `n=3`:
```
***   ***
 *** ***
  *****
   ***
  *****
 *** ***
***   ***
```
and so on...
It has these properties:
`n*2+1` lines tall
the "arms" are `n` wide except when they merge
the center line is `n` wide
if `n` is even the lines above and below the center are `n*2` wide
if `n` is odd the lines above and below the center are `n*2-1` wide
# Rules
* Trailing newlines accepted
* Standard loopholes apply
* **Shortest bytes win**
* Output may be print out or a string or array of strings
# Edits
* `n=0` doesn't need to be handled
* Trailing spaces allowed
  
[Answer]
# [MATL](https://github.com/lmendo/MATL), 16 bytes
```
EQXyG:Y+tP+g42*c
```
[**Try it online!**](https://tio.run/##y00syfn/3zUwotLdKlK7JEA73cRIK/n/f3MA)
### Explanation
Consider input `2` as an example. Stack contents are shown with more recent ones below.
```
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: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~13~~ 12 [bytes](https://github.com/somebody1234/Charcoal/wiki/Code-page)
Thanks to @ErikTheOutgolfer for a byte
```
ＦＮ«ＰX⁺*×*Ｉθ→
```
[Try it online!](https://tio.run/##ASgA1/9jaGFyY29hbP//77ym77yuwqvvvLBY4oG6KsOXKu@8qc644oaS//8y "Charcoal – Try It Online")
This is my first ever Charcoal answer, and I'm pretty sure it's not golfed as well as it could be, but I figured I'd start somewhere.
```
 ＦＮ«            # For input() (i in range(0,input()))
     Ｐ           # Print
       X          # In an 'X' shape
        ⁺*×*Ｉθ   # '*'+'*'*int(first_input)
               →  # Move the cursor right one
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
Ḥ‘Ḷ⁶ẋ;€”*ẋ$»Ṛ$Y
```
[Try it online!](https://tio.run/##AS0A0v9qZWxsef//4bik4oCY4bi24oG24bqLO@KCrOKAnSrhuoskwrvhuZokWf///zM "Jelly – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 18 bytes
```
Å4bS{I·ƒDÂ~„ *èJ,À
```
[Try it online!](https://tio.run/##ASUA2v8wNWFiMWX//8OFNGJTe0nCt8aSRMOCfuKAniAqw6hKLMOA//8z "05AB1E – Try It Online")
**Explanation**
Example for `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
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~18~~ 17 bytes
Saved a byte thanks to @DJMcMayhem's input trick.
```
Àé*ÄJÀälÀñ2ÙÀl2x>
```
[Try it online!](https://tio.run/##K/v//3DD4ZVah1u8gPSSHCCx0ejwzMMNOUYVdv///7cEAA "V – Try It Online")
Explanation
```
Àé*ÄJÀäl
```
This inserts `[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
```
Each iteration of the loop the buffer goes from
```
|**   ***
```
To
```
***   ***
 |** ***
***   ***
```
Where `|` is the cursor with a `*` under it
[Answer]
# [V](https://github.com/DJMcMayhem/V), 23 bytes
```
Àé*ÄJÀälÀñÙãlxx>ñyHæGVp
```
[Try it online!](https://tio.run/##K/v//3DD4ZVah1u8gPSSHCCx8fDMw4tzKirsDm@s9Di8zD2s4P///xYA "V – Try It Online")
Hexdump:
```
00000000: c0e9 2ac4 4ac0 e46c c0f1 d9e3 6c78 783e  ..*.J..l....lxx>
00000010: f179 48e6 4756 70                        .yH.GVp
```
For whatever reason, this challenge is significantly harder in V than the last one. Since our general approach of *n times, grow an 'x'* won't work here, we'll instead construct the top of the X, copy it and flip it, then attaching the two parts together.
Explanation:
```
Àé*Ä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.
```
Doing the indent at the *end* of the loop, allows us to [take advantage of implicit endings](https://codegolf.stackexchange.com/a/124600/31716). This also conveniently creates *n+1* lines, which is exactly the top half of the 'X'. Let's say the input was 4. Then at this point, the buffer looks like this:
```
****    ****
 ****  ****
  ********
   ******
    ****
```
And we're on the last line. So then we:
```
                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
```
[Answer]
# C#, 139 130 115 bytes
-1 byte by creating a string and calling `WriteLine`, thus saving the check for the new line.  
-6 bytes thanks to Kevin and his master golfing techniques!  
-2 bytes by replacing `n*3-n` with `n*2`.  
-15 bytes after Kevin kindly pointed me in the right direction: I can just return the string instead of printing it, thus saving the call to `System.Console.WriteLine()`. And some other tips also...
```
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;}
```
[Try it online!](https://tio.run/##jc5NS8NAEAbge37FkEPzsUmxDYK42XgQvIggeuhBPSzbTZilnYXdbaHU/PaYaE@CmPc487zDKF8q6/SgdtJ7eHa2c3IP5wjG@CADKjha3MKTREp9cEjd2wdI1/nsoqa8nnzQ@@XDgVSNFIof2EALAgYSzfkoHXgRx7y1Lh0FYGHEFTe1oHzNDWOFZyJ@pzj7BuMKa8orno1jbIRZYG0YfeLkq9KUqwUy1kzl0twleXKbQMKdDgdH4Hk/8Oj3b/eWvN3p5cZh0GmbrrKM/2fWM0w1w1zPMDeT@Qu9aLl91Kf0cqaP@uEL)
Ungolfed:
```
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();
    }
}
```
It just iterates along the rows and columns of the space needed to print the big X and prints either a `'*'` or a `' '` depending on the condition.
[Answer]
# [Haskell](https://www.haskell.org/), 88 87 86 bytes
-1 thanks to @Laikoni
```
(!)=replicate
x n=[zipWith max(reverse m)m|m<-[i!' '++n!'*'++(n*2-i)!' '|i<-[0..n*2]]]
```
[Try it online!](https://tio.run/##FcmxCsMgEIDhvU9xTmpCQmnX@gbplKFDkCLlIEc9EWODlLy7tdMP37@67Y3e16qENgmjp5fLeCoQzPKl@KC8AruiEu6YNgTWfPBtWEhIkH0fhOxaVOguA@m/HdTueRybWGsrOwqGXbw/IX7ynNMUQBW46voD "Haskell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~24~~ ~~23~~ 16 bytes
```
Ḥ‘Ḷ⁸+þṬ+Ṛ$a”*o⁶Y
```
[Try it online!](https://tio.run/##ASwA0/9qZWxsef//4bik4oCY4bi24oG4K8O@4bmsK@G5miRh4oCdKm/igbZZ////Mw "Jelly – Try It Online")
[Answer]
# MATLAB, 153 126 bytes (17.6%↓)
Thanks to @LuisMendo's comment, function `disp()` can output chars without single quotes, thus I could prevent using `fprintf` with `formats` and omit a few bytes. Besides, his comment reminds me that I need use `char(32)` to present a space rather than `char(0)` (null). 
```
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 ''])
```
[Try it online!](https://www.jdoodle.com/a/3Np)
### MATLAB, 153 bytes
```
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)')
```
Result example:
 n=10
```
**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~93~~ ~~90~~ ~~89~~ 83 bytes
-3 bytes thanks to Leaky Nun  
-1 byte thanks to Zachary T  
-6 bytes thanks to xnor
```
n=input()
x=n*'*'+n*'  '
exec"print`map(max,x,x[::-1])`[2::5];x=' '+x[:-1];"*(n-~n)
```
[Try it online!][TIO-j3xwsktf]
Starts with a string like `'*** '` for `n=3`, applying `map/max` to pick the `*` over the spaces for each position, then append a space and remove the last character from the string and do this all again.
[Answer]
# [Haskell](https://www.haskell.org/), 70 bytes
```
f n=[[last$' ':['*'|y<-[1..n],(c-n-y)^2==r^2]|c<-[1..3*n]]|r<-[-n..n]]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00hzzY6OiexuERFXUHdKlpdS72m0kY32lBPLy9WRyNZN0@3UjPOyNa2KM4otiYZImOslRcbW1ME5OjmgdTF/s9NzMxTsFXITSzwVSgoLQkuKfLJU1BRSFMw/Q8A "Haskell – Try It Online")
Outputs a list of strings.
For each position of row `r`, column `c`, uses a formula to determine whether it falls in one of the two diagonal bands and so is `*`.
[Answer]
# Javascript (ES2017), ~~155~~ 157 bytes
```
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)]
```
Returns an array of strings. I perform operations on arrays then mirror it. This could probably be optimized with matrices like the other answers, but I wanted to be unique.
Edit: As pointed out by Neil, for even values of `n`, the center line was not `n` wide, so I added a modulus to detect even/odd when slicing the column.
```
n=5
['*****     *****',
 ' *****   ***** ',
 '  ***** *****  ',
 '   *********   ',
 '    *******    ',
 '     *****     ',
 '    *******    ',
 '   *********   ',
 '  ***** *****  ',
 ' *****   ***** ',
 '*****     *****']
```
**Ungolfed**
```
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
}
```
**Quadrant**
```
n=5
   *****
  ***** 
 *****  
*****   
****    
***     
```
**Mirrored Horizontally**
```
n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     
```
**Mirrored Vertically**
```
n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     
    *******    
   *********   
  ***** *****  
 *****   ***** 
*****     *****
```
[Answer]
# Java 10, ~~119~~ ~~118~~ 111 bytes
```
n->{var r="";for(int i=0,j;i<n-~n;i++,r+="\n")for(j=0;j<n*3;r+=j>=i&j<i+n|j<n*3-i&++j>n*2-i?"*":" ");return r;}
```
Port from [*@CarlosAlejo*'s amazing C# answer](https://codegolf.stackexchange.com/a/126277/52210), after I helped him golf a few things. **So make sure to upvote him as well!**  
-4 bytes thanks to *@ceilingcat*.
[Try it here.](https://tio.run/##RY/BasMwDIbvewrhQ4njJnQb7DDF6RO0lx23Hbw0HfJSpThOYHTZq2dqUhjIAv@S4Pu8G1zmD19T1biug50jvtwBEMc6HF1Vw/76BXiJgfgTqkQmwBolHOVJddFFqmAPDBYmzsrL4AIEqxQe2zDvk92sPVLB2S8jGbMOxqo3Vvq64O0GfcHpI0rqS0srX5DhnznLaGWMLzl9yGirUvWsQGkMdewDQ8BxwgXi3H80AnFjGVo6wElUkgX79R2cXjz@ke4RqHiSZoyeRyL53cX6lLd9zM9yFxtOOBdlffMdpz8)
[Answer]
# Mathematica, 148 bytes
```
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])&
```
[Answer]
## R, 102 bytes
Code:
```
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)
```
Test:
```
> 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
**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********
```
[Answer]
## CJam, 24 bytes
```
{:T2*){S*T'**+}%_W%..e>}
```
This is a block that takes a number from the stack and outputs a list of lines to the stack.
### Explanation:
```
{                        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
```
[Answer]
# **Python 2**, 110 bytes
```
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)
```
This program breaks each line into 4 parts, first spaces, first stars, second spaces and then second stars. For each horizontal line of the X it calculates how many stars or spaces are needed for each of the 4 sections of the line, then constructs and prints that string.
[Answer]
# [Retina](https://github.com/m-ender/retina), 144 bytes
```
.+
 $&$* $&$* $&
 
$`#$'¶
¶\d+$
( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1
( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3
+` (# +#)
$1 
+` #...
#
##
```
[Try it online!](https://tio.run/##NYwxCgMxDAT7fYVgl@RsgeHsPMfFBZIiTYqQt90D7mOOzJFCIwZG@jy/r/d9jOIwXZT/gEEbdT12HHt/uIDFcuLEEp6gVU05q3Juo@rpa4QeTQ7MmOZMvfXamzmiqXF5i4kevtkZxDubxlIKCBJjtB8 "Retina – Try It Online") Explanation:
```
.+
 $&$* $&$* $&
```
Add 2n+1 spaces before the input value (one for each output line).
```
$`#$'¶
```
Replace each space with a `#` and collect the results. This gives a diagonal line of `#`s, space padded on both sides, with the input value suffixed.
```
¶\d+$
```
Delete the original input value, as we now have a copy on each line.
```
( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1
```
Build up two diagonal lines of n `*`s, with a separator column of `n` spaces wrapped in a pair of `#`s.
```
( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3
```
On those lines where the `*`s are nearer the middle, swap the two halves around. This gives an appearance resembling `> | | <`.
```
+` (# +#)
$1 
```
Move the `| |`s as far left as they will go, giving a sort of `>> > <` appearance.
```
+` #...
#
```
For each space between the `#`s, delete the three following characters. This joins the `> <` into an `X`.
```
##
```
Delete the now unnecessary `#`s.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 16 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ENI>1})¦'*…×82SΛ
```
[Try it online.](https://tio.run/##yy9OTMpM/f/f1c/TzrBW89Ayda1HDcsOT7cwCj43@/9/YwA)
**Explanation:**
```
E      # Loop N in the range [1, (implicit) input]:
 N     #  Push loop-index N
  I>   #  Push the input, and increase it by 1
    1  #  Push 1
})     # After the loop: wrap all values on the stack into a list
  ¦    # And remove the very first 1
'*    '# Push "*"
…×82S  # Push "×82" as list: ["×",8,2]
Λ      # Use the Canvas builtin with these three arguments
       # (after which it is output implicitly)
```
*Canvas explanation:*
The Canvas builtin takes three arguments:  
1. The lengths of the lines to 'draw', which in this case is the list we generate at the start with the loop. For an input \$n=3\$, the list will look like this: \$[4,1,2,4,1,3,4,1]\$ (or more in general: for sequence \$x\_n\$ in \$[2,n]\$, the list will be \$[n+1,1,x\_1,n+1,1,x\_2,n+1,1,x\_3,...]\$).  
2. The string to 'draw', which in this case is `"*"`.  
3. The directions, which in this case is `["×",8,2]`. These will be the directions `[cross, reset-to-origin, →]`.
With these arguments, it will draw as follows (let's take the \$n=3\$ as example again):
```
Draw an X-shaped cross of character "*" with arms of length 4:
*     *
 *   *
  * *
   *
  * *
 *   *
*     *
Reset back to the origin (8), and draw 2-1 characters "*" in direction 2 (→):
(NOTE: The origin is the center of this first cross.)
*     *
 *   *
  * *
   **
  * *
 *   *
*     *
Draw an X-shaped cross of character "*" with arms of length 4 again:
**    **
 **  **
  ****
   **
  ****
 **  **
**    **
Reset back to the origin (8), and draw 3-1 characters "*" in direction 2 (→):
**    **
 **  **
  ****
   ***
  ****
 **  **
**    **
Draw an X-shaped cross of character "*" with arms of length 4 again:
***   ***
 *** ***
  *****
   ***
  *****
 *** ***
***   ***
```
[See this 05AB1E tip of mine for a more in-depth explanation of the Canvas builtin.](https://codegolf.stackexchange.com/a/175520/52210)
]