[Question]
  [
**The Challenge**
Your task is to create a program that takes any given string input, and outputs the input in a squared format. Empty strings should return an empty string.
**Examples**
Given the input:
```
golf
```
Your program should output:
```
golf
o  l
l  o
flog
```
Input:
```
123
```
Output:
```
123
2 2
321
```
Input:
```
a
```
Output:
```
a
```
Input:
```
Hello, world!
```
Output (notice the space between the , and w - the gap is not just a newline):
```
Hello, world!
e           d
l           l
l           r
o           o
,           w
w           ,
o           o
r           l
l           l
d           e
!dlrow ,olleH
```
**Scoring**
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in each language wins.
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~7~~ 5 bytes
```
θ‖Ｏ↙↘
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRKNQ05orKDUtJzW5xL8stSgnsUDDyiW/PM8nNa1ERwHMDMpMzyjRtP7/Pz0/J@2/btl/3eIcAA "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved 2 bytes thanks to @CarlosAlejo. Explanation:
```
θ       Print the input string, making the top row
 ‖Ｏ     Reflect with overlap...
   ↙    ... down and left, to create the left side
    ↘   ... down and right, to create the bottom and right sides
```
(Multiple directions to the Reflect command run consecutively rather than simultaneously.)
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~20~~ ~~16~~ 11 bytes
```
otYTO6Lt&(c
```
Try it at [**MATL online!**](https://matl.io/?code=otYTO6Lt%26%28c&inputs=%27Hello%2C+world%21%27&version=20.2.1)
*EDIT: The code works in release 20.2.1, which predates the challenge. The link uses that release. (In 20.2.2 the code would be shorter, but it postdates the challenge).*
### Explanation
```
o     % Implicitly input a string. Convert chars to ASCII codes
t     % Duplicate
YT    % 2-input Toeplitz matrix
O     % Push 0
6L    % Push predefined literal [2, -1+1j]. When used as an index, this is
      % interpreted as 2:end-1 (indexing is 1-based)
t     % Duplicate
&(    % 4-input assignment indexing. This writes 0 at the square formed by
      % rows 2:end-1 and columns 2:end-1 
c     % Convert to char. Char 0 is shown as space. Implicitly display
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~29 22~~ 17 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
*[Charcoal](https://github.com/somebody1234/Charcoal) ~~will~~ [trounce+d](https://codegolf.stackexchange.com/a/133677/53748) this score...*
```
J⁶ẋa0,1¦"ṚṚ;$ṖŒḌY
```
A monadic link taking and returning a lists of characters; or a full program printing the result.
**[Try it online!](https://tio.run/##y0rNyan8/9/rUeO2h7u6Ew10DA8tU3q4cxYQWas83Dnt6KSHO3oi////r1SekZ@TqgQA "Jelly – Try It Online")**
### How?
```
J⁶ẋa0,1¦"ṚṚ;$ṖŒḌY - Link: list of characters, w     e.g. "whole"
 ⁶                - literal space character              ' '
J                 - range(length(w))                     [1,2,3,4,5]
  ẋ               - repeat                               [" ","  ","   ","    ","     "]
         Ṛ        - reverse w                            "elohw"
        "         - zip with:
       ¦          -   sparse application of:
   a              -     and (vectorises)
    0,1           -     to indexes: [0,1] (last and 1st) ["e","ll","o o","h  h","w   w"]
            $     - last two links as a monad:
          Ṛ       -   reverse                            ["w   w","h  h","o o","ll","e"]
           ;      -   concatenate                        ["w   w","h  h","o o","ll","e","e","ll","o o","h  h","w   w"]
             Ṗ    - pop (remove last entry)              ["w   w","h  h","o o","ll","e","e","ll","o o","h  h"]
              ŒḌ  - reconstruct matrix from diagonals    ["whole","h   l","o   o","l   h","elohw"]
                Y - join with newlines                   "whole\nh   l\no   o\nl   h\nelohw"
                  - if running as a full program implicit print
```
[Answer]
## C, 109 bytes
```
i,j;f(char*s){for(i=j=printf("%s\n",s)-2;1[++s];)printf("%c%*c\n",*s,i,s[j-=2]);for(;*s*~i--;)putchar(*s--);}
```
[Try it online!](https://tio.run/##PcxBDsIgEEDRqxCSJgxlFnY74SS1CxxFIRENU1dNvTqWjev/8xjvzK0llykafoRqBbb4qib57N81lTUaPci5aCeAE53mcZSF4J94sNyrFZeczBn9tAB1gazYb0I85s/aaWMFEWhvz5CKAbWpAwgXvt40kNrbDw "C (gcc) – Try It Online")
Noteworthy tricks:
* Instead of wasting bytes on `strlen`, we simply grab the length of the string while simultaneously printing the first line:
```
i=j=printf("%s\n",s)-2
```
This works because `printf` returns the number of bytes written.
* For the middle lines, we need to loop over the string but exclude both the first and last character. This is achieved with the condition
```
1[++s]
```
(which is shorter than `(++s)[1]`), which skips the first character due to the `++`'s being in the condition and skips the last one by stopping when the character past the current character is `'\0'` (rather than stopping *at* `'\0'`).
* In the body of the first loop,
```
printf("%c%*c\n",*s,i,s[j-=2])
```
we print the current character, then the appropriate "mirrored" character (keeping track with `j`, which does go into the negatives, resulting in the odd situation of indexing into a string with a negative number) padded to a length of `i` with spaces (where `i` is conveniently `strlen(s) - 1`).
* The reversed printing on the last line is pretty straightforward; the only trick is the `*s*~i--`, which is the shortest way to get `i+2` iterations of the loop body (which doesn't depend on `i`; all `i` is used for is to count). The funky `*s*` part makes sure the loop doesn't run if `*s` is `'\0'`, which happens on length-1 input.
[Answer]
# Octave, 40 bytes
```
@(s,t=toeplitz(s),u=t(x=2:end-1,x)=32)t;
```
[Try it online!](https://tio.run/##y08uSSxL/f/fQaNYp8S2JD@1ICezpEqjWFOn1LZEo8LWyCo1L0XXUKdC09bYSLPE@n9iXrGGUnp@TpqS5n8A "Octave – Try It Online")
It is my answer but posted after @Luis [MATL answer](https://codegolf.stackexchange.com/a/133659/62451)
[Answer]
# [Haskell](https://www.haskell.org/), ~~84~~ 78 bytes
```
f s@(_:x)|_:y<-r x=s:[a:(y>>" ")++[b]|(a,b)<-zip x y]++[r s];f s=[s]
r=reverse
```
[Try it online!](https://tio.run/##Dc1BCoMwEEDRfU8xiIsEaw@QGuk9QpBYRgxNU5mxJRHvnmb74fFXxy8MoZQF@CEmleQ5qTz0BEmzMk6JPI4NNLLrzGxP4a6zHPrDb5Ag2xoJ2N4r1obthTThD4mxvJ2PoMHHHck9d2jhG4OPyLelrHX4@QM "Haskell – Try It Online") Usage: `f "test"`. Returns a list of lines.
**Edit:** -6 bytes thanks to dianne!
[Answer]
# [Python 2](https://docs.python.org/2/), ~~89~~ ~~81~~ ~~88~~ 86 bytes
```
i=input();n=k=len(i)-2
print i
exec'print i[~k]+" "*n+i[k];k-=1;'*n
if~k:print i[::-1]
```
[Try it online!](https://tio.run/##NcqxCoAgEADQ3a@QFktx0FHxS8IpjI6LS8OgFn/dlhofvPzU7SDbOwSgfNVx8hQw7IlGmLRl@QSqHFi60yI@zA2jGvggScGM0aMOxgtJDNaG7k/OaRN7F6WIFw "Python 2 – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 113 bytes
```
function(s){n=length(s<-strsplit(s,'')[[1]])
m=matrix(' ',n,n)
m[n,n:1]=m[,1]=m[1,]=m[n:1,n]=s
write(m,'',n,,'')}
```
[Try it online!](https://tio.run/##HYwxCgIxEEX7PcVazQTGIq2Y3htYhBSiGw0kE8nMoiCePWZt3ofH57UeXY8rXzVVRjEfdnnhuz5QjnvRJs@cFIUAjPc2BDMVVy7a0hthBmLiYfyYgw2uePrT0sahiIOT6dWSLlhGY/y30rdHhNOSc6X5XFu@7cD0Hw "R – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~17~~ ~~16~~ ~~15~~ 19 bytes
```
ÂDÂø¦¨Dgú€Ás)˜»Igi¨
```
[Try it online!](https://tio.run/##ASsA1P8wNWFiMWX//8OCRMOCw7jCpsKoRGfDuuKCrMOBcynLnMK7SWdpwqj//2Fi "05AB1E – Try It Online")
**Explanation**
Example with `input = golf`
```
ÂDÂ                  # bifurcate, duplicate, bifurcate
                     # STACK: 'golf', 'flog', 'flog', 'golf'
   ø                 # zip the top 2 items
                     # STACK: 'golf', 'flog', ['fg', 'lo', 'ol', 'gf']
    ¦¨               # remove the first and last element
                     # STACK: 'golf', 'flog', ['lo', 'ol']
      Dg             # get the length of the list
                     # STACK: 'golf', 'flog', ['lo', 'ol'], 2
        ú            # prepend that many spaces to each element
                     # STACK: 'golf', 'flog', ['  lo', '  ol']
         €Á          # rotate each right
                     # STACK: 'golf', 'flog', ['o  l', 'l  o']
           s         # swap the top 2 items
                     # STACK: 'golf', ['o  l', 'l  o'], 'flog'
            )˜       # wrap in a flattened list
                     # STACK: ['golf', 'o  l', 'l  o', 'flog']
              »      # join on newline
               Igi¨  # if input is length 1, remove last char
```
The fix for 1-letter input was quite expensive.  
I feel like a different approach might be better now.
[Answer]
# Python 3, 88 bytes
```
w=input();p=print;l=len(w)-2
[p(w[n+1]+' '*l+w[l-n])for n in range(l)]
l+1and p(w[::-1])
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~99~~ 88 bytes
*-4 bytes thanks to musicman523.*
```
lambda s:s[1:]and[s]+[s[i]+' '*(len(s)-2)+s[~i]for i in range(1,len(s)-1)]+[s[::-1]]or s
```
[Try it online!](https://tio.run/##LcuxDsIgEIDhVzknwLYmdCRx9w060BswgJ7Bo@G6uPjqaIzz//3ba79Xnns@r72E5zUGECfeOgwcveDgxRMOCtRRl8RazDSbQfybMNcGBMTQAt@StuO/W/O7nJss4tdI3xrxDmpldXpUYp21uqRS6ghLbSUelDH9Aw "Python 2 – Try It Online")
Returns a list of strings.
[Answer]
# Mathematica, 128 bytes
```
(c=Column;g=Length[x=Characters@#]-1;If[g==0,#,c@{#,c@Table[""<>{x[[i]],""<>Table[" ",g-1],x[[-i]]},{i,2,g}],StringReverse@#}])&
```
[Answer]
# C, 96 bytes
```
i,l;f(char*s){for(i=l=puts(s)-2;--i;)printf("%c%*c\n",s[l-i],l,s[i]);for(;l+1;)putchar(s[l--]);}
```
Bonus version (122 bytes):
```
x,y,i,l;f(char*s){for(i=l=puts(s)-1;++i<l*-~l;putchar(x==l?10:x%~-l*(y%~-l)?32:s[(x*y?l+l-2-x-y:x+y)%l]))x=i%-~l,y=i/-~l;}
```
[Answer]
# [Swift 3](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/index.html), ~~215~~ 199 bytes
```
let s=readLine()!,c=s.characters,r:[Character]=c.reversed(),b=c.count
print(s)
if b>1{for i in 0..<b-2{print("\(r.reversed()[i+1])\(String.init(repeating:" ",count:b-2))\(r[i+1])")};print(String(r))}
```
[Try it online](http://swift.sandbox.bluemix.net/#/repl/5972645d4d6fc06b79b9e5d0)
[Answer]
# JavaScript (ES8), ~~108~~ 112 bytes
```
let f = 
s=>(n=s.length)<2?s:(r=[...s].reverse()).slice(1,-1).reduce((a,v,i)=>a+`
`+s[i+1].padEnd(n-1)+v,s)+`
`+r.join``
o.innerHTML = f("hello folks!")
```
```
<pre id="o"></pre>
```
**Less golphed**
```
s=>
   (n=s.length) < 2 ?    // record and check length
   s :                   // s has 0 or 1 char, else
   (r=[...s].reverse())  // reverse characters,
   .slice(1,-1)          // exclude 1st and last
   .reduce((a,v,i)=>     // append inner lines
      a +'\n' +s[i+1].padEnd(n-1) + v
    ,s)                  // to first line
    + '\n' +r.join("")   // append characters reversed
```
Thanks to Justin Mariner for saving lots of bytes, which then all got used up adding the zero or single character check needed to comply with the challenge. You get that :-(
[Answer]
# [PHP](http://php.net/), 118 bytes
```
echo $s=$argv[1];$l=strlen($r=strrev($s))-1;for($i=$l-1;$l&&$i;)echo "\n".str_pad($r[$i],$l).$s[$i].(--$i?"":"\n$r");
```
[Try it online!](https://tio.run/##HcvRCoMgGIbhW3HyEQopdDoXnXYPLUYst4SflN/RLt/Zzp6D901bKuU2pC0J/9yiQO6x8PuYutmB@vxh8rsCn2J/KGStTedekRVCD6oGNQ2C0/9f3ndpa/tIy1q3CWFuQdoin7TKGIRBymvtwFK7UsroiWIrvpFpvfwA)
```
echo $s = $argv[1];
$l = strlen($r = strrev($s)) - 1;
for ($i = $l - 1; $l && $i;)
    echo "\n" . str_pad($r[$i], $l) . $s[$i] . (--$i ? "" : "\n$r");
```
[Answer]
# [APL](https://www.dyalog.com/), 58 bytes
```
{(' ',⍵)[x+(x←∘.{((c-1)=⍺⌈⍵)∨0=⍺⌊⍵}⍨r)×o⌊⌽⊖o←∘.⌈⍨r←⍳c←≢⍵]}
```
With `⎕IO←0`.
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HfVE//R20TDLjSgGS1hrqCus6j3q2a0RXaGhVAkUcdM/SqNTSSdQ01bR/17nrU0wGSfdSxwgDC7QJyax/1rijSPDw9H8ztfNQ1DULmQ/WDNa0oAvF6NyeDqM5FQG2xtf//pymoJ6pzAUlDI2Mw7ZGak5OvqA4A)
**How?**
`c←≢⍵` - length of the string
`r←⍳` - range
`o←∘.⌈⍨` - outer product with minimum
```
123
223
333
```
`o⌊⌽⊖` - minimalize with itself turned 180o
```
123  ⌊  333  =  123
223  ⌊  322  =  222
333  ⌊  321  =  321
```
`×` - multiply with
`x←∘....⍨r` - outer product of the range with
    `((c-1)=⍺⌈⍵)∨0=⍺⌊⍵` - the frame of the matrix
```
111  ×  123  =  123
101  ×  222  =  202
111  ×  321  =  321
```
`x+` - add the frame
```
111  +  123  =  234
101  +  202  =  303
111  +  321  =  432
```
`(' ',⍵)[...]` - get by index from the string concatenated to space
[Answer]
# Python 3, 122 bytes
```
i=input();l=len(i)
if l!=1:
    print(i)
    for I in range(1,l-1): print(i[I]+" "*(l-2)+i[l-I-1])
    print(i[::-1])
else:print(i)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY3qzJtM_MKSks0NK1zbHNS8zQyNbky0xRyFG0Nrbg4C4oy80pAQpxp-UUKngqZeQpFiXnpqRqGOjm6hppWClAF0Z6x2koKSloaObpGmtqZ0Tm6nrqGsZpwA6KtrMD81JziVCuYoRAXQB2yYGEihAEA)
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), ~~14~~ 10 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
*Knew* there had to be a shorter way!
```
¬hU ÆÔÃÕÆÔ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=rGhVIMbUw9XG1A&input=IkhlbGxvLCB3b3JsZCEi)
```
¬hU ÆÔÃÕÆÔ     :Implicit input of string U
¬              :Split
 hU            :Replace first element with U
    Æ          :Modify last element
     Ô         :  U reversed
      Ã        :End modify
       Õ       :Transpose
        ÆÔ     :As above
               :Implicit output joined with newlines
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 8 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
gIûûŽ9¦Λ
```
[Try it online](https://tio.run/##yy9OTMpM/f8/3fPw7sO7j@61PLTs3Oz//xOTklMA) or [verify all test cases](https://tio.run/##S0oszvifnFiiYKeQnJ@SqpdfnJiUmapgY6Pg6u/GdWibvZJnXkFpiZWCkr0Ol5J/aQmEo/M/3fPw7sO7j@61PLTs3Oz/IMVc5RmZOakKRamJKQqZeVwp@VwKCvr5BSX6EDOhFJo1NgoqYLV5qf/T83PSuAyNjLkSuTxSc3LydRTK84tyUhS5EpOSU7gA).
**Explanation:**
```
g    # Push the length of the (implicit) input
I    # Push the input itself
 û   # Palindromize it
  û  # And palindromize that again
Ž9¦  # Push compressed integer 2460
Λ    # Use the Canvas builtin with those three options
     # (after which the result is output immediately implicitly)
```
[See this 05AB1E tip of mine (section How to compress large integers?)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Ž9¦` is `2460`.
As for some additional information about the Canvas builtin `Λ`:  
It takes 3 arguments to draw an ASCII shape:
1. Length of the lines we want to draw
2. Character/string to draw
3. The direction to draw in, where each digit represents a certain direction:
```
7   0   1
  ↖ ↑ ↗
6 ← X → 2
  ↙ ↓ ↘
5   4   3
```
`gIûûŽ9¦` creates the following Canvas arguments:
* Length: the length of the input (e.g. `4` for input `"abcd"`)
* Characters: the double palindromized input (e.g. `"abcdcbabcdcba"` for input `"abcd"`)
* Directions: `[2,4,6,0]`, which translates to \$[→,↓,←,↑]\$
Because we only have a single length, the directions are leading here.
Step 1: Draw 4 characters (`"abcd"`) in direction `2` (\$→\$):
```
abcd
```
Step 2: Draw 4-1 characters (`"cba"`) in direction `4` (\$↓\$):
```
abcd
   c
   b
   a
```
Step 3: Draw 4-1 characters (`"bcd"`) in direction `6` (\$←\$):
```
abcd
   c
   b
dcba
```
Step 4: Draw 4-1 characters (`"cba"`) in direction `0` (\$↑\$):
```
abcd
b  c
c  b
dcba
```
[See this 05AB1E tip of mine for an in-depth explanation of the Canvas builtin.](https://codegolf.stackexchange.com/a/175520/52210)
[Answer]
# [J](http://jsoftware.com/), 28 23 bytes
```
|._1}]0}|.,.~<:@#{."1,.
```
[Try it online!](https://tio.run/##PYo9C8IwFAD3/IrXBnxtSV6TRWiwEBTEQRxcnIqDtn4QCLg2yV@PxcHhhjvunbvC6GFdmA6RlYQT9AYQBCgwC5Jgdz7uc6CrjoOKgQSljbF8plILyjU7bWn5cSXmVFVcDsHKNlDdqF41bbIiRVPbF1nOxtvTwwT48G7CnyH@42F0zgu4@I@7Y/4C "J – Try It Online")
* `,.` Columnize the input:
```
g
o
l
f
```
* `<:@#{."1` Take "input length - 1" elements from each row, with space fills. I'll show the spaces filled with `.` for clarity:
```
g..
o..
l..
f..
```
* `|.,.~` Zip with the reverse:
```
g..f
o..l
l..o
f..g
```
* `]0}` Replace first row with input:
```
golf
o..l
l..o
f..g
```
* `|._1}` Replace last row with input reversed:
```
golf
o..l
l..o
flog
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~16~~ 10 bytes
```
∞∞?L2460ø∧
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLiiJ7iiJ4/TDI0NjDDuOKIpyIsIiIsIkhlbGxvLCB3b3JsZCEiXQ==)
-6 bytes by porting 05AB1E thanks to emanresu
[Answer]
# JavaScript (ES2017), 87 bytes
```
s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i].padEnd(l)+c:z.join``:s).join`
`
```
ES6 version: 93 bytes
```
s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i]+' '.repeat(l-1)+c:z.join``:s).join`
`
```
*Less golfed*
```
s => (
  l = s.length-1,
  [...s].reverse().map( // scan string backwards
     (c, i, z) => 
     i != 0 // check if top row
     ? l-i != 0 // check if bottom row
       ? s[i].padEnd(l) + c // any middle row
       : z.join`` // bottom row: string reversed
     :s // top row: original string
  ).join`\n`
)
```
```
F=
s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i].padEnd(l)+c:z.join``:s).join`
`
function update() {
  O.textContent = F(I.value)
}
update()
```
```
<input id=I value='Hello, world!' oninput='update()'>
<pre id=O></pre>
```
[Answer]
# Java, 191 bytes
```
(s)->{PrintStream o=System.out;int l=s.lenght();o.println(s);for(int i=0;i<l;i++){o.printf("%"+"s%"+(l-1)+"s%n",s.charAt(i),s.charAt(l-1-i));for(int i=0;i<l;i++){o.print(s.charAt(l-1-i));}}};
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), ~~179~~ 161 bytes
*-18 bytes thanks to [TheLethalCoder](https://codegolf.stackexchange.com/users/38550/thelethalcoder)*
```
using System.Linq;
s=>{int l=s.Length-1,i=1;var d=s.Reverse().ToArray();while(i<l)s+="\n"+s[i]+new string(' ',l-1)+d[i++];if(l>1)s+="\n"+new string(d);return s;};
```
[Try it online!](https://tio.run/##TVA9b8IwEJ2bX3FlwZaTSJlNkFClqgNdaKUOlMGKL3CSsVufCUKI354GaClvuM@np3fXcNGEiL03W@Qv0yC8HTjhNjtmMGDH5NcwJ/@tL33jDDPMLvWVcQYnk6iBLpCFV0NeyNvqn3TG8843E05xEM3hmqfQQt1zPT2ST@BqLufo12lTVDnVle5MBDsMF9hhZBSyfA@zGM1BSL3fkENBEydZ1aNPP1K8pJXyuP/VFmMY566opLJLUmqlqRVuWt3od0wrdcS0ix5Yn3T/cHb7FDwHh@VHpISiFX/9Ao0dXjKYkVLf7jtl13jqX9C5kMM@RGcffwA "C# (.NET Core) – Try It Online")
~~I'm not sure about the rules, if this is needed to byte count or not:~~
```
using System.Linq;
```
Someone please correct me about this.
Ungolfed:
```
s =>
{
    int l = s.Length - 1, i = 1;
    var d = s.Reverse().ToArray();
    while (i < l)
        s += "\n" + s[i] + new string(' ', l - 1) + d[i++];
    if (l > 1)
        s += "\n" + new string(d);
    return s;
};
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 106 bytes
```
..+
$&¶$&
O$^`.(?=.*$)
\G.
$&$%'¶
r`.\G
¶$%`$&
+`(.+)¶¶((.*¶)*).(.*)
¶¶$1$4$2
T`p` `(?<=.¶.).*(?=.¶.)
G`.
```
[Try it online!](https://tio.run/##FYwxCgJBDEX7nMIiuyYz8EGxdNlyShvLRWKhIojK4tlygFxsnOke7z/@evs939dagUw8hvNIJ74YZJ6QWImWgjbwsA2n1bAUatFgrcsmyBoeLoIUrknRQKkr3vGB93S2r21M5uOEcChS/@1ExVDr4/O6/wE "Retina – Try It Online") Explanation:
```
..+
$&¶$&
```
If there are at least two characters, duplicate the input.
```
O$^`.(?=.*$)
```
Reverse the duplicate.
```
\G.
$&$%'¶
r`.\G
¶$%`$&
```
Turn the strings into triangles. The top triangle starts with the input and removes the first character each time, while the bottom triangle starts with the first letter of the reversed input and adds a character each time.
```
+`(.+)¶¶((.*¶)*).(.*)
¶¶$1$4$2
```
Join the triangles together, overlapping so that the last character forms the `/` diagonal.
```
T`p` `(?<=.¶.).*(?=.¶.)
```
Change all the characters to spaces, if they are at least one character away from the end on every side.
```
G`.
```
Delete any left-over blank lines.
[Answer]
# Python 3, 85 bytes
Using the input for the top row :)
```
a=input()
b=len(a)
for i in range(b-2):print(a[1+i]+" "*(b-2)+a[-2-i])
print(a[::-1])
```
[Answer]
# [Lua](http://lua.org), 104 bytes
```
print(s);for a=2,#s-1 do print(s:sub(a,a)..(" "):rep(#s-2)..s:sub(#s-a+1,#s-a+1)) end;print(s:reverse())
```
[Try it online!](https://tio.run/##NYvNCoQwDIRfJdu9JFgFPSrefY1Is7BQrCT@PH4tqKfhm28m7pxtdJPEmDycSWP4uLzqf9nQaPglBR47/7W6hZDgEb3tM7Jnahp04KhXWbFsulLcsgBXrb@DCGQJw3tWOURNkCjnCw)
[Answer]
# Python 3, 106 bytes
A functional version... 
```
w=input();p=print;l=len(w)-2
def f(k):p(w[k]+' '*l+w[-k-1]);l-k>0and f(k+1)
l<0 or f(1)or l<1or p(w[::-1])
```
[Answer]
# [Python 2](https://docs.python.org/2/), 100 bytes
```
lambda a:'\n'.join([a]+(len(a)>1)*([a[i]+(len(a)-2)*' '+a[~i]for i in range(1,len(a)-1)]+[a[::-1]]))
```
[Try it online!](https://tio.run/##PYu7DsIwDAB/xUyO@0BKx0gw8w9pBqMmYBScKqqEWPj10AEx3ulufW/3olNLp7llfl4XBnY4Kx4fRdR4Dr3JUQ3T2VK3s5e/GSfqELBn/5GQSgUBUaist2js8GsshX6/nBttCERtraIbJIOXmHMZ4FVqXg5I7Qs "Python 2 – Try It Online")
]