[Question]
  [
Given an input string of length `2` or longer consisting solely of alphabetical characters `[A-Z]` or `[a-z]` (your choice if they're all uppercase or all lowercase), output a continuous string of characters forming a double diamond pattern.
The input string starts on the center line and extends down-and-right at a diagonal until the end of the input string is reached. Then, the pattern continues up-and-right at a diagonal until you're as far above the center line as the length of the input string minus 1. Continue down-and-right back to the center line, then down-and-left, then up-and-left (going "behind" the center character), and finally down-and-left back to the starting character.
That's a little wordy, and it's better demonstrated by some examples:
```
"YOU"
  U   Y
 Y O U O
Y   O   U
 O Y U Y
  U   O
  ^   ^
 ↙ ↖ ↗ ↘
↘   ↗   >
 ↘ ↗ ↖ ↙
  V   V
```
See how the `YOU` starts at the center line and follows down-and-right, then up-and-right, etc., until it loops back to the beginning. Note especially how the `Y` on the up-and-left portion is "behind" the `O` and therefore not shown.
Some further examples:
```
"HI"
 I I
H H H
 I I
"TEST"
   E     E
  S T   T S
 T   T T   T
T     S     T
 E   E E   E
  S T   T S
   T     T
"HELLO"
    L       L
   O L     E L
  H   E   H   O
 E     H O     H
H       L       E
 E     L L     L
  L   E   L   L
   L H     E O
    O       H
```
---
* Input and output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963).
* The input is guaranteed to be at least two letters long (i.e., you'll never receive `""` as input).
* You can print it to STDOUT or return it as a function result.
* Either a full program or a function are acceptable.
* Any amount of extraneous whitespace is acceptable, so long as the characters line up appropriately (e.g., feel free to pad as a rectangle).
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 17 bytes
```
ＧＨ<↗↘>↖↙ＬθθＧＨ<Ｌθθ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8gP6cyPT/PIz8nJ79cw8pGR8EqtCAoMz2jBMhyyS/Pg7HtwDI@qWkwCQjTJzUvvSRDo1BTR6FQ05oL0zhUBf//e7j6@Pj/1y3LAQA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
ＧＨ
```
Draw along a path.
```
<↗↘>↖↙
```
Draw in the directions ↘↗↗↘↙↖↖↙ (the `<` and `>` are shorthands for those two pairs, but the other pairs don't have shorthands.)
```
Ｌθ
```
Each path segment has the same length, including the ends, of the length of the input.
```
θ
```
Use the input as the text to be written along the path.
```
ＧＨ<Ｌθθ
```
Print the first two parts of the path again so that the middle character is correct.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 12 bytes
```
gIR7._•ÍÎ·•Λ
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/3TPIXC/@UcOiw72H@w5tBzLOzf7/38XT0dffzwUA "05AB1E – Try It Online")
```
           Λ    use the canvas function
g               with the length of input for each segment
 IR7._          the input reversed and rotated left by 7 characters (we will draw this backwards to have the right center character)
      •ÍÎ·•     and the directions 1, 3, 3, 1, 7, 5, 5, 7 as a compressed number. 
```
[Answer]
# JavaScript (ES6), ~~157 155~~ 154 bytes
Returns a matrix of characters.
```
s=>(y=n=s.length,y+=i=X=Y=-1,m=[...Array(y+n)].map(_=>r=Array(4*n-3).fill` `),g=x=>x?g(x-=r[m[y][++i==6*n-6||+x]=s[i%n],y-=m[y-Y]?Y:Y=-Y,x-X]?X:X=-X):m)``
```
[Try it online!](https://tio.run/##LY5Na4QwGITv/RW5lCTNB5SWPVhepQdhCwt76BaUNFSx6mbRZEmWYmD/u3VtT88wMzBzqn/q0Hhzvgjrvtu5gzlASiJYCHJobX858sjAQAEliEc@gpJSvnpfRxKZpVqO9Zl8Qerhz3x@sOKJys4MQ4UqynuYIJ2ynkwCvBpV1IoxA7BZepvrlU0agjL3VvMoYIlFqbMyWbZKPolCZ0VSgChoMtKqml8U3r5hjnC5/7jhkL8fbtzmu90e6zvZOZ/XzZEEBClqnA1uaOXgetKRQNeraxLkyRlLMKb0X31aTBFDK@n8Cw "JavaScript (Node.js) – Try It Online")
### How?
Given the length \$n\$ of the input string, we build a matrix of size \$w\times h\$, with:
* \$w = 4n-3\$
* \$h = 2n-1\$
We run a simulation of a 'ball' bouncing in this matrix, starting at \$(0,n-1)\$ and heading South-East, until it's back to its initial position.
The 0-based index of the center character that must be skipped in the diamond shape is:
$$p=6n-6$$
Example for \$n=4\$:
[![enter image description here](https://i.stack.imgur.com/onMG0.png)](https://i.stack.imgur.com/onMG0.png)
### Commented
```
s => (                           // s = input string
  y = n = s.length,              // n = length of s
  y += i = X = Y = -1,           // y = n - 1; i = X = Y = -1
  m =                            // create a matrix m[]:
    [...Array(y + n)].map(_ =>   //   - of height 2n-1
      r = Array(4 * n - 3)       //   - of width 4n-3 (save one of these rows in r[])
          .fill` `               //   - initially filled with spaces
    ),                           //
    g = x =>                     // g is a recursive function taking x
      x ?                        //   if x is truthy:
        g(                       //     do a recursive call:
          x -= r[                //       update x:
            m[y][                //         update m[y][x]:
              ++i == 6 * n - 6   //           unless this is the 2nd pass through the
              || +x              //           center cell, set it to the next character
            ] = s[i % n],        //           in s (otherwise we write to m[y][true]
                                 //           instead, which has no effect)
            y -=                 //         update y:
              m[y - Y] ? Y       //           bounce vertically if m[y - Y] is undefined
                       : Y = -Y, //
            x - X                //         bounce horizontally
          ] ? X                  //         if r[x - X] is undefined
            : X = -X             //
        )                        //     end of recursive call
      :                          //   else:
        m                        //     stop recursion and return m[]
)``                              // initial call to g with x = [''] (zero-ish but truthy)
```
[Answer]
## JavaScript (ES6), 136 bytes
```
f=
(s,l=s.length-1,z=l*4,a=[...Array(l-~l)].map(_=>Array(z+1).fill` `),g=x=>x--?g(x,a[a[y=(x+l)%z]?y:z-y][x>z?z+z-x:x]=s[x%-~l]):a)=>g(z+z)
```
```
<input oninput=o.textContent=f(this.value).map(c=&gt;c.join``).join`\n`><pre id=o>
```
Returns a two-dimensional array. Works by drawing the string into the array directly computing the destination co-ordinates working backwards from the end so that the centre cell is overwritten automatically. Explanation:
```
(s
```
Input string.
```
,l=s.length-1
```
Distance between "bounces", also half the last row index and one less than the length.
```
,z=l*4
```
Last column index, also half of the length of text to draw.
```
,a=[...Array(l-~l)].map(_=>Array(z+1).fill` `)
```
Array of spaces.
```
,g=x=>x--
```
Count down from the last cell to the first.
```
  ?g(x
```
Recursive call to process the remaining cells.
```
    ,a[a[y=(x+l)%z]?y:z-y]
```
Calculate the row of this cell.
```
      [x>z?z+z-x:x]=s[x%-~l])
```
Calculate the column of this cell and the character that belongs there.
```
  :a
```
Finish by returning the array.
```
)=>g(z+z)
```
Start at the end of the text.
[Answer]
# [J](http://jsoftware.com/), ~~79~~ ~~77~~ 75 bytes
```
(|.@$~8*])`([:;/(1,~<:@])+/\@,(_2{&1 _1\#:33495)}.@#~])`(' '$~1+2 4*])}<:@#
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/NWr0HFTqLLRiNRM0oq2s9TUMdepsrBxiNbX1Yxx0NOKNqtUMFeINY5StjI1NLE01a/UclOtAitUV1FXqDLWNFEyAemuBWpT/a3JxpSZn5CukKah7eKpD2OrqcLEQ1@AQTFEPVx8ff3Uurv8A "J – Try It Online")
[Answer]
# [C (clang)](http://clang.llvm.org/), [~~201~~](https://tio.run/##TY5Ra8IwFIXf@ytKxiBp791sdBtrjEVE1gdZYfZlqA@h6gzYdLRVquJv71J9WSC55zuce28yzPbK/LRtAyfQcIQcjNjSCs4s26nSq8TlVhUUCy1pI8/eADnz6MkqjgFbiW1RUiUroYWRuQxYsUDUK6kfm6jPw6AntGw8xPMteLSaIxdHRKF9C7lvbIfNdw/2edTV0O5T0vN9FamwAtMNGzXYjzAIDeRSPzeRvcMTBlEeWjMQv4e6ogUT1/ZBm2x/WG/cYVWvdfG0GzmONrWbK20ocy/OlpL4mwBnopPpdJ4SGNwhns5mCYGXOyVf48@PKYHX/zgn8HbnSZxMktk4tYl369x@QJZmadyNWRPrOK495aY@lMbtCefa/gE "C (clang) – Try It Online") [~~196~~](https://tio.run/##TY5Pa8JAEMXv@RRhS2E3mW1N0j806xpExBykgeqlqIcl0bpgJiWJkih@9nSNlw4M836PN8OkPD0o/Om6BlrQcIIcUOxoBWeW7lXpVOLSTyUrKFZa0laeHZ97zKGNbN2WbcSuKKnQAmUuPVasONcbqR@bKPBDbyC0bBzOz33qZLTPfXHiXGjXQO6i2TB5GfhRLxwVDkBJx3VVpMIK8HZq1PAg4l6IkEv93ESmhy33ojw0pid@j3VFCyau3YPG9HDMtvawqjNdPO1HlqWxtnOlkTL7Yu0oib8J@Ezc5HK6WBJ4uUM8nc8TAq93Sr7Gn7Mpgbf/uCDwfudJnEyS@XhpEh/G6T8ga1yjvcWMGMeyTZXb@liiPRDWtfsD "C (clang) – Try It Online") 188 bytes
```
x,y,i,v,m,n;f(s,z){char*a=s,o[i=(y=z*2-1)*(x=y+y)];for(v=x*2-2;i;n=m=1)o[--i]=i%x?32:10;for(i=x*--z;v--;i+=x*m+n)o[i]==32?o[i]=*a:0,a=*++a?a:s,n=i%x>x-3?-1:n,m=i/x?i/x<y-1?m:-1:1;puts(o);}
```
[Try it online!](https://tio.run/##TY5Na8JAEIbv@RVhS2E3mW1N7AfNugYR0YM0UL0U9bDEpC6YScmHJIq/PV3NpQMD7/PyMEzM46PCn65roAUNJ8gARUpLOLNLfFCFo2QJ@UZL2sqz43OPObSRrduynUjzgp5kY1pfaIEykx7LN5zrndSPTTj0A29wl7SROD@LE@dCuwYyF41pPDn0w3twVDAAJR3XVaEKSsDbiXHDhyH3AoRM6ucmNDtquRdmgSk98VtXJc2ZuHYPGuNjvU/sUVntdf50GFuWxsrOlEbK7IuVUrL4JuAzcYvr2WpN4KWHxWy5jAi89hR9TT7nMwJv/3FF4L3n6SKaRsvJ2hgfprl/QLa4RTvBPTGNZZspkqou0B4I69r9AQ "C (clang) – Try It Online")
-13 @ceilingcat suggestions
[Answer]
# [Python 2](https://docs.python.org/2/), 137 bytes
```
s=input();n=len(s);m=2*n-2
for r in range(m+1):print''.join([s[[x,-8-x][(x<=m)==(m>2*r)]%n],' '][r!=(x+1-n)%m!=m-r]for x in range(4*n-3))
```
[Try it online!](https://tio.run/##RY/BbsIwEETP8VeYA1obkkqkPVRQVyo0FZWQuPRm@UBTU9LiTbQJqvn61A5IXMZrjXfeuDl3hxrzvqy/rCIA6FtVYXPqhFygOloUrVw4lU8wy9m@Jk68Qk47/LbCTWdy3lCFHcDdT12h0K3WPs0eM2@08E/KSaWEe84nJM0YTQocjKaREn46y1CO3Ui5jEzM9bfchwC7l7IPbRiLEv02@hrW75DCy3J10ddwrIvNZgtmzpKhCm9Zsg@lr9dhn/0dqqPlH3Sy4VlH56CJ9bbk8dssjKVtOl5s3wqimqL7SXb320ccG3DsgmNX3D8 "Python 2 – Try It Online")
A full program that takes a string as input as prints out the diamondized version.
]