(Inspiré par ce défi )

Étant donné deux chaînes d'entrée, dont l'une est exactement d'un caractère plus longue que l'autre, organisez les chaînes en art ASCII comme s'il s'agissait de deux moitiés d'une fermeture éclair qui n'est qu'à moitié fermée. Le mot le plus long forme le bas de la fermeture éclair et est le premier et le dernier caractère de la partie à fermeture éclair combinée. Comme ce paragraphe est difficile à comprendre, jetez un œil à quelques exemples:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

Notez comment paragraph(le mot le plus long) forme la fermeture à glissière inférieure, et la g r a p hpartie encapsule la e r e dpartie de zippered, et les parties z i p pet p a r asont décalées les unes par rapport aux autres.

Contribution

• Deux chaînes ASCII dans n'importe quel format pratique , avec une longueur garantie et l'autre exactement un caractère plus long.
• Aucune chaîne ne contiendra d'espace, mais peut contenir toute autre valeur ASCII imprimable.
• Vous pouvez prendre l'entrée dans l'un ou l'autre ordre. Veuillez indiquer dans votre soumission l'ordre de saisie.

Production

La représentation artistique ASCII résultante des mots zippés, comme décrit ci-dessus, à nouveau dans n'importe quel format pratique.

Règles

• Les sauts de ligne ou les espaces de début ou de fin sont tous facultatifs, tant que les caractères eux-mêmes s'alignent correctement.
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) gagne.

Exemples

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

Japt , 31 28 octets

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

Testez-le en ligne! Prend la chaîne la plus courte en premier.

Explication

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.

Fusain , 33 31 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend la chaîne la plus courte en premier. Modifier: enregistré 2 octets en modifiant la détection du point médian. Explication:

→Ｆ²«

Faites une boucle sur chaque chaîne à tour de rôle.

ＦＬθ«

Faites une boucle sur chaque caractère de la chaîne à tour de rôle.

§θκ→

Imprimez le personnage et déplacez un carré supplémentaire vers la droite.

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

Pour la première moitié de la chaîne, déplacez également le curseur vers le bas ou vers le haut selon le cas.

Ｊ⁰ＬθＡηθ

Après avoir imprimé la première chaîne, passez au point de départ de la deuxième chaîne et remplacez la première chaîne par la seconde, afin qu'elle soit imprimée pour la deuxième boucle. (Le code s'exécute sur les deux boucles, mais la deuxième fois, c'est un no-op.)

Pyth , 35 octets

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

Essayez-le en ligne!

Gelée ,  27  26 octets

-1 octet grâce à Erik the Outgolfer (utilisez la répétition,, ¡pour remplacer if ?, et une clause else passée ¹)

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

Un programme complet qui imprime le résultat avec un premier espace blanc, comme autorisé dans la question (ou un lien dyadique renvoyant une liste de caractères).

Essayez-le en ligne!

Comment?

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 octets

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

Essayez-le en ligne!

V , 47 38 30 27 26 25 octets

Enfin battre la réponse Jelly actuelle \ o /

Prend la saisie avec le mot le plus long en haut

Explication à venir, ne pensez pas qu'il y a beaucoup plus à jouer au golf.

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Ce qui suit doit être lu avec beaucoup de sarcasmes et de citations aériennes .

Voici une réponse dans ma langue de golf qui est bonne pour les réponses courtes aux défis basés sur les cordes et l'art ASCII .

Pourquoi je continue de me faire ça?

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 

Gelée , 28 octets

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

Essayez-le en ligne!

Woo Jelly participe actuellement à un défi de cordes et d' ascii-art ! \ o /

05AB1E , 26 23 octets

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

Essayez-le en ligne!

Explication

Avec un exemple d'entrée = 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 octets

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

Essayez-le en ligne!

Probablement beaucoup de golf à faire ici, mais voici une première tentative non-LINQ. Fonction lambda qui prend le mot le plus long en premier et renvoie une chaîne avec la sortie.

Java 8, 216 octets

Une lambda au curry: prend Stringet renvoie une lambda de StringàString . Le paramètre du lambda externe est la chaîne la plus courte.

Ne pas pouvoir indexer en Strings avec la syntaxe du tableau est ... malheureux.

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

Explication

lest la longueur de l'entrée la plus courte et iest un index polyvalent, initialisé pour faire référence au premier caractère de la seconde moitié de l'entrée la plus courte. oaccumule le résultat, pstocke finalement des espaces pour le rembourrage et nest un alias pour"\n" .

La première boucle entrelace les deuxièmes moitiés des deux chaînes (à l'exclusion du dernier caractère de l'entrée la plus longue) et construit p la quantité appropriée de remplissage pour la ligne médiane.

La ligne suivante complète la ligne médiane de sortie.

Je voudrais m'excuser auprès de James Gosling pour la deuxième boucle. Il ajoute les lignes au-dessus et au-dessous de la ligne médiane de l'intérieur vers l'extérieur. Entrer dans la boucle iest l - 1, donc un caractère de remplissage est ajouté avec le dernier caractère de la première moitié de la chaîne la plus courte.iest décrémenté de sorte que le remplissage suivant (ajouté au résultat) soit un caractère plus court. Par division entière, le même caractère de position de la chaîne plus longue est ajouté. Cela se répète et le résultat terminé est renvoyé.

Truc cool

La ligne 13 était autrefois

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

car sans la chaîne vide, +ajouté les valeurs de caractères ensemble et ajouté une chaîne numérique. En développant l'affectation composée, la concaténation de oet t.charAt(i)est évaluée en premier, ce qui donne le résultat souhaité sans avoir besoin de la chaîne vide, économisant 2 octets. C'est la première fois que je vois une affectation composée se comporter différemment de son expansion.

Javascript (ES6), 140 137 133 octets

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

Bien sûr, cela peut être joué plus loin

Mathematica, 174 octets

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

Contribution

["zippé", "paragraphe"]

TXR Lisp , 126 octets

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

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;

Courez avec -nrou essayez-le en ligne .

Perl 5 , 163 octets

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

Essayez-le en ligne!

Prend d'abord la chaîne la plus longue.