[Question]
  [
I was expecting to post something more complex as my first puzzle in PCG, but a particular, uh... [homework question on Stack Overflow](https://stackoverflow.com/q/26623488/1461424) inspired me to post this. They want to:
> 
> print the following pattern for any given word that contains **odd** number of letters:
> 
> 
> 
> ```
> P           M
>   R       A   
>     O   R    
>       G       
>     O   R      
>   R       A   
> P           M 
> 
> ```
> 
> [c++](/questions/tagged/c%2b%2b "show questions tagged 'c++'")
> 
> 
> 
---
> 
> Notice that letters are a knight's move apart in the pattern you need to print. So, every other column is empty. -- (Thanks [xnor](https://codegolf.stackexchange.com/users/20260/xnor) for pointing this out.)
> 
> 
> 
## Rules
1. Using C++ is prohibited. As I may link this question there.
2. You may use `stdout`, or any means of quickly outputting a string (e.g. `alert()` in JavaScript).
3. As always, shortest code wins.
  
[Answer]
## APL (~~37~~ ~~35~~ ~~34~~ 27)
```
↑{∊2↑¨⍵↑¨I}¨↓(+∨⌽)∘.=⍨⍳⍴I←⍞
```
It takes input from the keyboard, like so:
```
      ↑{∊2↑¨⍵↑¨I}¨↓(+∨⌽)∘.=⍨⍳⍴I←⍞
CODE-GOLF
C               F 
  O           L   
    D       O     
      E   G       
        -         
      E   G       
    D       O     
  O           L   
C               F 
```
[Answer]
# Python 2 - ~~94 90 89~~ 88
```
s=input()
L=len(s)
R=range(L)
for i in R:print" ".join([s[j]," "][j!=i!=L+~j]for j in R)
```
**Input:**
```
"CODE-GOLF"
```
**Output:**
```
C               F
  O           L  
    D       O    
      E   G      
        -        
      E   G      
    D       O    
  O           L  
C               F
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 22
```
Vzjdm?@zd}N,dt-lzd\ Uz
```
Test:
```
$ pyth -c 'Vzjdm?@zd}N,dt-lzd\ Uz' <<< "CODE-GOLF"
C               F
  O           L  
    D       O    
      E   G      
        -        
      E   G      
    D       O    
  O           L  
C               F
```
Explanation:
```
(Implicit)                  z = input()
(Implicit)                  d = ' '
Vz                          for N in range(len(z)):
  jd                            print(d.join(
    m                               map(lambda d:
     ?@zd                                        z[d] if
         }N                                      N in
           ,dt-lzd                                    (d,len(z)-d-1) else
      \                                          " ",
     Uz                                          range(len(z)))))
```
[Answer]
## Python 3: 75 chars
```
s=input()
i=n=len(s)
while i:i-=1;a=[" "]*n;a[i]=s[i];a[~i]=s[~i];print(*a)
```
For line `i`, we start with a list of spaces and set the entries `i` from the front and back to be equal to the letters of the input string. Then, we print the result.
Python strings are immutable, so `a` must be a list of characters instead. The list `a` must be initialized inside the loop or the modifications will carry over between loops. We use `print(*a)` to print each character in the list, space separated, which requires Python 3.
The output lines are symmetrical, so we can have `i` count down rather than up using a while loop.
```
>>> CODE-GOLF
C               F
  O           L  
    D       O    
      E   G      
        -        
      E   G      
    D       O    
  O           L  
C               F
```
It also works for an even number of letters.
```
>>> CODEGOLF
C             F
  O         L  
    D     O    
      E G      
      E G      
    D     O    
  O         L  
C             F
```
[Answer]
# CJam, ~~27~~ 25 bytes
```
l_,S*:Sf{W):W2$tW~@tS}zN*
```
[Try it online.](http://cjam.aditsu.net/)
### Example run
```
$ cjam <(echo 'l_,S*:Sf{W):W2$tW~@tS}zN*') <<< CROSS; echo
C       S 
  R   S   
    O     
  R   S   
C       S 
```
As the example in the answer, each line has trailing whitespace.
### How it works
```
                             " N := '\n'; R := []; S = ' '; W := -1 ";
l                            " Q := input()                         ";
 _,S*:S                      " S := len(Q) * S                      ";
       f{            }       " for each C in Q:                     ";
                             "   T := S                             ";
         W):W                "   W += 1                             ";
             2$t             "   T[W] := C                          ";
                W~@t         "   T[~W] := C                         ";
                             "   R += [T]                           ";
                    S        "   R += [S]                           ";
                      z      " R := zip(R)                          ";
                       N*    " R := N.join(R)                       ";
                             " print R                              ";
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 5 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
＼＼：⇵ｎ
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjNDJXVGRjNDJXVGRjFBJXUyMUY1JXVGRjRF,i=JTIyUFJPR1JBTSUyMg__,v=8)
Explanation:
```
\      create a diagonal of the input
 \     create an even steeper diagonal of that
  :⇵   reverse a copy of it vertically
    n  overlap the two
```
[Answer]
# Pure Bash, 94 bytes
```
l=${#1}
for((;t<l*l;t++));{
((x=t%l))||echo
((x-t/l&&x+t/l+1-l))&&printf \ ||printf ${1:x:1}
}
```
[Answer]
# [R](https://www.r-project.org/), ~~99~~ ~~98~~ ~~93~~ 89 bytes
```
m=ifelse(diag(l<-length(w<-el(strsplit(scan(,''),'')))),w,' ')
write(pmax(m,m[,l:1]),1,l)
```
[Try it online!](https://tio.run/##FcNLCoAgEADQq7SbGZgWbvucJFpYTiaMESrY7a0evNRanMMhmgVdsB516lUuX06sUy@KuaR8ayiYd3shA9D/w5WhAxprCkXwjvbByHFhHcxKbFipgd12J9Be "R – Try It Online")
Line 1 reads input string, splits it into characters, stores its length and creates a matrix with the word on its main diagonal – letters of the word are superposed on an identity matrix (and repeated by default to match its length) and only those matching 1's are retained, others being replaced by spaces.
Line 2 prints a matrix formed by elements of either the diagonal matrix or its horizontally mirrored version, whichever are greater.
*−2 + 1 = −1 byte thanks to [JayCe](https://codegolf.stackexchange.com/users/80010/jayce)*
*−4 bytes thanks to [Giuseppe](https://codegolf.stackexchange.com/users/67312/giuseppe)*
[Answer]
# Java - 168
A simple nested loop, there's nothing really special going on here.
```
class C{public static void main(String[]a){int b=-1,c=a[0].length()-1,d;for(;b++<c;)for(d=-1;d++<c;)System.out.print((b==d|b==c-d?a[0].charAt(d):" ")+(c==d?"\n":""));}}
```
With line breaks:
```
class C{
    public static void main(String[]a){
        int b=-1,c=a[0].length()-1,d;
        for(;b++<c;)
            for(d=-1;d++<c;)
                System.out.print(
                    (b==d|b==c-d?a[0].charAt(d):" ")+
                    (c==d?"\n":""));
    }
}
```
[Answer]
# Ruby, 64
```
f=->w{x=w.size
x.times{|i|y=" "*x
y[i],y[~i]=w[i],w[~i]
puts y}}
```
## Explanation
* Input is taken as the argument to a lambda. It expects a `String`.
* In a loop that loops trough every character in the word (`n` in total):
	+ Create a String consisting of `n` spaces.
	+ Replace the `i`th and `n-i`th (`~i`, thanks xnor) space with the `i`th and `n-i`th character of the input.
	+ Print the line
[Answer]
# JavaScript (E6) 101 ~~95 129 136~~
**Edit** Wrong letter spacing. Fixed.  
**Edit** Simpler and shorter using classic for loops  
As a function, output via popup.
```
F=a=>{
  for(l=a.length+1,i=s=o='';++i<l;s='\n')
    for(j=0;++j<l;)
      o+=s+((s=' ')+a)[j==i|i+j==l&&j]
  alert(o)
}
```
*Previous version* using .map
```
F=a=>alert([...a].map((c,p)=>
  --q<p
  ?B(q)+a[q]+B(p-q-1)+c 
  :B(p)+c+(p-q?B(q-p-1)+a[q]:'')
,B=n=>' '.repeat(n),q=a.length).join('\n'))
```
**Test** In FireFox/FireBug console
```
F('Java-Script')
```
*Output*
```
J                   t
  a               p  
    v           i    
      a       r      
        -   c        
          S          
        -   c        
      a       r      
    v           i    
  a               p  
J                   t
```
[Answer]
# Befunge-93, ~~68~~ 71
```
:~:84*-!#@#v_\:2*\4+p1+
::+\4+g:!| >$1+0:>p1-::
00+4\*2:\<>0p#:- ^#2g
```
You can test it [here](http://www.bedroomlan.org/tools/befunge-93-playground). It'll come up with an input dialog box on each pass through `~`; enter your word one character at a time (it does say the input is 'klunky' after all), ending with a space.
It won't print to the console; this wouldn't be Befunge without a hint of self-modification, after all! Instead it will modify its own grid to display the message. After it's done, the grid will look something like this:
```
 ~:84*-!#@#v_\:2*\4+p1+
::+\4+g:!| >$1+0:>p1-::
00+4\*2:\<>0p#:- ^#2g
c               f      
  o           l        
    d       o          
      e   g            
        -              
      e   g            
    d       o          
  o           l        
c               f
```
(Note the noble sacrifice of the cell at (0,0), after we know the pointer won't go there anymore, for the purpose of storing a piece of data.)
It also works with inputs of even length. Note that, since Befunge-93 is limited to an 80x25 grid, the input size is limited to 21 characters if you run it in a Befunge-93 interpreter. Running it as Befunge-98 should remove this limit.
*Edit* - Now it works more along the lines of the intended output, at the expense of only three characters of length.
[Answer]
# Javascript 102 84 85
*Edit: Had to fix spacing. Not so small anymore.*
```
function p(s){for(i in s){o='';for(n in s)o+=(n==i?s[n]:n==s.length-1-i?s[n]:' ')+' ';console.log(o)}}
p('Thanks-Dennis')
T                       s
  h                   i
    a               n
      n           n
        k       e
          s   D
            -
          s   D
        k       e
      n           n
    a               n
  h                   i
T                       s
```
[Answer]
## CJam, ~~38~~ ~~36~~ ~~35~~ ~~34~~ 32 bytes
```
l:I,,_f{f{_2$=@2$+I,(=|\I=S?S}N}
```
[Test it here.](http://cjam.aditsu.net/) This reads the input word from STDIN. It also works for an even number of characters. This prints a trailing column of spaces, but I don't see anything in the rules against that.
Explanation
```
l:I,,_f{f{_2$=@2$+I,(=|\I=S?S}N}
l:I                              "Read input and store it in I.";
   ,                             "Get string length.";
    ,_                           "Turn into range and duplicate.";
      f{                       } "Map block onto first range, with second range on the stack.";
        f{                   }   "Map block onto second range, with first iterator in stack.
                                  Each invocation of this block will start with grid coordinates
                                  y and x on the stack (x on top).";
          _2$=                   "Duplicate x, duplicate y, check for equality.";
              @2$+               "Pull up y, duplucate x, add,";
                  I,(=           "Check if that's one less than the string length.";
                      |          "Bitwise or between conditions.";
                       \         "Swap condition and x.";
                        I=       "Take x'th character from the string.";
                          S?     "Push a space and select character depending on condition.";
                            S    "Push another space.";
                              N  "Push a line feed.";
```
The contents of the stack are printed automatically at the end of the program.
[Answer]
# C, 105
two slightly different ways of doing it.
```
c,i,j;main(int l,char**v){for(l=strlen(v[1]);j-l;)putchar((c=v[1][i++])?i-1-j&&l-i-j?32:c:(i=0,j++,10));}
i,j;main(int l,char**v){for(l=strlen(v[1]);j-l;i++)putchar((l-i)?i-j&&l-i-j-1?32:v[1][i]:(i=-1,j++,10));}
```
If you want to add extra spaces, replace `putchar(` with `printf(" %c",` for an extra 5 characters.
[Answer]
## J - 36 30 bytes:
*Edit:* 6 characters shorter, credits go to [@algorithmshark](https://codegolf.stackexchange.com/users/5138/algorithmshark) .
```
(1j1#"1' '&,({~](*>.*&|.)=)#\)
```
eg:
```
   (1j1#"1' '&,({~](*>.*&|.)=)#\) 'Code-Golf'
C               f
  o           l  
    d       o    
      e   G      
        -        
      e   G      
    d       o    
  o           l  
C               f
```
Bonus: works with even length strings too:
```
   (1j1#"1' '&,({~](*>.*&|.)=)#\) 'CodeGolf'
C             f
  o         l  
    d     o    
      e G      
      e G      
    d     o    
  o         l  
C             f
```
[Answer]
# Prolog - 240 bytes
```
:-initialization m.
+[]. +[H|T]:-(H=' ';!),+T.
+[H|T]+I+X:-0=:=I,X=H;+T+(I-1)+X.
+L+I+C+S:-L=:=I;S=[D|E],+C+I+B,+C+(L-I-1)+B,+B+2*I+D,+L+(I+1)+C+E,+B,writef('%s\n',[B]).
-X:-get_char(C),(C='\n',X=[];X=[C|Y],-Y).
m:- -X,length(X,L),+L+0+_+X.
```
Invocation: 
```
$ echo "Code-Golf" | swipl -qf c.pl
C               f
  o           l
    d       o
      e   G
        -
      e   G
    d       o
  o           l
C               f
```
Readable:
```
:- initialization(main).
vars_to_spaces([]).
vars_to_spaces([' '|T]) :- vars_to_spaces(T).
vars_to_spaces([_|T]) :- vars_to_spaces(T).
get_index([Head|_], Index, Result) :-
    0 =:= Index,
    Result = Head.
get_index([_|Tail], Index, Result) :-
    get_index(Tail, Index-1, Result).
print_loop(Length, Index, Board, String) :-
    Length =:= Index;
    String = [FirstChar|RestString],
    get_index(Board, Index, Line),
    get_index(Board, Length-Index-1, Line),
    get_index(Line, 2*Index, FirstChar),
    print_loop(Length, Index+1, Board, RestString),
    vars_to_spaces(Line),
    writef('%s\n', [Line]).
get_line(Line) :-
    get_char(C),
    (   C = '\n', Line = [];
        Line = [C|More], get_line(More)).
main :-
    get_line(String),
    length(String, Length),
    print_loop(Length, 0, _, String).
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
LḶḤ⁶ẋ;"µ»ṚY
```
[Try it online!](https://tio.run/##ASgA1/9qZWxsef//TOG4tuG4pOKBtuG6izsiwrXCu@G5mln///9QUk9HUkFN "Jelly – Try It Online")
[Answer]
# Powershell, 78 bytes
+8 bytes thanks @[streetster](https://codegolf.stackexchange.com/users/69200/streetster)
```
param($s)$s|% t*y|%{$r=,' '*$s.length;$r[+$i++]=$_;$r[-$i]=$s[-$i];$r-join' '}
```
Explaned test script:
```
$f = {
param($s)               # declare a parameter $s stores a word
$s|% t*y|%{             # split $s into chars https://codegolf.stackexchange.com/a/168174/80745
    $r=,' '*$s.length   # create an array of spaces with length equal length of the word
    $r[$i++]=$_         # set first char
    $r[-$i]=$s[-$i]     # set last char
    $r-join' '          # join the array to string
}
}
&$f PROGRAM
''
&$f sword
''
&$f uhm
''
&$f o
''
&$f codegolf  # It works with word that contains even number of letters
```
# Powershell, 70 bytes (if a word can be represented by an array of chars)
+8 bytes thanks @[streetster](https://codegolf.stackexchange.com/users/69200/streetster)
```
($s=$args)|%{$r=,' '*$s.count;$r[+$i++]=$_;$r[-$i]=$s[-$i];$r-join' '}
```
Test script:
```
$f = {
($s=$args)|%{$r=,' '*$s.count;$r[+$i++]=$_;$r[-$i]=$s[-$i];$r-join' '}
}
&$f P R O G R A M
''
&$f s w o r d
''
&$f u h m
''
&$f o
''
&$f c o d e g o l f  # It works with word that contains even number of letters
```
Output for both cases:
```
P           M
  R       A
    O   R
      G
    O   R
  R       A
P           M
s       d
  w   r
    o
  w   r
s       d
u   m
  h
u   m
o
c             f
  o         l
    d     o
      e g
      e g
    d     o
  o         l
c             f
```
[Answer]
## C# (~~214~~ 212)
(Certainly badly) Golfed version:
```
using System;class A{static void Main(){char[]a,w=Console.ReadLine().ToCharArray();int l=w.Length,i=0;for(;i<l;i++){a=new string(' ',2*l-1).ToCharArray();a[2*i]=w[i];a[2*l-2*i-2]=w[l-i-1];Console.WriteLine(a);}}}
```
Ungolfed version:
```
using System;
class A
{
  static void Main()
  {
    char[] a, w = Console.ReadLine().ToCharArray();
    int l = w.Length, i = 0;
    for (; i < l; i++)
    {
      a = new string(' ', 2 * l - 1).ToCharArray();
      a[2 * i] = w[i];
      a[2 * l - 2 * i - 2] = w[l - i - 1];
      Console.WriteLine(a);
    }
  }
}
```
Any hints, tips, tricks or remarks are very welcome, as this is my first attempt at CodeGolf. I just wanted to try it, even though I know my C# byte length won't even come close to double the best solutions ;)
And how do you guys count your bytes? I just posted the above into a Quick Watch window and did `.Length`. I could write a small program to count bytes for me, but I bet there is an easier way that I don't yet know.
[Answer]
# JavaScript (ES6) - ~~185~~ ~~177~~ ~~175~~ 170 bytes
```
f=n=>{return s='  ',r='repeat',n=[...n],l=n.length,j=l/2-.5,[...h=n.slice(0,j).map((c,i)=>s[r](i)+c+s[r](l-2-(i*2))+' '+n[l-i-1]),s[r](j)+n[j],...h.reverse()].join('\n')}
```
Put this in the Firefox console and run as `f('PROGRAM')`:
```
P           M
  R       A
    O   R
      G
    O   R
  R       A
P           M
```
`f("CODE-GOLF")`:
```
C               F
  O           L
    D       O
      E   G
        -
      E   G
    D       O
  O           L
C               F
```
[Answer]
# Mathematica, 149 bytes
```
FromCharacterCode@Flatten[Append[Riffle[#,32],10]&/@MapThread[Max,{#,Reverse@#,ConstantArray[32,Dimensions@#]},2]&@DiagonalMatrix@ToCharacterCode@#]&
```
Input passed as parameter to the function; function returns the output string. There is a trailing newline at the end of the output.
Explanation: We create a diagonal matrix with the string, then we create a copy of it vertically flipped using `Reverse@#` to reverse the rows. Then we have a third matrix of the same dimensions containing only 32 (ascii space). We use `MapThread` to take the element-wise max of these 3 matrices. Finally, we `Riffle` spaces into each row, `Append` a newline at the end, and `Flatten` the result.
[Answer]
# Perl - 90
It might be possible to squeeze some more characters out of this:
```
($j=$i++%8)==7?++$k&&print"\n":print$j+1==$k||7-$j==$k?"$_ ":"  "for split//,($_ x y///c)
```
`89` + `1` for `-n`.
Run with:
```
echo "program" | perl -nE'($j=$i++%8)==7?++$k&&print"\n":print$j+1==$k||7-$j==$k?"$_ ":"  "for split//,($_ x y///c)'
```
Output:
```
p           m
  r       a
    o   r
      g
    o   r
  r       a
p           m
```
[Answer]
## T-SQL: 180
Taking the input from variable @i
```
DECLARE @s VARCHAR(MAX)=REPLICATE('  ',LEN(@i)),@ INT=1a:PRINT STUFF(STUFF(@s,@*2-1,1,SUBSTRING(@i,@,1)),LEN(@i)*2-(@*2)+1,1,SUBSTRING(@i,LEN(@i)-@+1,1))SET @+=1IF @<=LEN(@i)GOTO A
```
This stuffs single characters in/decrementing from the start and end into a string of spaces.
Test Result
```
DECLARE @i VARCHAR(MAX)='Super Large'
DECLARE @s VARCHAR(MAX)=REPLICATE('  ',LEN(@i)),@ INT=1a:PRINT STUFF(STUFF(@s,@*2-1,1,SUBSTRING(@i,@,1)),LEN(@i)*2-(@*2)+1,1,SUBSTRING(@i,LEN(@i)-@+1,1))SET @+=1IF @<=LEN(@i)GOTO A
S                   e 
  u               g   
    p           r     
      e       a       
        r   L         
        r   L         
      e       a       
    p           r     
  u               g   
S                   e 
```
[Answer]
# PowerShell ~~118~~ ~~102~~ 97
```
($x=[char[]]"$args")|%{$i++;$y=[char[]]" "*$x.Count;$y[$i-1]=$x[$i-1];$y[-$i]=$x[-$i];$y-join' '}
```
Outputs:
```
PS C:\PowerShell> .\cross.ps1 SWORD
S       D
  W   R
    O
  W   R
S       D
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 81 bytes
```
f=s=>[...s].map((_,i,a)=>a.map((c,j)=>j==i|j==s.length+~i?c:' ').join` `).join`
`
```
**EDIT**: -1 Thanks Joe King. I didn't see the TIO gives preformatted direct paste for CG.
[Try it online!](https://tio.run/##LcdBCsIwEEDRvaco3TTBOAdQph5ExAxpWhNipmSK3RSvHgu6@fwX6U3iSpiXU@bB1zqiYH8DALnDi2alHiYY0tjTj87EHRExbHsEks/T8jx@wtWdu6bTEDlk29j/HGx1nIWTh8STGlW7chlcYZFW60v9Ag "JavaScript (Node.js) – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 13 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
â┤▼iS╙£≥»u5V╓
```
[Run and debug it](https://staxlang.xyz/#p=83b41f6953d39cf2af753556d6&i=%22PROGRAM%22&a=1&m=2)
Unpacked, ungolfed, and commented, it looks like this.
```
{       begin block for mapping characters of input
  ]i^)  left-pad each character to length (i+1) where i is the index
m       map using block
r       reverse the array; this produces the southwest-northeast diagonal
m       map using the rest of the program, implicitly output result
  i     iteration index
  xi@   get the i'th character of the original input, where i is the iteration
  &     assign element to array at index
  0\    join with spaces
```
[Run this one](https://staxlang.xyz/#c=%7B+++++%09begin+block+for+mapping+characters+of+input%0A++]i%5E%29%09left-pad+each+character+to+length+%28i%2B1%29+where+i+is+the+index%0Am+++++%09map+using+block%0Ar+++++%09reverse+the+array%3B+this+produces+the+southwest-northeast+diagonal%0Am+++++%09map+using+the+rest+of+the+program,+implicitly+output+result%0A++i+++%09iteration+index%0A++xi%40+%09get+the+i%27th+character+of+the+original+input,+where+i+is+the+iteration%0A++%26+++%09assign+element+to+array+at+index%0A++0%5C++%09join+with+spaces&i=%22PROGRAM%22&a=1&m=2)
[Answer]
# [R](https://www.r-project.org/), 88 bytes
```
n=ncol(m<-diag(u<-utf8ToInt(scan(,""))-32));diag(m[,n:1])=u;write(intToUtf8(m+32,T),1,n)
```
[Try it online!](https://tio.run/##K/r/P882Lzk/RyPXRjclMzFdo9RGt7QkzSIk3zOvRKM4OTFPQ0dJSVNT19hIU9MarCI3WifPyjBW07bUurwosyRVIzOvJCQ/FKhJI1fb2EgnRFPHUCdP839AkL97kKPvfwA "R – Try It Online")
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 6 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
＼：↶ｎ ＊
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjNDJXVGRjFBJXUyMUI2JXVGRjRFJTIwJXVGRjBB,i=UFJPR1JBTQ__,v=8)
# Explanation
```
＼       Create a diagonal with the input
 ：      Duplicate the diagonal
  ↶     Rotate left
    ｎ   Simple overlap 
      ＊ Insert spaces on every line
```
[Answer]
# Zsh, ~~90~~ 82 bytes
Kudos to @pxeger for saving 8 bytes.
```
for i ({1..$#1})(for z (${(s::)1}){((i==++j||j+i==$#1+1))||z=\ 
printf $z\ }
echo)
```
[Attempt this Online](https://ato.pxeger.com/run?1=m724qjhjwYKlpSVpuhY3g9LyixQyFTSqDfX0VJQNazU1QAJVChoq1RrFVlaaQJFqDY1MW1tt7ayamixtIAuoTNtQU7Ompso2RoGroCgzryRNQaUqRqGWKzU5I18TYjLUgvXRSpHOHkH-vv7B_r6uSrFQYQA)   ~~[90 bytes](https://tio.run/##qyrO@J@moVn9Py2/SCFTQaPaUE9PRdmwVrMaJJCFLKChkWlrm1VTk6UNpIFC2oaammpqVbYq1YbRWbG1NTVVtjEKXAVFmXklaQoqVTEKtVypyRn5tf9rudIUIp09gvx9/YP9fV3/AwA)~~
]