（受此挑战启发）

给定两个输入字符串（其中一个字符串比另一个字符串长一个字符），将这些字符串按ASCII艺术形式排列，就好像它们是仅拉链一半的拉链的两半一样。较长的单词构成拉链的底部，并且是组合的拉链部分的第一个和最后一个字符。由于难以理解该段，因此请看一些示例：

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

请注意paragraph（较长的单词）如何形成底部拉链，并且该g r a p h部分封装的e r e d部分zippered，并且z i p p和p a r a部分彼此偏移。

输入项

• 两个ASCII字符串，可采用任何方便的格式，其中一个保证长度均匀，而另一个则保证一个字符长。
• 这两个字符串都不包含空格，但是可以包含任何其他可打印的ASCII值。
• 您可以按任何顺序输入。请在您的提交中说明输入顺序。

输出量

如上所述，所得到的拉链字的ASCII艺术表示形式还是任何方便的格式。

规则

• 前导或尾随的换行符或空格都是可选的，只要字符本身正确对齐即可。
• 完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
• 如果可能，请提供一个在线测试环境的链接，以便其他人可以尝试您的代码！
• 禁止出现标准漏洞。
• 这是代码高尔夫球，因此所有常用的高尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

例子

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

Japt，31 28字节

N®¬£ç iXYm½*Ul
uUo mw
y c ·y

在线测试！首先获取较短的字符串。

说明

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.

木炭，33 31字节

→Ｆ²«ＦＬ諧θκ→¿‹κ÷Ｌθ²¿ι↑↓»Ｊ⁰ＬθＡηθ

在线尝试！链接是详细版本的代码。首先获取较短的字符串。编辑：通过调整中点检测保存了2个字节。说明：

→Ｆ²«

依次遍历每个字符串。

ＦＬθ«

依次循环遍历字符串的每个字符。

§θκ→

打印字符，然后向右移动一个额外的正方形。

¿‹κ÷Ｌθ²¿ι↑↓»

对于字符串的前半部分，还可以根据需要上下移动光标。

Ｊ⁰ＬθＡηθ

在打印第一个字符串之后，跳到第二个字符串的起点，然后用第二个字符串替换第一个字符串，以便为第二个循环打印它。（代码在两个循环上运行，但是第二次是空操作。）

Pyth，35个字节

AQj.t.e+*d+lG*<klH*^_1k/h-lGk2b.iHG

在线尝试！

果冻， 27  26 字节

-1个字节，感谢Outgolfer的Erik（使用repeat 、、¡替换if ?，和传递的else子句¹）

JCḂ¡€ṚH
żµL⁶ẋ;ЀFṙ"ÇZṙÇṀ$Y

一个完整的程序，该打印程序将在问题允许的范围内使用前导空格打印结果（或者返回一个字符列表的二元链接）。

在线尝试！

怎么样？

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

Python 2中，128个 119字节

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+' '),()))

在线尝试！

V，47 38 30 27 26 25字节

最终击败了当前的果冻答案\ o /

输入带有较长单词的输入

解释即将到来，不要认为高尔夫还有更多。

òGxplòxãòd|>HÏpd|>GGÏphl

在线尝试！

说明

ò     ò      ' <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)

V，79字节

ãl}dÍ./ &
XòYf D"0Pr -Y;D"0pr +òGï"1pÓ./&ò
}dGÓ/&ò
{jpògJòÓó
|DÇ./d
MÙ"-pBr 

在线尝试！

在阅读以下内容时，请多加讽刺和空话。

下面是我的一个答案高尔夫球语言这是很好的，在很短的答案基于字符串和ASCII艺术的挑战。

为什么我要对自己继续这样做？

十六进制转储：

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 

果冻，28个字节

HĊ©«Rµ®Ḥ_,Ṗ
ZLÇṬ€a"¥"o⁶ZẎz⁶Y

在线尝试！

Woo Jelly实际上正在挑战弦乐器 和 ascii艺术！\ o /

05AB1E，26 23字节

øS2ä`JIθ«¸«vyNúr})2äR˜»

在线尝试！

说明

使用示例输入= 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

C＃（.NET Core），163字节

(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;}

在线尝试！

在这里可能要做很多高尔夫运动，但这是最初的非LINQ尝试。Lambda函数，该函数首先获取较长的单词，然后返回带有输出的字符串。

Java 8，216字节

一个令行禁止的λ：需要String从返回拉姆达String至String。外部lambda的参数是较短的字符串。

String不幸的是，无法使用数组语法索引到s。

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;}

非高尔夫λ

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;
    }

说明

l是较短输入的长度，并且i是一个多用途索引，已初始化为引用较短输入后半部分的第一个字符。o累积结果，p最终存储用于填充的空间，以及n是的别名"\n"。

第一个循环交错两个字符串的后半部分（不包括较长输入的最后一个字符）并进行构建 p为中间行适当的填充量。

下一行完成输出的中间行。

对于第二个循环，我想向詹姆斯·高斯林（James Gosling）道歉。它从内到外在中线上方和下方添加了线。进入循环，i是l - 1，因此在短字符串的前半部分的最后一个字符前加上一个填充字符。i减小，以便下一个填充（添加到结果中）是一个较短的字符。通过整数除法，将附加较长字符串的相同位置字符。重复此过程，并返回完成的结果。

酷的东西

第13行曾经是

o+=t.charAt(i)+""+s.charAt(i++);

因为没有空字符串，+请将字符值加在一起并附加数字字符串。通过扩展复合赋值，首先评估o和的连接t.charAt(i)，这将产生所需的结果，而无需使用空字符串，从而节省了2个字节。这是我第一次看到复合分配的行为与其扩展有所不同。

使用Javascript（ES6），140个137 133字节的

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])

非常确定这可以进一步打高尔夫球

Mathematica，174个字节

(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}]]])&

输入项

[“带拉链”，“段落”]

TXR Lisp，126字节

(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 `)""}`))

PHP，149129字节

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;

运行-nr或在线尝试。

Perl 5，163字节

@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--

在线尝试！

首先获取较长的字符串。