[Question]
  [
## Introduction:
Inspired by [this comment of *@MagicOctopusUrn*](https://codegolf.stackexchange.com/questions/129523/it-was-just-a-bug#comment326309_129549) on [*@Emigna*'s 05AB1E answer](https://codegolf.stackexchange.com/a/129549/52210) for my ["*It was just a bug*" challenge](https://codegolf.stackexchange.com/questions/129523/it-was-just-a-bug):
> 
> `8F9ÝÀNð×ý}».∊` I done did made a spaceship maw! And I was all excited about suggesting a 12-byte edit. – [Magic Octopus Urn](https://codegolf.stackexchange.com/users/59376/magic-octopus-urn) Jul 17 '17 at 20:10
> 
> 
> 
Which is a [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands) (legacy) program resulting in this:
```
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
```
[Try it online.](https://tio.run/##AR8A4P8wNWFiMWX//zhGOcOdw4BOw7DDl8O9fcK7LuKIiv//)
## Challenge:
Input: A non-empty string
Output: From outwards going inwards, add one more space between each character every line, similar as done in the output above, equal to the `length - 1`. So for an input `1234567890` the output would actually be this instead:
```
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
1         2         3         4         5         6         7         8         9         0
1        2        3        4        5        6        7        8        9        0 
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
```
Why? The length of `1234567890` is `10`. So we start by outputting 10 lines: the first line without spaces; second with one space delimiter; third with two; etc. And then (without have the middle line with `length - 1` spaces duplicated), we go back to the initial input while going down.
## Challenge rules:
* Input is guaranteed to be non-empty (a length `>= 1`). (For single char inputs we simply output that character.)
* Any amount of trailing/leading spaces/newlines are allowed, as long as the output itself (wherever on the screen) is correct. (Empty line(s) in between output lines also isn't allowed.)
* Input will only contain printable ASCII characters excluding whitespaces (code-point range `[33, 126]`)
* I/O is flexible. Input may be taken as STDIN, argument, or function parameter. May be a list/array/stream of characters instead of string. Output may also be a list/array/stream of characters instead of strings; may be printed to STDOUT; returned as newline-delimited string; etc.
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.  
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code.
* Also, adding an explanation for your answer is highly recommended.
## Test cases:
```
Input: @
Output:
@
Input: test
Output:
test
t e s t
t  e  s  t
t   e   s   t
t  e  s  t
t e s t
test
Input: ?!
Output:
?!
? !
?!
Input: Spaceship
Output:
Spaceship
S p a c e s h i p
S  p  a  c  e  s  h  i  p
S   p   a   c   e   s   h   i   p
S    p    a    c    e    s    h    i    p
S     p     a     c     e     s     h     i     p
S      p      a      c      e      s      h      i      p
S       p       a       c       e       s       h       i       p
S        p        a        c        e        s        h        i        p
S       p       a       c       e       s       h       i       p
S      p      a      c      e      s      h      i      p
S     p     a     c     e     s     h     i     p
S    p    a    c    e    s    h    i    p
S   p   a   c   e   s   h   i   p
S  p  a  c  e  s  h  i  p
S p a c e s h i p
Spaceship
Input: 05AB1E
Output:
05AB1E
0 5 A B 1 E
0  5  A  B  1  E
0   5   A   B   1   E
0    5    A    B    1    E
0     5     A     B     1     E
0    5    A    B    1    E
0   5   A   B   1   E
0  5  A  B  1  E
0 5 A B 1 E
05AB1E
Input: )}/\
Output:
)}/\
) } / \
)  }  /  \
)   }   /   \
)  }  /  \
) } / \
)}/\
```
  
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~8~~ 6 bytes
Takes input as an array of characters, outputs an array of strings.
```
£qYçÃê
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=o3FZ58Pq&input=WyJTIiwicCIsImEiLCJjIiwiZSIsInMiLCJoIiwiaSIsInAiXQotUg==)
---
## Explanation
```
£          :Map each element at (0-based) index Y
 q         :  Join input with
  Yç       :   Space repeated Y times
    Ã      :End Map
     ê     :Palindromise
```
---
## Original, 8 bytes
I/O is a string. Uses the `-R` flag. Includes trailing spaces on each line.
```
¬£múYÄÃê
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=rKNt+lnEw+o=&input=IlNwYWNlc2hpcCIKLVI=)
### Explanation
```
             :Implicit input of string U
¬            :Split
 £           :Map each character at 0-based index Y
  m          :  Map original U
   ú         :    Right pad with spaces to length ...
    YÄ       :     Y+1
      Ã      :End map
       ê     :Palindromise
             :Implicitly join with newlines
```
[Answer]
# [R](https://www.r-project.org/), ~~105~~ ~~99~~ ~~85~~ ~~84~~ 79 bytes
-6 thanks to @Kevin Cruissen and @Giuseppe
-14 from changing to a regex based method
-1 thanks to @Giuseppe
-5 thanks to @digEmALl
```
function(w,n=nchar(w)-1)write(trimws(Map(gsub,"",strrep(" ",n-abs(n:-n)),w)),1)
```
[Try it online!](https://tio.run/##JcYxCsMwDEDRvadoNUlgD1lLQ3uBHsIxduMhqpEUdHwnkOHzvoz6iqPunK39GT3wzHlNgk5xIpdmBU3a5orf1PGn@xIAgppI6Qh3CBzTosjPyETBzyYaFeEDdDt5vC@tqF2nPeWia@tA4wA "R – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~10~~ 9 bytes
Saved 1 bytes thanks to *Adnan*
```
εINð×ý}û»
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3FZPv8MbDk8/vLf28O5Du///j1YyUNJRMgViRyB2AmJDIHZVigUA "05AB1E – Try It Online")
**Explanation**
```
ε            # apply to each in input
 I           # push the input
  Nð×        # push <index> spaces
     ý       # merge the input on the spaces
      }      # end loop
       û     # palendromize
        »    # join on newlines
```
[Answer]
# JavaScript (ES6), 53 bytes
Takes input as an array of characters.
```
f=(s,p=i='',o=s.join(p)+`
`)=>s[++i]?o+f(s,p+' ')+o:o
```
[Try it online!](https://tio.run/##dcqxCsIwEADQvV@hXZJwNejgIpxVwS9wLIWGmGhKyQUv@PuR7mZ@bzZfw/YTUt5FerpSPEruEgYUoiNkPVOIMimYmknhmQeAMPYEfl0gNkIBnahYikyL0wu9pJeD1rq9tKNSzR/IjnPN@m1NHslYx@@QamF/vN4O91XLDw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 10 bytes
```
Ｅθ⪫θ× κ‖Ｏ↓
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUCjUEfBKz8zD0SHZOamFmsoKSjpKGRrAoE1V1BqWk5qcol/WWpRDlCtlUt@eZ6m9f//hkbGJqZm5haWBv91y3IA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｅθ          Map over characters of input string
  ⪫θ        Join characters of input string using
    ×       a literal space repeated 
      κ     current index number of times
            Implicitly print each result on its own line
       ‖Ｏ↓  Reflect vertically with overlap
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 8 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
┐² ×＊］──
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXUyNTEwJUIyJTIwJUQ3JXVGRjBBJXVGRjNEJXUyNTAwJXUyNTAw,i=U3BhY2VzaGlw,v=6)
The [7 byte](https://dzaima.github.io/Canvas/?u=JXUyNTEwJUIyJTIwJUQ3JXVGRjBBJXVGRjNEJXUyNTAw,i=JTIwQUJDJTVD,v=6) version was too good for this challenge..
[Answer]
# [Python 2](https://docs.python.org/2/), ~~72~~ ~~70~~ ~~68~~ ~~66~~ 65 bytes
-2 bytes thanks to Kevin Cruijssen  
-3 bytes thanks to ovs  
```
w=input();c=s=-1
while c:print(' '*~c).join(w);s*=w[:c]>'';c+=s|1
```
[Try it online!](https://tio.run/##BcFBCoAgEADAe6/wtmoU2FHZPhKdFkEjVHJDgujrNlMeDjktvTeMqdwslSOsOJmhhXh6QbZcMbEEAfojNR85JtmUqxrbZmlfARyNWF/TO7CvDD8 "Python 2 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~54~~ 49 bytes
```
->a{(-(z=a.size-1)..z).map{|i|a*(?\s*(z-i.abs))}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6xWkNXo8o2Ua84sypV11BTT69KUy83saC6JrMmUUvDPqZYS6NKN1MvMalYU7O29n9BaUmxQlq0kqGRsYmpmbmFpYGSXnJGYlFxLBdMKrggMTm1OCOzAEPGXhEm9B8A "Ruby – Try It Online")
Takes input as an array of characters, outputs array of strings.
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), 9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
εINúíJ}û»
```
Input as list of characters.
[Try it online](https://tio.run/##MzBNTDJM/f//3FZPv8O7Dq/1qj28@9Du//@jlTSVdJRqgVgfiGNilGIB) or [verify all test cases](https://tio.run/##MzBNTDJM/W/u5nl4QqjO/3NbI/wO7zq81qv28O5Du//rHNqm8z9ayVBJR8kIiI2B2ASITYHYDIjNgdgCiC2B2EAplitayQFMlgD5qUBcDMQlYBF7IEsRzAoGsgqAOBGIk5HUZQBxJlgOpMoAaosjEDsBMcgFrmAZTSCrFoj1gTgmRikWAA).
**Explanation:**
```
ε     }    # Map each character in the input to:
 I         #  Take the input
  Nú       #  Prepend each with the 0-indexed amount of spaces
           #   i.e. ["t","e","s","t"] & 3 → ["   t","   e","   s","   t"]
    í      #  Reverse each item
           #   i.e. ["   t","   e","   s","   t"] → ["t   ","e   ","s   ","t   "]
     J     #  Join them together to a single string
           #   i.e. ["t   ","e   ","s   ","t   "] → "t   e   s   t   "
       û»  # Palindromize the list, and join by newlines
           #  i.e. ["test","t e s t ","t  e  s  t  ","t   e   s   t   "]
           #   → "test\nt e s t \nt  e  s  t  \nt   e   s   t   \nt  e  s  t  \nt e s t \ntest"
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~60~~ 59 bytes
```
(init<>reverse).(scanl(?)<*>tail)
a?_=do u<-a;u:[' '|' '<u]
```
[Try it online!](https://tio.run/##DcyxDoIwEADQna@4jdYEPkAPGHCUhMTFRA25QMHG0pL26uS3Wxne@l4U3sqYpNfNeYYzMZWds05PIEBgLUFm2QwVPJLQVjPWXn2UD0qWIoxkjWgkHmombWRGzVBNDiIWdIrHew75d4fxmVbSdk9W2roBtshX9hcLJewzIiyKW2dZWQ6JVeDfOBtaQipubd//AQ "Haskell – Try It Online")
## Explanation
For a string (eg. `"abc"`) we apply first
```
scanl (?) <*> tail
```
which is the same as
```
\str -> scanl (?) str (tail str)
```
This repeatedly applies `(?)` (appends a space to each character in the range *[33..]*) to the `str` until there are that many strings as `str` has characters: `["abc","a b c ", "a b c "]`
Now we only need to concatenate the result (minus the last element) with its reversed counter part:
```
init<>reverse
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~66~~ 54 bytes
*-12 bytes thanks to mazzy*
```
0..($x=($a=$args).count-1)+$x..0|gu|%{$a-join(' '*$_)}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/30BPT0OlwlZDJdFWJbEovVhTLzm/NK9E11BTW6VCT8@gJr20RrVaJVE3Kz8zT0NdQV1LJV6z9v///@ol6v/VU4G4WB3EBgA "PowerShell – Try It Online")
Takes input via splatting, which on TIO manifests as separate command-line arguments for each character.
We first set `$a=$args` as the input argument. Then we set `$x` equal to the `.count` of that array `-1`. We then need to loop through the letters to construct the spaceship. That's done by constructing a range from `0` to `$x`, then `$x` back down to `0`, then using `Get-Unique` to pull out just the appropriate range.
Each iteration, we take our input arguments and `-join` them together with the corresponding number of spaces. Each of those strings is left on the pipeline, and an implicit `Write-Output` gives us newlines for free when the program completes.
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~25~~ ~~22~~ 13 bytes
```
zZv"Gtz@he!1e
```
[Try it online!](https://tio.run/##y00syfn/vyqqTMm9pMohI1XRMPX/f3VDI2MTUzNzC0sDdQA "MATL – Try It Online")
Thanks to [Luis Mendo](https://codegolf.stackexchange.com/users/36398/luis-mendo) for suggesting a 5 byte golf, which then inspired me to shave off 4 more bytes!
Explanation, with example input `'abc'`:
```
         # Implicit input, 'abc'
z        # find number of nonzero elements (length of string)
         # stack: [3]
Zv       # symmetric range
         # stack: [[1 2 3 2 1]]
"        # begin for loop, iterating over [1 2 3 2 1] as the loop indices
G        # push input
         # stack: ['abc']
tz       # dup and push length
         # stack: ['abc', 3]
@        # push loop index, i (for example, 2)
         # stack: ['abc', 3, 2]
h        # horizontally concatenate
         # stack: ['abc', [3, 2]]
e!       # reshape to matrix of 3 rows and i columns, padding with spaces, and transpose
         # stack: [['abc';'   ';'   ']]
1e       # reshape to matrix of 1 row, leaving last value on stack
         # stack: ['a  b  c  ']
         # implicit end of for loop
         # implicit end of program, display stack contents
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~9~~ 8 bytes
*-1 byte from @Shaggy*
```
ÊÆ¬qXîÃê
```
---
```
ÊÆ¬qXîÃê        Full program, implicity input U
ÊÆ              Range from 0 to U length and map
  ¬             split U at ""
   qXîÃ         join U using " " times range current value
        ê       horizontal mirror
```
[Try it online!](https://tio.run/##y0osKPn//3DX4bZDawojDq873Hx41f//SsEFicmpxRmZBUoKukEA)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
jⱮLḶ⁶ẋƲŒḄ
```
[Try it online!](https://tio.run/##ATQAy/9qZWxsef//auKxrkzhuLbigbbhuovGssWS4biE/8OHKy/igqzFkuG5mP//U3BhY2VzaGlw "Jelly – Try It Online")
Returns a list of lines; output prettified over TIO.
[Answer]
# [Pyth](https://pyth.readthedocs.io), 12 bytes
Just my mandatory Pyth submission. I am quite proud of this so an explanation will likely come soon.
```
+P_=jRQ*L;_U
```
[Try it here!](https://pyth.herokuapp.com/?code=%2BP_%3DjRQ%2aL%3B_U&input=%22E%3DMC%5E2%22&debug=0)
```
+P_=jRQ_.e*d
```
[Try it here!](https://pyth.herokuapp.com/?code=j%2BP_%3DjRQ_.e%2ad&input=%22E%3DMC%5E2%22&debug=0)
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 10 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
Ç·9ƒù▌╘Ä┘e
```
[Run and debug it](https://staxlang.xyz/#p=80fa399f97ddd48ed965&i=%220123456789%22%0A%22%40%22%0A%22test%22%0A%22%3F%21%22%0A%22Spaceship%22%0A%2205AB1E%22&a=1&m=2)
Outputs with trailing whitespace on each line.
Explanation:
```
%R|pmx{]n(m Full program, unpacked, implicit input
%           Length of input
 R          1-based range
  |p        Palindromize
    m       Map:
     x{   m   Map over characters of input:
       ]        Character -> string
        n(      Right-pad to length given by outer map value
              Implicit flatten and output
```
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), 115 bytes
```
s->{for(int l=s.length(),i=-l;++i<l;)System.out.printf(s.replaceAll(".","%-"+(i<0?l+i:l-i)+"s")+"%n",s.split(""));}
```
[Try it online!](https://tio.run/##rU/LTsMwELz3KxZLlWySWC1QHk3TUhAHDpxyRBxMmrRbHMeKnUqoyreHPEojgVQuWLK9OzP2zG7FTnjb1UeFqc5yC9u654VFyc/9wS8sKVRkMVMNGUlhDLwIVLAfAOjiXWIExgpbX7sMV5DWHA1tjmr9@gYiXxvWSgEeM2WKNM5nHTuHJGjxynjzfZLlFJUFGRguY7W2G8pcDDzpOw7OpM/CT2PjlGeF5bp@bhNqeB5rKaJ4KSUlnLhk6BGH4my0kA5OpYfMIYbUx1AR13CjJVpKCGN@Wfmt9TGnjY01EBySApDxxeXV5Prm9m5E3G/svi8bfd8tzvo61HUis0HdQ6PJ8mH8dOjLzrmZt3NvvaddAnYM8HNcqSh5VrqolQScVs38E1qvXeSkpmcTLqIo1pb@@S/5B7YcNLusvgA "Java (JDK 10) – Try It Online")
* -2 bytes thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
[Answer]
# Oracle SQL, 115 bytes
Not a golfing language but...
```
SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))FROM t CONNECT BY LEVEL<2*LENGTH(v)
```
Assuming that the value is in column `v` of table `t`:
[SQL Fiddle](http://sqlfiddle.com/#!4/07659/13)
**Oracle 11g R2 Schema Setup**:
```
CREATE TABLE t ( v ) AS
  SELECT 'test' FROM DUAL;
```
**Query 1**:
```
SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))
FROM   t
CONNECT BY LEVEL<2*LENGTH(v)
```
**[Results](http://sqlfiddle.com/#!4/07659/13/0)**:
(SQLFiddle prints the values right-aligned in the column for some reason... there are no leading spaces)
```
| TRIM(REGEXP_REPLACE(V,'(.)',LPAD('\1',1+LENGTH(V)-ABS(LEVEL-LENGTH(V))))) |
|---------------------------------------------------------------------------|
|                                                                      test |
|                                                                   t e s t |
|                                                                t  e  s  t |
|                                                             t   e   s   t |
|                                                                t  e  s  t |
|                                                                   t e s t |
|                                                                      test |
```
[Answer]
## [Perl 5](https://www.perl.org/) + `-M5.010 -nlF`, 34 bytes
```
$,=$"x($#F-abs),say@F for-$#F..$#F
```
[Try it online!](https://tio.run/##K0gtyjH9/19Fx1ZFqUJDRdlNNzGpWFOnOLHSwU0hLb9IFyikpwck/v934CpJLS7hslfkCi5ITE4tzsgs4DIwdXQydOXSrNWP4TIwNDI2MTUzt7A0@JdfUJKZn1f8X9fXVM/A0OC/bl6OGwA "Perl 5 – Try It Online")
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~25~~ 24 bytes
**Solution:**
```
,/'(1+a,1_|a:!#x)$\:+,x:
```
[Try it online!](https://tio.run/##y9bNz/7/X0dfXcNQO1HHML4m0UpRuUJTJcZKW6fCSim4IDE5tTgjs0Dp/38A "K (oK) – Try It Online")
**Explanation:**
Port of my [K4 solution](https://codegolf.stackexchange.com/a/171725/69200):
```
,/'(1+a,1_|a:!#x)$\:+,x: / the solution
                      x: / save input as x
                     ,   / enlist
                    +    / flip
                 $\:     / pad ($) right by each-left (\:)
   (            )        / do this together
              #x         / count length of input,           e.g. 3
             !           / range 0..length,                 e.g. 0 1 2
           a:            / save as a
          |              / reverse it,                      e.g. 2 1 0
        1_               / drop first,                      e.g. 1 0
      a,                 / join to a,                       e.g. 0 1 2 1 0
    1+                   / add 1,                           e.g. 1 2 3 2 1
,/'                      / flatten (,/) each (')
```
**Notes:**
* -1 byte thanks to ngn
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~115~~, ~~109~~, ~~105~~, ~~100~~, ~~97~~, ~~96~~, ~~92~~, ~~91~~, ~~90~~, 82 bytes
-5 & -3 thanks to [Kevin Cruissen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
-8 thanks to [roblogic](https://codegolf.stackexchange.com/users/15940/roblogic)
```
for((c=f=1;f;c-=2*(f>=${#1}),f+=c))
{ printf '%-'${f}'.c' `grep -o .<<<"$1"`
echo
}
```
[Try it online!](https://tio.run/##BcFBDsIgEADAO6/YVAyg0kSvgJ/wA8WVlV4KYb0R3o4z78h5zpbiB9hRaVpjoHB35NCGx0XTM8h@4mFudA1ojOhQ2378CNTZKtlpqBUVbN@WKtgCq/d@kbxsImEuYsz5qhET573@AQ "Bash – Try It Online")
---
Note that since the `\` is a shell escape char, the test case `)}/\` should be entered with an extra `\` like this: `)}/\\`.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `j`, 5 bytes
```
ż∞v↲∩
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJqIiwiIiwixbziiJ524oay4oipIiwiIiwiW1wiYVwiLFwiYlwiLFwiY1wiLFwiZFwiXSJd) -5 bytes thanks to lyxal.
```
ż     # range from 1 to length of input
 ∞    # Palindromised
  v↲  # For each character of the input, pad left by each of the above
    ∩ # Transpose
      # (j flag formats list of lines as a string)
```
[Answer]
# Zsh, ~~95~~ 77 bytes
[Try it online!](https://tio.run/##qyrO@J@moVn9P8tWJVpF2VDXMNY6Lb9IIVNBo1pXJUtPTyWrVjM1OSNfTQ0kXKGgoVKtUWxlpWlYq1lQlJlXkqagqgvRqVKdqaxbG1usoFLxH6SjlitNwdDI2MTUzNzC0gDIUdes1Y@JUQeyDEwdnQxdgYzggsTk1OKMzAIguyS1uASkyl4RpMThPwA)  
~~[95 bytes](https://tio.run/##Fcq9DsIgGIXhvVfxWT8JDEUxcWkx/iRegaN1MA0EQmKbwtBIuHak25Nz3p83WVMWszvjVnSUOnlkjBApJQpC1GJDpccZLNAoOMeXa8Q7QUTHuUgsrt8CFCP1bcvKMs32GzTsGow2ecClU4MZU06Vhpqlfd/XRYfT7S4eBc/pMyhv7FQclA9rddmsyTX/AQ)~~
```
j=$[$#1-1];for i ({-$j..$j})echo&&for x (${(s::)1})printf %-$[$#1-${i#-}]s $x
```
Takes input from argument `$1`. Set `j` to `length-1`. Iterate `i` from `-j` to `j`. For each character `x` in the input string, print `x` and append a number of spaces equal to `length` minus the absolute value of `i`
[Answer]
# [Pascal (FPC)](https://www.freepascal.org/), ~~143~~ 135 bytes
```
var s:string;i,j,l:word;begin read(s);l:=length(s);repeat i:=i+1;for j:=1to l do write(s[j],'':l-abs(l-i)-1);writeln until i=l*2-1 end.
```
[Try it online!](https://tio.run/##HclBDsIgEADAr@ytRYsJHiG8wqPxQMu23WYDZEH7fIweJ1NCXQLrtSy9f4JAtbUJpc3RdExszyzRzbhRAsEQx6ocW8@Ytrb/IFgwNCDr6WrcmgUO603LwBAznEINx/o8XtMwWNZhriNrUtoo9z9O8E6NGMjz5a4NYIq33h8lLFh3Kl8 "Pascal (FPC) – Try It Online")
I will probably win only against Lenguage...
[Answer]
# PHP, ~~88~~ 89 bytes
```
for(;++$i<2*$e=count($a=str_split($argn));)echo join(str_pad("",~-$e-abs($i-$e)),$a),"\n";
```
requires PHP 5 or later for `str_split`. Run as pipe with `-nR` or [try it online](http://sandbox.onlinephpfunctions.com/code/115df30d29922cfe22c71b5920d73f2e4b0d5e18).
[Answer]
# [K4](https://kx.com/download/), 23 bytes
**Solution:**
```
,/'(1+a,1_|a:!#x)$\:$x:
```
**Example:**
```
q)k),/'(1+a,1_|a:!#x)$\:$x:"Spaceship"
"Spaceship"
"S p a c e s h i p "
"S  p  a  c  e  s  h  i  p  "
"S   p   a   c   e   s   h   i   p   "
"S    p    a    c    e    s    h    i    p    "
"S     p     a     c     e     s     h     i     p     "
"S      p      a      c      e      s      h      i      p      "
"S       p       a       c       e       s       h       i       p       "
"S        p        a        c        e        s        h        i        p        "
"S       p       a       c       e       s       h       i       p       "
"S      p      a      c      e      s      h      i      p      "
"S     p     a     c     e     s     h     i     p     "
"S    p    a    c    e    s    h    i    p    "
"S   p   a   c   e   s   h   i   p   "
"S  p  a  c  e  s  h  i  p  "
"S p a c e s h i p "
"Spaceship"
```
**Explanation:**
Has trailing whitespace on each line.
```
,/'(1+a,1_|a:!#x)$\:$x: / the solution
                     x: / save input as x,                 e.g. "abc"
                    $   / string,                          e.g. (,"a";,"b";,"c")
                 $\:    / pad ($) right by each-left (\:)
   (            )       / do this together
              #x        / count length of input,           e.g. 3
             !          / range 0..length,                 e.g. 0 1 2
           a:           / save as a
          |             / reverse it,                      e.g. 2 1 0
        1_              / drop first,                      e.g. 1 0
      a,                / join to a,                       e.g. 0 1 2 1 0
    1+                  / add 1,                           e.g. 1 2 3 2 1
,/'                     / flatten each
```
[Answer]
## C#, 113 105 98 bytes
```
s=>{for(int l=s.Length,i=-l;++i<l;)WriteLine(Join("",s.Select(c=>$"{c}".PadRight(i<0?l+i:l-i))));}
```
[Try it online!](https://tio.run/##bZFRT8IwEMff9ynOhYQtjAVUFBkD0fhiMCFi4oPxoZayXVI73BWMWfbZsWMgm3oPbe5//7v8euXU5kkqtmtCFcH8i7R4D6xq5k9RfRwk0kwjP1RuE0WJFP8X5zo1YmBZq/WbNDKXjAhmVmaBib13wjUmakg77wiWEG4pHGXLJHVQaZAh@VOhIh17GLZl0GrhUAbuc4paGCzh3CeoHNv2yJ8LKbh2eDhq2BnPbX/GFo8YxdrBYWcsWziQbXRNBPm2ADBgxbVKccO0OPBsElzAAzNDS6SXV2BpRO7OW5IXsWEpaEGaIAQlPo3rWAOwu6dn572Ly/5Vx/aq@nU9LSbUlfFJPZ@vGBcU46oud3qTm@5dRcv3rynC7E4wHoNTQBKgKkndH0MVFWD/h/5xpw37yTQMIKPcdoOaeenQL@Vvu9kHlH/vNMOmB/2OW@nJrfLMt98 "C# (.NET Core) – Try It Online")
[Answer]
# **[Scala](https://github.com/scala/scala)**, **82 bytes**
```
for(i<-(0 to a.size)union(-a.size to 0))println(a.map(_+" "*Math.abs(i)).mkString)
```
[Try it online](https://tio.run/##PY5NDoIwEIX3nGLS1YyGhjUREw/AyrgyxgxYtAotactCDGfHEozL7@X9@Zpbnm31VHWAkrWBTwJwUw10EZDd3edwcI7f52Nw2twvlMPJ6ADF39lYGwk5h9VCUOznxjrUuxQzCBZYej0qGoy2BtOVFj0j6mMitHFJdtzjdStAbEoOD8mVR00ku9evNVZaFH457IZWjYKSKZnmLw)
Scala has lot of shortcuts that are helping me here and that is quite readable! 
[**Try Scala**](https://github.com/scala/scala) 
[Answer]
# 8086 machine code, ~~56~~ 53 bytes
```
00000000  bf 35 01 57 ba 01 00 52  be 82 00 b3 ff ac 59 51  |.5.W...R......YQ|
00000010  aa 3c 0d 74 07 b0 20 e2  f7 43 eb f1 b0 0a aa 59  |.<.t.. ..C.....Y|
00000020  00 d1 e3 08 38 cb d6 08  c2 51 eb dc c6 05 24 5a  |....8....Q....$Z|
00000030  b4 09 cd 21 c3                                    |...!.|
00000035
```
Assembled from:
```
org 0x100
use16
        mov di, buffer
        push di
        mov dx, 1
        push dx
nextl:  mov si, 0x82
        mov bl, -1
nextc:  lodsb
        pop cx
        push cx
stor:   stosb
        cmp al, 0x0d
        je cr
        mov al, ' '
        loop stor
        inc bx
        jmp nextc
cr:     mov al, 0x0a
        stosb
        pop cx
        add cl, dl
        jcxz done
        cmp bl, cl
        salc
        or dl, al
        push cx
        jmp nextl
done:   mov [di], byte '$'
        pop dx
        mov ah, 0x09
        int 0x21
        ret
buffer:
```
Test case:
[![screenshot](https://i.stack.imgur.com/AheJe.png)](https://i.stack.imgur.com/AheJe.png)
[Answer]
## Haskell, ~~64~~ ~~60~~ 59 bytes
```
(""#)
a#s|l<-(:a)=<<s,w<-' ':a=l:[x|w<(' '<$s),x<-w#s++[l]]
```
[Try it online!](https://tio.run/##dYwxDoJAEEV7TzEZSIDAXoAMlYWNVtohMRNg1TjAxsFAwdldsbGz/O@9/BvroxXxFgo4@xgxSDYc6CJk4pyTgkiziUwEUc6F5OW8TBSvi0JNspnMFGiallJVvuN7v540wwYAOnaHC7jXeByf@x5CsICnVkf8yh9G/Nduh6Y1u0Es@ndtha/qTe3cBw "Haskell – Try It Online")
```
a#s                         -- take a string of spaces 'a' and the input string 's'
 |l<-(:a)=<<s               -- let 'l' be the current line, i.e. the spaces in 'a'
                            -- appended to each char in 's'
  w<-' ':a                  -- let 'w' be 'a' with an additional space   
 =l                         -- return that 'l'
   :[   |w<(' '<$s)   ]     -- and, if 'w' is shorter than 's',
     x  ,x<-w#s++[l]        -- followed by a recursive call with 'w' 
                            -- and by another copy of 'l'
(""#)                       -- start with an empty 'a'
```
]