(Inspirado por este desafio )

Dadas duas seqüências de entrada, uma das quais é exatamente um caractere mais longo que a outra, organize as sequências na arte ASCII como se fossem duas metades de um zíper com zíper apenas na metade. A palavra mais longa forma a parte inferior do zíper e é o primeiro e o último caractere da parte com zíper combinada. Como esse parágrafo é difícil de entender, dê uma olhada em alguns exemplos:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

Observe como paragraph(a palavra mais longa) forma o zíper inferior, e a g r a p hparte encapsula a e r e dparte zipperede as partes z i p pe p a r asão deslocadas uma da outra.

Entrada

• Duas seqüências ASCII em qualquer formato conveniente , uma garantida para ter um comprimento uniforme e a outra exatamente um caractere maior.
• Nenhuma das cadeias conterá espaço em branco, mas poderá conter qualquer outro valor ASCII imprimível.
• Você pode receber a entrada em qualquer ordem. Indique no seu envio a ordem de entrada.

Saída

A representação artística ASCII resultante das palavras com zíper, como descrito acima, novamente em qualquer formato conveniente.

Regras

• Novas linhas à esquerda ou à direita ou espaços em branco são opcionais, desde que os próprios caracteres estejam alinhados corretamente.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Exemplos

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

Japonês , 31 28 bytes

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

Teste online! Pega a corda mais curta primeiro.

Explicação

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.

Carvão , 33 31 bytes

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

Experimente online! Link é a versão detalhada do código. Pega a corda mais curta primeiro. Editar: salvou 2 bytes ajustando a detecção do ponto médio. Explicação:

→Ｆ²«

Faça um loop sobre cada corda por vez.

ＦＬθ«

Faça um loop sobre cada caractere da sequência.

§θκ→

Imprima o personagem e mova um quadrado extra para a direita.

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

Para a primeira metade da string, também mova o cursor para baixo ou para cima, conforme apropriado.

Ｊ⁰ＬθＡηθ

Depois de imprimir a primeira sequência, pule para o ponto inicial da segunda sequência e substitua a primeira pelo segundo, para que seja impressa no segundo ciclo. (O código é executado nos dois loops, mas na segunda vez é um no-op.)

Pitão , 35 bytes

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

Experimente online!

Geléia ,  27  26 bytes

-1 byte graças a Erik, o Outgolfer (use repeat,, ¡para substituir if ?, e uma cláusula else else ¹)

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

Um programa completo que imprime o resultado com espaço em branco à esquerda, conforme permitido na pergunta (ou um link diádico retornando uma lista de caracteres).

Experimente online!

Quão?

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

Experimente online!

V , 47 38 30 27 26 25 bytes

Finalmente bata a resposta atual do Jelly \ o /

Recebe entrada com a palavra mais longa no topo

A seguir, não pense que há muito mais para jogar golfe.

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

Experimente online!

Explicação

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

Experimente online!

O texto a seguir deve ser lido com bastante sarcasmo e citações no ar .

Aqui está uma resposta no meu idioma de golfe que é boa em suma respostas para desafios baseados em strings e de arte ASCII .

Por que continuo fazendo isso comigo mesmo?

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 

Gelatina , 28 bytes

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

Experimente online!

Woo Jelly está realmente competindo em uma corda e ascii-art desafio! \ o /

05AB1E , 26 23 bytes

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

Experimente online!

Explicação

Com o exemplo 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

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

Experimente online!

Provavelmente muito golfe aqui, mas aqui está uma tentativa inicial não-LINQ. Função Lambda que pega primeiro a palavra mais longa e retorna uma string com a saída.

Java 8, 216 bytes

Um lambda ao curry: leva String e retorna um lambda de Stringpara String. O parâmetro para a lambda externa é a sequência mais curta.

Não sendo possível indexar em String s com sintaxe de matriz é ... lamentável.

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 ungolfed

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

Explicação

lé o comprimento da entrada mais curta e ié um índice multiuso, inicializado para se referir ao primeiro caractere da segunda metade da entrada mais curta. oacumula o resultado, pfinalmente armazena espaços para preenchimento en é um alias para"\n" .

O primeiro loop intercala as segundas metades das duas strings (excluindo o último caractere da entrada mais longa) e cria p a quantidade adequada de preenchimento para a linha do meio.

A próxima linha completa a linha do meio da saída.

Gostaria de me desculpar com James Gosling pelo segundo ciclo. Ele adiciona as linhas acima e abaixo da linha do meio de dentro para fora. Ao inserir o loop, ié l - 1, então um caractere de preenchimento é anexado juntamente com o último caractere da primeira metade da sequência mais curta.ié decrementado para que o próximo preenchimento (anexado ao resultado) seja um caractere menor. Por divisão inteira, o mesmo caractere de posição da string mais longa é anexado. Isso se repete e o resultado concluído é retornado.

Coisas legais

A linha 13 costumava ser

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

porque sem a sequência vazia, +adicionou os valores dos caracteres e anexou uma sequência numérica. Ao expandir a atribuição composta, a concatenação oe t.charAt(i)é avaliada primeiro, o que gera o resultado desejado sem a necessidade da cadeia vazia, economizando 2 bytes. É a primeira vez que vejo uma atribuição composta se comportar de maneira diferente de sua expansão.

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

Certeza de que isso pode ser jogado ainda mais

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

["com zíper", "parágrafo"]

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;

Corra com -nrou experimente online .

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

Experimente online!

Leva a corda mais longa primeiro.