(Zainspirowany tym wyzwaniem )

Biorąc pod uwagę dwa ciągi wejściowe, z których jeden jest dokładnie jeden znak dłuższy od drugiego, ułóż ciągi w grafice ASCII tak, jakby były dwiema połówkami zamka błyskawicznego, który jest tylko w połowie zapięty. Dłuższe słowo tworzy spód zamka i jest pierwszym i ostatnim znakiem połączonej części zamka błyskawicznego. Ponieważ ten akapit jest trudny do zrozumienia, spójrz na kilka przykładów:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

Zwróć uwagę, jak paragraph(dłuższe słowo) tworzy dolny zamek błyskawiczny, a g r a p hczęść otacza e r e dczęść zippered, z i p pa p a r aczęści i są przesunięte względem siebie.

Wkład

• Dwa ciągi ASCII w dowolnym dogodnym formacie , z których jeden ma równą długość, a drugi dokładnie jeden znak dłuższy.
• Żaden ciąg nie będzie zawierał białych znaków, ale może zawierać dowolną inną drukowaną wartość ASCII.
• Możesz wziąć dane wejściowe w dowolnej kolejności. Podaj w swoim zgłoszeniu kolejność wprowadzania.

Wydajność

Wynikowa reprezentacja ASCII spakowanych słów, jak opisano powyżej, ponownie w dowolnym dogodnym formacie.

Zasady

• Wiodące lub końcowe znaki nowej linii lub białe znaki są opcjonalne, o ile same znaki są poprawnie ustawione w linii.
• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
• Jeśli to możliwe, dołącz link do internetowego środowiska testowego, aby inni mogli wypróbować Twój kod!
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

Przykłady

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

Japt , 31 28 bajtów

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

Przetestuj online! Najpierw zajmuje krótszy ciąg.

Wyjaśnienie

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.

Węgiel drzewny , 33 31 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Najpierw zajmuje krótszy ciąg. Edycja: Zapisano 2 bajty, dostosowując wykrywanie punktu środkowego. Wyjaśnienie:

→Ｆ²«

Zapętlaj kolejno każdy łańcuch.

ＦＬθ«

Zapętlaj kolejno każdy znak ciągu.

§θκ→

Wydrukuj postać i przesuń dodatkowy kwadrat w prawo.

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

W pierwszej połowie ciągu przesuń również kursor odpowiednio w dół lub w górę.

Ｊ⁰ＬθＡηθ

Po wydrukowaniu pierwszego ciągu przeskocz do punktu początkowego drugiego ciągu i zastąp pierwszy ciąg drugim, aby został wydrukowany dla drugiej pętli. (Kod działa na obu pętlach, ale za drugim razem nie działa.)

Pyth , 35 bajtów

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

Wypróbuj online!

Galaretka ,  27  26 bajtów

-1 bajt dzięki Erikowi Outgolferowi (użyj powtarzania, ¡w celu zastąpienia if ?, i przesłanej klauzuli else ¹)

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

Pełny program, który drukuje wynik z wiodącą białą spacją, jak dopuszczono w pytaniu (lub diademiczny link zwracający listę znaków).

Wypróbuj online!

W jaki sposób?

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 bajtów

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

Wypróbuj online!

V , 47 38 30 27 26 25 bajtów

Wreszcie pokonaj obecną odpowiedź na galaretkę \ o /

Wprowadza dane z dłuższym słowem na górze

Wyjaśnienia nadchodzą, nie myśl, że jest wiele więcej do golfa.

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

Wypróbuj online!

Wyjaśnienie

ò     ò      ' <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 bajtów

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

Wypróbuj online!

Poniższe fragmenty należy czytać z dużą ilością sarkazmu i cytatów z powietrza .

Oto odpowiedź w moim języku golfowym, która jest dobra w krótkich odpowiedziach na wyzwania związane ze sznurkiem i ASCII .

Dlaczego ciągle to robię?

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 

Galaretka , 28 bajtów

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

Wypróbuj online!

Woo Jelly faktycznie konkuruje w sznurkowym i ascii-artowym wyzwaniu! \ o /

05AB1E , 26 23 bajtów

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

Wypróbuj online!

Wyjaśnienie

Z przykładowym wejściem = 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 bajty

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

Wypróbuj online!

Prawdopodobnie dużo golfa do zrobienia tutaj, ale oto wstępna próba bez LINQ. Funkcja Lambda, która jako pierwsza przyjmuje dłuższe słowo i zwraca ciąg znaków z wyjściem.

Java 8, 216 bajtów

Curried lambda: bierze Stringi zwraca lambda od Stringdo String. Parametrem zewnętrznej lambda jest krótszy ciąg.

Brak możliwości indeksowania do Strings przy pomocy składni tablicowej jest ... niefortunny.

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

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

Wyjaśnienie

ljest długością krótszego wejścia i ijest indeksem uniwersalnym, zainicjowanym w celu odniesienia do pierwszego znaku drugiej połowy krótszego wejścia. ogromadzi wynik, postatecznie przechowuje miejsca na wypełnienie i njest aliasem dla "\n".

Pierwsza pętla przeplata drugą połowę dwóch łańcuchów (wyłączając ostatni znak dłuższego wejścia) i buduje pdo odpowiedniej ilości wypełnienia dla linii środkowej.

Następny wiersz kończy środkowy wiersz wyniku.

Chciałbym przeprosić Jamesa Goslinga za drugą pętlę. Dodaje linie powyżej i poniżej linii środkowej od wewnątrz. Wejście do pętli ijest takie l - 1, że jeden znak dopełnienia jest dodawany wraz z ostatnim znakiem pierwszej połowy krótszego łańcucha. ijest zmniejszane, tak że następne wypełnienie (dołączane do wyniku) jest krótsze. Przez dzielenie liczb całkowitych dołączany jest ten sam znak pozycji dłuższego łańcucha. To się powtarza i zwracany jest pełny wynik.

Fajne rzeczy

Kiedyś była linia 13

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

ponieważ bez pustego ciągu +dodała wartości znaków i dodała ciąg liczbowy. Po rozszerzeniu przypisania złożonego najpierw ocenia się konkatenację oi t.charAt(i), co daje pożądany wynik bez potrzeby stosowania pustego ciągu, co pozwala zaoszczędzić 2 bajty. To pierwszy raz, kiedy przypisanie złożone zachowuje się inaczej niż jego rozszerzenie.

JavaScript (ES6), 140 137 133 bajtów

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

Całkiem pewne, że można dalej grać w golfa

Mathematica, 174 bajty

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

Wkład

[„zapinane na zamek”, „akapit”]

TXR Lisp , 126 bajtów

(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 bajtów

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;

Uruchom -nrlub wypróbuj online .

Perl 5 , 163 bajtów

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

Wypróbuj online!

Najpierw zajmuje dłuższy ciąg.