Draw a big ASCII X

Question

Problem

Inspired by a previous challenge 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 1

MATL, 16 bytes

EQXyG:Y+tP+g42*c

Try it online!

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 2

Charcoal, 13 12 bytes

Thanks to @ErikTheOutgolfer for a byte

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

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 3

Jelly, 15 bytes

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

Try it online!

Answer 4

05AB1E, 18 bytes

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

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 5

V, 18 17 bytes

Saved a byte thanks to @DJMcMayhem's input trick.

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

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 6

V, 23 bytes

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

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. 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 7

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!

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 8

Haskell, 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!

Answer 9

Jelly, 24 23 16 bytes

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

Try it online!

Answer 10

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!

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 11

Python 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 12

Haskell, 70 bytes

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

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 13

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 14

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, after I helped him golf a few things. So make sure to upvote him as well!
-4 bytes thanks to @ceilingcat.

Try it here.

Answer 15

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 16

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 17

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 18

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 19

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! 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 20

05AB1E, 16 bytes

ENI>1})¦'*…×82SΛ

Try it online.

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.