(Inspirado por este desafío )

Dadas dos cadenas de entrada, una de las cuales es exactamente un carácter más largo que el otro, organice las cadenas en el arte ASCII como si fueran dos mitades de una cremallera que solo tiene la mitad de la cremallera. La palabra más larga forma la parte inferior de la cremallera, y es el primer y último carácter de la porción combinada con cremallera. Dado que ese párrafo es difícil de entender, eche un vistazo a algunos ejemplos:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

Observe cómo paragraph(la palabra más larga) forma la cremallera inferior, y la g r a p hporción encapsula la e r e dporción de zippered, y las porciones z i p py p a r ase compensan entre sí.

Entrada

• Dos cadenas ASCII en cualquier formato conveniente , con una garantizada de longitud uniforme y la otra exactamente un carácter más largo.
• Ninguna cadena contendrá espacios en blanco, pero puede contener cualquier otro valor ASCII imprimible.
• Puede tomar la entrada en cualquier orden. Indique en su envío el orden de entrada.

Salida

La representación artística ASCII resultante de las palabras con cremallera, como se describió anteriormente, nuevamente en cualquier formato conveniente.

Reglas

• Las nuevas líneas iniciales o finales o espacios en blanco son opcionales, siempre que los caracteres se alineen correctamente.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

Japt , 31 28 bytes

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

¡Pruébelo en línea! Toma la cuerda más corta primero.

Explicación

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.

Carbón , 33 31 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma la cuerda más corta primero. Editar: guardado 2 bytes ajustando la detección del punto medio. Explicación:

→Ｆ²«

Pase sobre cada cuerda a su vez.

ＦＬθ«

Pase por cada carácter de la cadena a su vez.

§θκ→

Imprime el personaje y mueve un cuadrado extra a la derecha.

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

Para la primera mitad de la cadena, mueva el cursor hacia abajo o hacia arriba según corresponda.

Ｊ⁰ＬθＡηθ

Después de imprimir la primera cadena, salte al punto de inicio de la segunda cadena y reemplace la primera cadena con la segunda, de modo que se imprima para el segundo bucle. (El código se ejecuta en ambos bucles, pero la segunda vez no funciona).

Pyth , 35 bytes

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

Pruébalo en línea!

Jalea ,  27  26 bytes

-1 byte gracias a Erik the Outgolfer (use repeat,, ¡para reemplazar if ?, y una cláusula else aprobada ¹)

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

Un programa completo que imprime el resultado con espacios en blanco iniciales, como se permite en la pregunta (o un enlace diádico que devuelve una lista de caracteres).

Pruébalo en línea!

¿Cómo?

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

Pruébalo en línea!

V , 47 38 30 27 26 25 bytes

Finalmente vencer a la respuesta actual de Jelly

Toma entrada con la palabra más larga en la parte superior

Explicación que viene, no creo que haya mucho más para el golf.

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

Pruébalo en línea!

Explicación

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

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

Pruébalo en línea!

Lo siguiente debe leerse con mucho sarcasmo y comillas aéreas .

Aquí hay una respuesta en mi lenguaje de golf que es buena para respuestas cortas a desafíos basados en cuerdas y arte ASCII .

¿Por qué sigo haciéndome esto a mí mismo?

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 

Jalea , 28 bytes

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

Pruébalo en línea!

¡Woo Jelly está compitiendo en un desafío de cuerdas y arte ascii ! \ o /

05AB1E , 26 23 bytes

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

Pruébalo en línea!

Explicación

Con entrada de ejemplo = 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 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;}

Pruébalo en línea!

Probablemente hay mucho golf por hacer aquí, pero aquí hay un intento inicial que no es de LINQ. Función Lambda que toma primero la palabra más larga y devuelve una cadena con la salida.

Java 8, 216 bytes

Una lambda al curry: toma Stringy devuelve una lambda de StringaString . El parámetro para el lambda externo es la cadena más corta.

No poder indexar en Strings con sintaxis de matriz es ... desafortunado.

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

Lambda sin golf

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

Explicación

les la longitud de la entrada más corta y ies un índice multipropósito, inicializado para referirse al primer carácter de la segunda mitad de la entrada más corta. oacumula el resultado, pfinalmente almacena espacios para el relleno y nes un alias para"\n" .

El primer bucle intercala las segundas mitades de las dos cadenas (excluyendo el último carácter de la entrada más larga) y se construye pcon la cantidad adecuada de relleno para la línea media.

La siguiente línea completa la línea media de salida.

Me gustaría disculparme con James Gosling por el segundo bucle. Agrega las líneas arriba y abajo de la línea media de adentro hacia afuera. Entrar en el ciclo, ies l - 1, por lo que se antepone un carácter de relleno junto con el último carácter de la primera mitad de la cadena más corta. ise disminuye para que el siguiente relleno (agregado al resultado) sea un carácter más corto. Por división entera, se agrega el mismo carácter de posición de la cadena más larga. Esto se repite y se devuelve el resultado completo.

Cosas interesantes

La línea 13 solía ser

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

porque sin la cadena vacía, +agregó los valores de los caracteres y agregó una cadena numérica. Al expandir la asignación compuesta, la concatenación de oy t.charAt(i)se evalúa primero, lo que produce el resultado deseado sin necesidad de la cadena vacía, ahorrando 2 bytes. Esta es la primera vez que veo una asignación compuesta que se comporta de manera diferente a su expansión.

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

Muy seguro de que esto se puede jugar más golf

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

Entrada

["con cremallera", "párrafo"]

TXR Lisp , 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 `)""}`))

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;

Ejecutar -nro probarlo en línea .

Perl 5 , 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--

Pruébalo en línea!

Toma la cuerda más larga primero.