(แรงบันดาลใจจากความท้าทายนี้ )

รับสายอินพุตสองสายหนึ่งในนั้นคือตัวละครตัวหนึ่งยาวกว่าอีกสายหนึ่งจัดเรียงสตริงให้เป็นงานศิลปะ ASCII ราวกับว่าพวกเขาเป็นซิปสองครึ่งที่ซิปเพียงครึ่งเดียว คำที่ยาวกว่าจะรวมอยู่ที่ด้านล่างของซิปและเป็นอักขระตัวแรกและตัวสุดท้ายของส่วนซิปรวม เนื่องจากย่อหน้านั้นยากที่จะเข้าใจให้ดูตัวอย่าง:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

ให้สังเกตว่าparagraph(คำที่ยาวกว่า) สร้างซิปด้านล่างอย่างไรและg r a p hส่วนที่ห่อหุ้มe r e dส่วนของzipperedและz i p pและและp a r aส่วนต่าง ๆ จะถูกหักล้างกัน

อินพุต

• สตริง ASCII สองรูปแบบในรูปแบบที่สะดวกใด ๆโดยมีหนึ่งสายที่รับประกันว่าจะมีความยาวและอีกสายหนึ่งยาวกว่า
• สตริงจะไม่มีช่องว่าง แต่อาจมีค่า ASCII ที่พิมพ์ได้อื่น ๆ
• คุณสามารถรับอินพุตตามลำดับใดก็ได้ โปรดระบุในการส่งคำสั่งซื้อของคุณ

เอาท์พุต

การแสดงภาพ ASCII แบบศิลปะของคำที่ซิปตามที่อธิบายไว้ข้างต้นอีกครั้งในรูปแบบที่สะดวก

กฎระเบียบ

• ขึ้นบรรทัดใหม่หรือต่อท้ายช่องว่างหรือช่องว่างทั้งหมดเป็นตัวเลือกตราบใดที่ตัวละครตัวเองเข้าแถวอย่างถูกต้อง
• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น หากฟังก์ชั่นคุณสามารถส่งคืนผลลัพธ์มากกว่าการพิมพ์
• หากเป็นไปได้โปรดรวมลิงค์ไปยังสภาพแวดล้อมการทดสอบออนไลน์เพื่อให้ผู้อื่นสามารถลองใช้รหัสของคุณได้!
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการเล่นกอล์ฟตามปกติทั้งหมดและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

ตัวอย่าง

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

Japt , 31 28 ไบต์

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

ทดสอบออนไลน์! ใช้สตริงที่สั้นกว่าก่อน

คำอธิบาย

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.

ถ่าน , 33วันที่ 31 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด ใช้สตริงที่สั้นกว่าก่อน แก้ไข: บันทึก 2 ไบต์โดยปรับการตรวจจับจุดกึ่งกลาง คำอธิบาย:

→Ｆ²«

วนรอบแต่ละสายในทางกลับกัน

ＦＬθ«

วนรอบอักขระแต่ละตัวของสตริงตามลำดับ

§θκ→

พิมพ์ตัวละครและย้ายสแควร์พิเศษไปทางขวา

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

สำหรับครึ่งแรกของสตริงให้เลื่อนเคอร์เซอร์ขึ้นหรือลงตามความเหมาะสม

Ｊ⁰ＬθＡηθ

หลังจากพิมพ์สตริงแรกให้ข้ามไปยังจุดเริ่มต้นของสตริงที่สองและแทนที่สตริงแรกด้วยสตริงที่สองเพื่อให้ได้รับการพิมพ์สำหรับลูปที่สอง (รหัสทำงานบนลูปทั้งสอง แต่ครั้งที่สองมันเป็นแบบไม่มีการ op)

Pyth , 35 ไบต์

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

ลองออนไลน์!

เยลลี่ ,  27  26 ไบต์

-1 ไบต์ด้วย Erik the Outgolfer (ใช้การทำซ้ำ¡, เพื่อแทนที่?,, และประโยคอื่นที่ผ่าน¹)

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

โปรแกรมเต็มรูปแบบที่พิมพ์ผลลัพธ์ด้วยการเว้นวรรคนำหน้าตามที่อนุญาตในคำถาม (หรือลิงก์ dyadic ที่ส่งคืนรายการของอักขระ)

ลองออนไลน์!

อย่างไร?

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 ไบต์

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

ลองออนไลน์!

V , 47 38 30 27 26 25 ไบต์

ในที่สุดก็เอาชนะคำตอบของเยลลี่ปัจจุบัน \ o /

ใช้อินพุตโดยใช้คำที่ยาวกว่าอยู่ด้านบน

คำอธิบายมาไม่คิดว่าจะมีอะไรอีกมากมายให้เล่นกอล์ฟ

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

ลองออนไลน์!

คำอธิบาย

ò     ò      ' <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 ไบต์

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

ลองออนไลน์!

ควรอ่านข้อมูลต่อไปนี้พร้อมคำพูดประชดประชันและคำพูดทางอากาศมากมาย

นี่คือคำตอบของฉันในการเล่นกอล์ฟภาษาที่ดีในระยะสั้นคำตอบให้กับความท้าทายสตริง-based และ ASCII ศิลปะ

ทำไมฉันถึงทำสิ่งนี้กับตัวเองต่อไปเรื่อย ๆ ?

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 

เยลลี่ขนาด 28 ไบต์

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

ลองออนไลน์!

วูวุ้นเป็นจริงการแข่งขันในสตริง และ ASCII ศิลปะท้าทาย! \ O /

05AB1E , 26 23 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ด้วยตัวอย่างอินพุต = 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 ไบต์

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

ลองออนไลน์!

อาจเป็นเรื่องของการเล่นกอล์ฟที่นี่ แต่นี่เป็นความพยายามครั้งแรกที่ไม่ใช่ LINQ ฟังก์ชัน Lambda ที่ใช้คำที่ยาวกว่าเป็นอันดับแรกและส่งคืนสตริงด้วย ouput

Java 8, 216 ไบต์

แลมบ์ดาแกงกะหรี่: ใช้เวลาStringและผลตอบแทนแลมบ์ดาจากไปString Stringพารามิเตอร์ของแลมบ์ดาด้านนอกเป็นสตริงที่สั้นกว่า

การไม่สามารถจัดทำดัชนีเป็นStrings ด้วยไวยากรณ์อาร์เรย์คือ ... โชคร้าย

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

แลมบ์ดา

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

คำอธิบาย

lคือความยาวของอินพุตที่สั้นกว่าและiเป็นดัชนีอเนกประสงค์ซึ่งเริ่มต้นเพื่ออ้างถึงอักขระแรกของครึ่งหลังของอินพุตที่สั้นกว่า oสะสมผลpในท้ายที่สุดเก็บช่องว่างสำหรับการขยายและเป็นนามแฝงสำหรับn"\n"

ลูปแรกสอดแทรกครึ่งที่สองของทั้งสองสตริง (ไม่รวมอักขระสุดท้ายของอินพุตที่ยาวกว่า) และสร้างpตามจำนวนที่เหมาะสมของการเติมเต็มสำหรับบรรทัดกลาง

บรรทัดถัดไปทำบรรทัดกลางของเอาต์พุตให้เสร็จสมบูรณ์

ฉันต้องการขอโทษ James Gosling สำหรับวงที่สอง มันเพิ่มเส้นด้านบนและด้านล่างของเส้นกลางจากด้านในออก การเข้าสู่ลูปiคือคือl - 1ดังนั้นอักขระหนึ่งของการเติมเต็มจะถูกเติมไว้พร้อมกับอักขระสุดท้ายของครึ่งแรกของสตริงที่สั้นกว่า iถูกลดค่าเพื่อให้การเติมถัดไป (ต่อท้ายผลลัพธ์) เป็นอักขระที่สั้นกว่า ด้วยการหารจำนวนเต็มอักขระตำแหน่งเดียวกันของสตริงที่ยาวกว่าจะถูกต่อท้าย ซ้ำนี้และผลลัพธ์ที่เสร็จสมบูรณ์จะถูกส่งกลับ

สิ่งที่เย็น

บรรทัดที่ 13 เคยเป็น

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

เนื่องจากไม่มีสตริงว่างให้+เพิ่มค่าอักขระร่วมกันและต่อท้ายสตริงตัวเลข โดยการขยายการผสมการรวมกันของoและt.charAt(i)ได้รับการประเมินก่อนซึ่งให้ผลลัพธ์ที่ต้องการโดยไม่ต้องใช้สตริงที่ว่างบันทึก 2 ไบต์ นี่เป็นครั้งแรกที่ฉันได้เห็นการมอบหมายผสมทำงานแตกต่างจากการขยายตัว

Javascript (ES6), 140 137 133 ไบต์

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

ค่อนข้างแน่ใจว่าสิ่งนี้สามารถเล่นกอล์ฟต่อไปได้

Mathematica, 174 ไบต์

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

อินพุต

["ซิป", "ย่อหน้า"]

TXR Lisp , 126 ไบต์

(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 ไบต์

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;

ทำงานด้วย-nrหรือลองออนไลน์

Perl 5 , 163 ไบต์

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

ลองออนไลน์!

ใช้สตริงที่ยาวกว่าก่อน