(Inspiriert von dieser Herausforderung )

Ordnen Sie die Zeichenfolgen bei zwei Eingabezeichenfolgen, von denen eine genau ein Zeichen länger als die andere ist, in ASCII-Zeichenfolgen so an, als handele es sich um zwei Hälften eines Reißverschlusses, der nur zur Hälfte mit einem Reißverschluss versehen ist. Das längere Wort bildet den unteren Rand des Reißverschlusses und ist das erste und letzte Zeichen des kombinierten Teils mit Reißverschluss. Da dieser Absatz schwer zu verstehen ist, sehen Sie sich einige Beispiele an:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

Beachten Sie, wie paragraph(das längere Wort) den unteren Reißverschluss bildet und der g r a p hTeil den e r e dTeil von einschließt zipperedund die Teile z i p pund p a r avoneinander versetzt sind.

Eingang

• Zwei ASCII-Zeichenfolgen in einem beliebigen Format , wobei die eine garantiert gerade und die andere genau ein Zeichen länger ist.
• Keine der Zeichenfolgen enthält Leerzeichen, kann jedoch einen anderen druckbaren ASCII-Wert enthalten.
• Sie können die Eingabe in beliebiger Reihenfolge vornehmen. Bitte geben Sie bei Ihrer Einsendung die Eingabereihenfolge an.

Ausgabe

Die resultierende ASCII-Grafikdarstellung der Wörter mit Reißverschluss, wie oben beschrieben, wiederum in einem beliebigen geeigneten Format.

Regeln

• Führende oder nachfolgende Zeilenumbrüche oder Leerzeichen sind optional, sofern die Zeichen selbst korrekt ausgerichtet sind.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

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

Online testen! Nimmt zuerst die kürzere Saite.

Erläuterung

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.

Kohle , 33 31 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Nimmt zuerst die kürzere Saite. Bearbeiten: 2 Bytes durch Ändern der Mittelpunkterkennung gespeichert. Erläuterung:

→Ｆ²«

Schleife nacheinander über jede Saite.

ＦＬθ«

Durchlaufen Sie nacheinander die einzelnen Zeichen der Zeichenfolge.

§θκ→

Drucken Sie das Zeichen und bewegen Sie ein zusätzliches Quadrat nach rechts.

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

Bewegen Sie für die erste Hälfte der Zeichenfolge den Cursor entsprechend nach unten oder oben.

Ｊ⁰ＬθＡηθ

Wechseln Sie nach dem Drucken der ersten Zeichenfolge zum Startpunkt der zweiten Zeichenfolge und ersetzen Sie die erste Zeichenfolge durch die zweite, damit sie für die zweite Schleife gedruckt wird. (Der Code wird in beiden Schleifen ausgeführt, aber das zweite Mal ist es ein No-Op.)

Pyth , 35 Bytes

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

Probieren Sie es online!

Jelly ,  27  26 Bytes

-1 Byte dank Erik the Outgolfer (benutze repeat,, ¡um if ?, und eine übergebene else-Klausel zu ersetzen ¹)

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

Ein vollständiges Programm, das das Ergebnis wie in der Frage angegeben mit führenden Leerzeichen ausgibt (oder ein dyadischer Link, der eine Liste von Zeichen zurückgibt).

Probieren Sie es online!

Wie?

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

Probieren Sie es online!

V , 47 38 30 27 26 25 Bytes

Schließe die aktuelle Gelee-Antwort ab \ o /

Nimmt Eingaben mit dem längeren Wort oben auf

Erklärung kommt, glaube nicht, dass Golf mehr zu bieten hat.

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Das Folgende sollte mit viel Sarkasmus und Anführungszeichen gelesen werden .

Hier ist eine Antwort in meiner Golfsprache , die sich gut für kurze Antworten auf stringbasierte und ASCII-artige Herausforderungen eignet .

Warum tue ich mir das immer wieder an?

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 

Gelee , 28 Bytes

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

Probieren Sie es online!

Woo Jelly konkurriert tatsächlich in einer String- und Ascii-Art- Herausforderung! \O/

05AB1E , 26 23 Bytes

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

Probieren Sie es online!

Erläuterung

Mit Beispieleingabe = 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 Byte

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

Probieren Sie es online!

Wahrscheinlich gibt es hier viel Golf zu spielen, aber hier ist ein erster Nicht-LINQ-Versuch. Lambda-Funktion, die das längere Wort zuerst benötigt und eine Zeichenfolge mit der Ausgabe zurückgibt.

Java 8, 216 Bytes

Ein Curry-Lambda: nimmt Stringein Lambda und gibt es von Stringbis zurück String. Der Parameter für das äußere Lambda ist die kürzere Zeichenfolge.

Es Stringist ... bedauerlich, nicht in der Lage zu sein, mit der Array-Syntax in s zu indizieren .

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

Erläuterung

list die Länge der kürzeren Eingabe und iein Mehrzweckindex, der so initialisiert wird, dass er sich auf das erste Zeichen der zweiten Hälfte der kürzeren Eingabe bezieht. oakkumuliert das Ergebnis, pspeichert letztendlich Leerzeichen zum Auffüllen und nist ein Alias ​​für"\n" .

Die erste Schleife verschachtelt die zweiten Hälften der beiden Zeichenfolgen (mit Ausnahme des letzten Zeichens der längeren Eingabe) und bildet pden richtigen Abstand für die mittlere Zeile.

Die nächste Zeile vervollständigt die mittlere Ausgabezeile.

Ich möchte mich bei James Gosling für die zweite Runde entschuldigen. Es fügt die Linien oberhalb und unterhalb der Mittellinie von innen nach außen hinzu. Wenn Sie die Schleife betreten, iwird l - 1ein Zeichen vor dem letzten Zeichen der ersten Hälfte der kürzeren Zeichenfolge eingefügt. iwird dekrementiert, so dass der nächste Abstand (an das Ergebnis angehängt) ein kürzeres Zeichen ist. Durch ganzzahlige Division wird das gleiche Positionszeichen der längeren Zeichenfolge angehängt. Dies wiederholt sich und das fertige Ergebnis wird zurückgegeben.

Cooles Zeug

Linie 13 war früher

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

weil ohne die leere Zeichenfolge +die Zeichenwerte zusammenaddiert und eine numerische Zeichenfolge angehängt wurden. Durch Erweitern der zusammengesetzten Zuweisung wird zuerst die Verkettung von ound t.charAt(i)ausgewertet, wodurch das gewünschte Ergebnis erzielt wird, ohne dass die leere Zeichenfolge erforderlich ist, wodurch 2 Byte eingespart werden. Dies ist das erste Mal, dass ich sehe, dass sich eine zusammengesetzte Zuweisung anders verhält als ihre Erweiterung.

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

Ganz sicher kann dies weiter golfen werden

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

Eingang

["reißverschluss", "absatz"]

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;

Laufen Sie mit -nroder versuchen Sie es 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--

Probieren Sie es online!

Nimmt zuerst die längere Saite.