[Question]
  [
*(Inspired by [this challenge](https://codegolf.stackexchange.com/q/102496/42963))*
Given two input strings, one of which is exactly one character longer than the other, arrange the strings into ASCII art as if they are two halves of a zipper that is only halfway zippered. The longer word forms the bottom of the zipper, and is the first and last character of the combined zippered portion. Since that paragraph is hard to understand, take a look at some examples:
```
zippered
paragraph
 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p
```
Note how `paragraph` (the longer word) forms the bottom zipper, and the `g r a p h` portion encapsulates the `e r e d` portion of `zippered`, and the `z i p p` and `p a r a` portions are offset from each other.
## Input
* Two ASCII strings [in any convenient format](http://meta.codegolf.stackexchange.com/q/2447/42963), with one guaranteed to be even in length and the other exactly one character longer.
* Neither string will contain whitespace, but may contain any other printable ASCII value.
* You can take the input in either order. Please state in your submission the input order.
## Output
The resulting ASCII art representation of the zippered words, as described above, again in any convenient format.
## Rules
* Leading or trailing newlines or whitespace are all optional, so long as the characters themselves line up correctly.
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* If possible, please include a link to an online testing environment so other people can try out your code!
* [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.
## Examples
```
ppcg
tests
 p
   p
    sctgs
  e
t
string
strings
 s
   t
     r
      iinnggs
    r
  t
s
```
  
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~31~~ 28 bytes
```
N®¬£ç iXYm½*Ul
uUo mw
y c ·y
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=Tq6so+cgaVhZbb0qVWwKdVVvIG13CnkgYyC3eQ==&input=InBwY2ciCiJ0ZXN0cyI=) Takes the shorter string first.
### Explanation
```
N®¬£ç iXYm½*Ul    First line: Set U to the result.
N®                Map each item (there's exactly 2 of them) in the input to
  ¬                 the item split into chars,
   £                with each item X and index Y mapped to
    ç                 the first input filled with spaces,
      iX              with X inserted at index
        Ym½*Ul          min(Y, 0.5 * U.length).
                  At the end each input is an array like
                  ["p    ", " p   ", "  c  ", "  g  "]
                  ["t    ", " e   ", "  s  ", "  t  ", "  s  "]
uUo mw    Second line: Set V to the result (though that's not important).
 Uo       Pop the last item (the array representing the second string) from U.
    m     Map each item by
     w      reversing.
u         Push the result to the beginning of U.
          At the end we have e.g.
          ["    t", "   e ", "  s  ", "  t  ", "  s  "]
          ["p    ", " p   ", "  c  ", "  g  "]
y c ·y    Last line: Output the result of this line.
y         Transpose: map [[A,B,C,...],[a,b,c,...]] to [[A,a],[B,b],[C,c],...].
  c       Flatten into one array. [A,a,B,b,C,c,...]
    ·     Join on newlines. Now we have the output transposed.
     y    Transpose rows with columns.
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~33~~ 31 bytes
```
→Ｆ²«ＦＬθ«§θκ→¿‹κ÷Ｌθ²¿ι↑↓»Ｊ⁰ＬθＡηθ
```
[Try it online!](https://tio.run/##VY5BCsIwEEXX6SlmmUAK0qWuCt1UFET0AKFNm9CapEmsovTsMa1CcTd//rzHVILZSrM@hKMeOd6eZSs82SWNtoAzAu8ELeOBq9YLPJBlhU5WKo9zX6qaP/FAoSMRQuhfgpBsZtQ53FEolS/kKGu@yihkJBrnK0ngC18NAd47/ouFfqhZNSVof7@Zi8YbCus3scmdk63CgsIQ4xTCSxrDLa8TwyxrLTMipGNIXf8B "Charcoal – Try It Online") Link is to verbose version of code. Takes the shorter string first. Edit: Saved 2 bytes by tweaking the midpoint detection. Explanation:
```
→Ｆ²«
```
Loop over each string in turn.
```
ＦＬθ«
```
Loop over each character of the string in turn.
```
§θκ→
```
Print the character and move an extra square to the right.
```
¿‹κ÷Ｌθ²¿ι↑↓»
```
For the first half of the string, also move the cursor down or up as appropriate.
```
Ｊ⁰ＬθＡηθ
```
After printing the first string, jump to the second string's starting point, and replace the first string with the second, so that it gets printed for the second loop. (The code runs on both loops, but the second time it's a no-op.)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 35 bytes
```
AQj.t.e+*d+lG*<klH*^_1k/h-lGk2b.iHG
```
[Try it online!](http://pyth.herokuapp.com/?code=AQj.t.e%2B%2ad%2BlG%2a%3CklH%2a%5E_1k%2Fh-lGk2b.iHG&input=%22zippered%22%2C%22paragraph%22&debug=0)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~27~~ 26 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-1 byte thanks to Erik the Outgolfer (use repeat, `¡`, to replace if, `?`, and a passed else clause `¹`)
```
JCḂ¡€ṚH
żµL⁶ẋ;Ð€Fṙ"ÇZṙÇṀ$Y
```
A full program that prints the result with leading white-space, as allowed in the question (or a dyadic link returning a list of characters).
**[Try it online!](https://tio.run/##y0rNyan8/9/L@eGOpkMLHzWtebhzlgfX0T2Htvo8atz2cFe39eEJQFG3hztnKh1ujwJSh9sf7mxQifz//79SQWJRYnpRYkGG0n@lqsyCgtSi1BQlAA "Jelly – Try It Online")**
### How?
```
JCḂ¡€ṚH - Link 1, get rotations: list p        e.g.: ["a1","b2","c3","d4","e5","f6","g"]
J       - range of length of p                       [ 1, 2, 3, 4, 5, 6, 7]
    €   - for €ach:
   ¡    -   repeat link:
  Ḃ     - ...# of times: modulo 2                      1  0  1  0  1  0  1
 C      - ...link: complement (1-x)                    0  2 -2  4 -4  6 -6
     Ṛ  - reverse                                    [-6, 6,-4, 4,-2, 2, 0]
      H - halve                                      [-3, 3,-2, 2,-1, 1, 0]
żµL⁶ẋ;Ð€Fṙ"ÇZṙÇṀ$Y - Main link: longer (odd length); shorter (even length)
                   -                           e.g.: "abcdefg", "123456"
ż                  - zip them together               ["a1","b2","c3","d4","e5","f6","g"]
 µ                 - monadic chain separation, call that p
  L                - length of p                     7
   ⁶               - literal space character         ' '
    ẋ              - repeat                          "       "
        F          - flatten p                       "a1b2c3d4e5f"
      Ð€           - map with:
     ;             -   concatenation                 ["       a","       1","       b","       2","       c","       3","       d","       4","       e","       5","       f","       6","       g"]
           Ç       - call last link (1) as a monad with argument p
          "        - zip with (no action on left by trailing values of right):
         ṙ         -   rotate left by                ["  a     ","    1   "," b      ","     2  ","c       ","      3 ","       d","       4","       e","       5","       f","       6","       g"]
            Z      - transpose                       ["    c        ","  b          ","a            ","             "," 1           ","   2         ","     3       ","      d4e5f6g"]
                $  - last two links as a monad:
              Ç    -   call last link (1) as a monad with argument p
               Ṁ   -   maximum                       3
             ṙ     - rotate left by                  ["             "," 1           ","   2         ","     3       ","      d4e5f6g","    c        ","  b          ","a            "]
                 Y - join with newlines            '''             \n
                                                       1           \n
                                                         2         \n
                                                           3       \n
                                                            d4e5f6g\n
                                                          c        \n
                                                        b          \n
                                                      a            '''
                   - as full program: implicit print
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~128~~ 119 bytes
```
f=lambda a,b,n=0:n/2<len(a)and' '*-~n+a[0]+'\n'+f(a[1:],b[1:],n+2)+'\n'+' '*n+b[0]or' '*n+''.join(sum(zip(b,a+' '),()))
```
[Try it online!](https://tio.run/##JcrBDoIwEATQX@G2u3ZV7JHIlyCHbQCpgW1T8aAHf72CXCaTmRffyxjU5jzUk8yuk0LYsdZlpWd7nXpFIdEOCjgcv2qkKVsDNwUzoDSXqmX3TzWW9n2TatzqQto7wOkRvOLzNePHR3QsmyJGIsoxeV2KAWG9Yp/6DhiiJLkniSNQ/gE "Python 2 – Try It Online")
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~47~~ ~~38~~ ~~30~~ ~~27~~ ~~26~~ 25 bytes
Finally beat the current Jelly answer \o/
Takes input with the longer word on top
Explanation coming, don't think there's much more to golf.
```
òGxplòxãòd|>HÏpd|>GGÏphl
```
[Try it online!](https://tio.run/##K/v///Am9wr@gpzDmyoOLz68KaXGzuNwfwGQcncH0hk5//8XJBYlphclFmRwVWUWFKQWpaYAAA "V – Try It Online")
### Explanation
```
ò     ò      ' <M-r>ecursively
             |abc
             def
 Gx          ' (G)oto the last line and (x) the first character
             abc
             |ef
            ' <C-O> Go back to the previous location
             |abc
             ef
    p        ' (p)aste the character cut
             a|dbc
             ef
     l       ' move one character right
             ad|bc
             ef
```
```
x                  ' (x) the last extraneous character from the previous loop
 ã                 ' <M-c>enter the cursor
  ò                ' <M-r>ecursively
   d|              ' (d)elete to the first co(|)umn
     >H            ' (>) Indent every line from here to (H)ome (first line)
                   ' this leaves the cursor on the first line
       Ïp          ' <M-O>n a newline above this (the first) (p)aste the deleted section
                   ' this leaves the cursor on the last character
         d|        ' (d)elete to the first co(|)umn
           >G      ' (>) Indent every line from here to the end (G)
                   ' unfortunately the cursor stays on the first line
             G     ' (G)oto the last line
              Ïp   ' <M-O>n a newline above this (the last) (p)aste the deleted section
                hl ' move left and then right (break the loop at the end)
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), 79 bytes
```
ãl}dÍ./ &
XòYf D"0Pr -Y;D"0pr +òGï"1pÓ./&ò
}dGÓ/&ò
{jpògJòÓó
|DÇ./d
MÙ"-pBr 
```
[Try it online!](https://tio.run/##K/v///DiHLHalMO9evoKalwRhzdFpim4KBkEFCnoRloDGQVFCtqHN7kfXq9kWHB4sp6@2uFNXPxADe6HJ4PZ1VkFhzelex3edHjy4c1cNS6H2/X0U7h8D89U0i1wKlL4/78qs6AgtSg1hasgsSgxvSixIAMA "V – Try It Online")
The following should be read with plenty of sarcasm and *air-quotes*.
> 
> Here's an answer in my *golfing-language* that's *good* at *short* answers to *string-based and ASCII-art challenges*.
> 
> 
> 
Why do I keep doing this to myself?
Hexdump:
```
00000000: e36c 167d 64cd 2e2f 2026 0a58 f259 6620  .l.}d../ &.X.Yf 
00000010: 4422 3050 7220 2d59 3b44 2230 7072 202b  D"0Pr -Y;D"0pr +
00000020: f247 ef22 3170 d32e 2f26 f20a 0f16 7d64  .G."1p../&....}d
00000030: 47d3 2f26 f20a 7b6a 70f2 674a f2d3 f30a  G./&..{jp.gJ....
00000040: 7c44 c72e 2f64 0a4d d922 2d70 4272 20    |D../d.M."-pBr 
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 28 bytes
```
HĊ©«Rµ®Ḥ_,Ṗ
ZLÇṬ€a"¥"o⁶ZẎz⁶Y
```
[Try it online!](https://tio.run/##AVQAq/9qZWxsef//SMSKwqnCq1LCtcKu4bikXyzhuZYKWkzDh@G5rOKCrGEiwqUib@KBtlrhuo564oG2Wf///1sncGFyYWdyYXBoJywgJ3ppcHBlcmVkJ10 "Jelly – Try It Online")
Woo Jelly is actually competing in a [string](/questions/tagged/string "show questions tagged 'string'") *and* [ascii-art](/questions/tagged/ascii-art "show questions tagged 'ascii-art'") challenge! \o/
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~26~~ 23 bytes
```
øS2ä`JIθ«¸«vyNúr})2äR˜»
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8I5go8NLErw8z@04tPoQEJdV@h3eVVSrCRQNOj3n0O7//6syCwpSi1JTuAoSixLTixILMgA "05AB1E – Try It Online")
**Explanation**
With example input = `ppcg, tests`
```
ø                           # zip the input strings
                            # STACK: ['tp', 'ep', 'sc', 'tg']
 S                          # split to a list of characters
                            # STACK: ['t', 'p', 'e', 'p', 's', 'c', 't', 'g'
  2ä                        # divide the list into 2 parts
    `                       # push them as separate to stack
                            # STACK: ['t', 'p', 'e', 'p'], ['s', 'c', 't', 'g']
     J                      # join the second part to a single string
      Iθ«                   # append the tail of the second input
         ¸«                 # concatenate the 2 lists
                            # STACK: ['t', 'p', 'e', 'p', 'sctgs']
           v                # for each y,N (element, index) in the list
            yNú             # prepend N spaces to y
               r            # reverse the stack
                })          # end loop and wrap the stack in a list
                            # STACK: ['    sctgs', '  e', 't', ' p', '   p']
                  2ä        # split the list into 2 parts
                    R       # reverse the list
                            # STACK: [[' p', '   p'], ['    sctgs', '  e', 't']]
                     ˜»     # flatten the list and join on newlines
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 163 bytes
```
(l,s)=>{var o="";int i=0,k=s.Length;for(;i<k;)o+=i<k/2?s[i++]+"\n"+"".PadLeft(i):l[i]+""+s[i++];o+=l[i]+"\n";for(i=k/2;i>0;)o+="".PadLeft(--i)+l[i]+"\n";return o;}
```
[Try it online!](https://tio.run/##VYyxTsMwFEV3f4X1JltOQsWI6zAgMRUJiYGhMFiJ6z412MHPqQRRvj1Y7QBMVzo653ZUdzG5dSIMnr98UXYfmnWDJeKfM6NsM3b8HLHnTxaDkDN7nEK3pZxKUPH/23JvVjFUJE07n23i0QBoDJmj2VQnQ83OBZ@P@hCT0Lg9aRmVKXtze097VOpdwVsABdA8237nDlmgvBv2WDioq6FLcSXFvByhKb3GdnN5@9PWNUr16yaXpxR41Muq2UMMFAfXvCbMTngBo03WJzseoYJvHEeXXA9SarYs6w8 "C# (.NET Core) – Try It Online")
Probably a lot of golfing to do here, but here's an initial non-LINQ attempt. Lambda function that takes the longer word first, and returns a string with the ouput.
[Answer]
# Java 8, 216 bytes
A curried lambda: takes `String` and returns a lambda from `String` to `String`. The parameter to the outer lambda is the shorter string.
Not being able to index into `String`s with array syntax is...unfortunate.
```
s->t->{int l=s.length(),i=l/2;String o="",p=o,n="\n";for(;i<l;p+="  ")o=o+t.charAt(i)+s.charAt(i++);o=p+o+t.charAt(i)+n;for(;i-->0;)o=p.substring(l-i--)+s.charAt(i/2)+n+o+p.substring(l-i)+t.charAt(i/2)+n;return o;}
```
## Ungolfed lambda
```
s ->
    t -> {
        int
            l = s.length(),
            i = l / 2
        ;
        String
            o = "",
            p = o,
            n = "\n"
        ;
        for (; i < l; p += "  ")
            o = o + t.charAt(i) + s.charAt(i++);
        o = p + o + t.charAt(i) + n;
        for (; i-- > 0; )
            o =
                p.substring(l-i--)
                + s.charAt(i / 2)
                + n
                + o
                + p.substring(l-i)
                + t.charAt(i / 2)
                + n
            ;
        return o;
    }
```
## Explanation
`l` is the length of the shorter input and `i` is a multipurpose index, initialized to refer to the first character of the second half of the shorter input. `o` accumulates the result, `p` ultimately stores spaces for padding, and `n` is an alias for `"\n"`.
The first loop interleaves the second halves of the two strings (excluding the last character of the longer input) and builds `p` to the proper amount of padding for the middle line.
The next line completes the middle line of output.
I would like to apologize to James Gosling for the second loop. It adds the lines above and below the middle line from the inside out. Entering the loop, `i` is `l - 1`, so one character of padding is prepended along with the last character of the first half of the shorter string. `i` is decremented so that the next padding (appended to the result) is a character shorter. By integer division, the same position character of the longer string is appended. This repeats, and the completed result is returned.
## Cool stuff
Line 13 used to be 
```
o+=t.charAt(i)+""+s.charAt(i++);
```
because without the empty string, `+` added the character values together and appended a numeric string. By expanding the compound assignment, the concatenation of `o` and `t.charAt(i)` is evaluated first, which yields the desired result without need for the empty string, saving 2 bytes. This is the first time I've seen a compound assignment behave differently from its expansion.
[Answer]
# Javascript (ES6), ~~140 137~~ 133 bytes
```
A=(a,b,c=0)=>a[c/2]?` `[d=`repeat`](c+1)+a[0]+`
`+A(a.slice(1),b.slice(1),c+2)+`
`+` `[d](c)+b[0]:` `[d](c)+[...a].map((e,f)=>e+b[f])
```
Quite sure this can be golfed further
[Answer]
# Mathematica, 174 bytes
```
(a=(c=Characters)@#;b=c@#2;T=Table;Column[Join[T[T["  ",i]<>a[[i]],{i,g=Length@a/2}],{T["  ",g+1]<>Riffle[b[[-g-1;;]],a[[-g;;]]]},Reverse@T[T["  ",i]<>b[[i+1]],{i,0,g-1}]]])&
```
  
**Input**
> 
> ["zippered", "paragraph"]
> 
> 
> 
[Answer]
## [TXR Lisp](http://nongnu.org/txr), 126 bytes
```
(defun f(a b :(n 0))(if(<(/ n 2)(length a))` @{""n}@[a 0]\n@(f(cdr a)(cdr b)(+ n 2))\n@{""n}@[b 0]``@{""n}@{(zip b`@a `)""}`))
```
[Answer]
# PHP, ~~149~~ 129 bytes
```
for($r=" ";$x+1<$w=2*$e=strlen($argv[2]);++$x&1||$r[++$i*$w-1]="
")$r[$w*($x&1?$y-1:$e-$y+=$y<$e/2)+$x]=$argv[2-$x%2][$i];echo$r;
```
Run with `-nr` or [try it online](http://sandbox.onlinephpfunctions.com/code/acf3039720d1e5304b6a880c9b86d8790e617bbb).
[Answer]
# [Perl 5](https://www.perl.org/), 163 bytes
```
@a=map{$s=.5*length;[/./g]}<>;say(($"x(2*$_)).$a[0][$_])for 0..$s-1;print$"x(2*$s);print$a[0][$_].$a[1][$_]for$s..@{$a[1]};print$/.($"x(1+2*$s)).$a[1][$s]while$s--
```
[Try it online!](https://tio.run/##NY1NCoMwEIX3PUUpszAWx6Tgylq8QE8gQQJNNWB1SIT@iFdvaoPu5j2@7w1p22Xel6p4KJrAFZjFne6bsc2rFNNGzudL7tQ7iuDwik4x1IwhqIrLCmrJ7oPdc0RwicjJmn5cKcfWuJF/R4RrUcAhllNo5pVLMTwQxyCzDXfy2ZpOL/uJ96SsaqyidvcxRNrq23eg0Qy988k1Qy74Dw "Perl 5 – Try It Online")
Takes the longer string first.
]