( Bu mücadeleden ilham alındı )

Biri diğerinden tam olarak bir karakter uzunluğunda olan iki giriş dizisi verildiğinde, dizeleri ASCII sanatına, sadece yarıya kadar fermuarlı bir fermuarın iki yarısıymış gibi düzenlerler. Uzun kelime fermuarın tabanını oluşturur ve birleşik fermuarlı kısmın ilk ve son karakteridir. Bu paragrafı anlamak zor olduğundan, bazı örneklere bir göz atın:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

Not kadar paragraph(daha uzun kelime), alt fermuar oluşturur ve g r a p hkısım kapsüller e r e dkısmı zipperedve z i p pve p a r abazı bölümleri birbirinden kayık halde bulunmaktadır.

Giriş

• İki ASCII dizgisi , herhangi biri uygun uzunlukta, diğeri ise tam olarak bir karakter daha uzun olacak şekilde garanti edilen herhangi bir formatta .
• Her iki dize de boşluk içermez, ancak yazdırılabilir başka bir ASCII değeri içerebilir.
• Girişi her iki sırada da alabilirsiniz. Lütfen giriş sırasını gönderiminizde belirtiniz.

Çıktı

Fermuarlı kelimelerin, yukarıda tarif edildiği gibi, herhangi bir uygun formatta ortaya çıkan ASCII sanatı gösterimi.

kurallar

• Lider ya da izleyen yeni satırlar veya boşluklar, karakterlerin kendileri doğru bir şekilde hizalandığı sürece isteğe bağlıdır.
• Tam bir program veya bir işlev kabul edilebilir. Bir işlevse, çıktıyı yazdırmak yerine geri gönderebilirsiniz.
• Mümkünse, lütfen başkalarının kodunuzu deneyebilmesi için çevrimiçi bir test ortamına bir bağlantı ekleyin!
• Standart boşluklar yasaktır.
• Bu kod-golf'dür, bu nedenle normal golf kurallarının tümü geçerli olur ve en kısa kod (bayt cinsinden) kazanır.

Örnekler

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

Japt , 31 28 bayt

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

Çevrimiçi test edin! Önce kısa olan ipi alır.

açıklama

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.

Kömür , 33 31 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Önce kısa olan ipi alır. Düzenleme: Orta nokta algılamasını ayarlayarak 2 bayt kaydedildi. Açıklama:

→Ｆ²«

Sırasıyla her bir dizginin üzerine döngü

ＦＬθ«

Sıranın her karakteri üzerinde ilmek yapınız.

§θκ→

Karakteri yazdırın ve fazladan bir kare sağa hareket ettirin.

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

Dizenin ilk yarısında imleci uygun şekilde aşağı veya yukarı hareket ettirin.

Ｊ⁰ＬθＡηθ

İlk dizgiyi yazdırdıktan sonra, ikinci dizginin başlangıç ​​noktasına atlayın ve ilk dizgiyi ikinciyle değiştirin, böylece ikinci döngü için yazdırılır. (Kod her iki döngüde de çalışır, ancak ikinci seferde işlem yapılmaz.)

Pyth , 35 bayt

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

Çevrimiçi deneyin!

Jöle ,  27  26 bayt

Outgolfer Erik sayesinde -1 bayt (tekrar,, ¡yerine ?geçen ve geçen başka bir maddeyi kullanın ¹)

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

Soruda izin verilen şekilde (veya bir karakter listesi döndüren ikili bir bağlantı) sonucu sonucu öndeki beyaz boşlukla basan tam bir program.

Çevrimiçi deneyin!

Nasıl?

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 bayt

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

Çevrimiçi deneyin!

V , 47 38 30 27 26 25 bayt

Sonunda mevcut Jelly cevabını yen / \ /

Üstteki uzun kelimeyle girdi alır

Açıklama geliyor, golf oynamaktan daha fazlası olduğunu sanmıyorum.

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Aşağıdakiler bol miktarda alay ve hava fiyatıyla okunmalıdır .

İşte benim de bir cevap değil golf-dili var iyi de kısa cevaplar dize tabanlı ve ASCII-sanat zorlukları .

Bunu neden kendime yapıyorum?

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 

Jöle , 28 bayt

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

Çevrimiçi deneyin!

Woo Jelly aslında bir ip ve bilim-sanat mücadelesinde yarışıyor ! \O/

05AB1E , 26 23 bayt

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

Çevrimiçi deneyin!

açıklama

Örnek giriş ile = 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 bayt

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

Çevrimiçi deneyin!

Muhtemelen burada yapılacak çok fazla golf sahası var, ancak işte LINQ dışı bir girişim. Önce uzun kelimeyi alan ve çıktıyla birlikte bir dize döndüren Lambda işlevi.

Java 8, 216 bayt

Körili bir lambda: Bir lambayı alır Stringve dan bir Stringyere döndürür String. Dış lambda parametresi daha kısa dizedir.

StringDizi sözdizimi ile s içine endeksleyememek ... talihsiz.

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

açıklama

lkısa girişin uzunluğu ve kısa girişin iikinci yarısının ilk karakterine atıfta bulunmak üzere başlatılan çok amaçlı bir indeks. osonucu biriktirir, psonunda doldurma için boşluklar depolar ve nbunun için bir takma addır "\n".

İlk döngü, iki dizinin ikinci yarısını (daha uzun girişin son karakteri hariç) serpiştirir pve orta çizgi için uygun dolgu miktarını oluşturur .

Bir sonraki satır, çıkışın orta satırını tamamlar.

İkinci döngü için James Gosling'den özür dilerim. Orta çizginin üstündeki ve altındaki çizgileri içten dışa ekler. Döngü girme, iolan l - 1dolgu bir karakter daha kısa dizesinin ilk yarının son karakteri ile birlikte başa eklenmesi böylece. iBir sonraki dolgu maddesi (sonuca eklenen) bir karakter daha kısa olacak şekilde azaltılır. Tamsayı bölme ile, daha uzun olan dizgenin aynı pozisyon karakteri eklenir. Bu tekrar eder ve tamamlanan sonuç döndürülür.

Güzel şeyler

Satır 13 eskiden

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

çünkü boş dize olmadan, +karakter değerlerini bir araya getirip sayısal bir dize ekledim. Bileşik atamasını genişleterek, boş dizgeye ihtiyaç duymadan istenen sonucu veren, 2 bayttan oluşan birleştirme ove t.charAt(i)ilk önce değerlendirilir. Bu, ilk defa bir bileşik atamanın genişlemesinden farklı davrandığını gördüm.

Javascript (ES6), 140 137 133 bayt

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

Bundan daha fazla golf oynayabileceğinden eminim

Mathematica, 174 bayt

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

Giriş

["fermuarlı", "paragraf"]

TXR Lisp , 126 bayt

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

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;

Çevrimiçi olarak çalıştırın -nrveya deneyin .

Perl 5 , 163 bayt

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

Çevrimiçi deneyin!

Önce daha uzun olan dizeyi alır.