Đoạn dây kéo

21

(Lấy cảm hứng từ thử thách này )

Cho hai chuỗi đầu vào, một trong số đó dài hơn một ký tự, sắp xếp các chuỗi thành nghệ thuật ASCII như thể chúng là hai nửa của khóa kéo chỉ có một nửa khóa kéo. Từ dài hơn tạo thành đáy của khóa kéo, và là ký tự đầu tiên và cuối cùng của phần dây kéo kết hợp. Vì đoạn đó khó hiểu, hãy xem một số ví dụ:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

Lưu ý cách paragraph(từ dài hơn) tạo thành khóa kéo phía dưới và g r a p hphần đóng gói e r e dphần của zippered, và các phần z i p pvà p a r aphần được bù trừ với nhau.

Đầu vào

  • Hai chuỗi ASCII ở bất kỳ định dạng thuận tiện nào , với một chuỗi được đảm bảo có độ dài đồng đều và chuỗi còn lại chính xác hơn một ký tự.
  • Cả hai chuỗi sẽ không chứa khoảng trắng, nhưng có thể chứa bất kỳ giá trị ASCII có thể in nào khác.
  • Bạn có thể lấy đầu vào theo thứ tự. Vui lòng nêu trong trình của bạn thứ tự đầu vào.

Đầu ra

Biểu diễn nghệ thuật ASCII kết quả của các từ có khóa kéo, như được mô tả ở trên, một lần nữa ở bất kỳ định dạng thuận tiện nào.

Quy tắc

  • Các dòng mới hoặc dấu cách hàng đầu hoặc dấu trắng đều là tùy chọn, miễn là bản thân các ký tự xếp hàng chính xác.
  • Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
  • Nếu có thể, vui lòng bao gồm một liên kết đến một môi trường thử nghiệm trực tuyến để người khác có thể thử mã của bạn!
  • Sơ hở tiêu chuẩn bị cấm.
  • Đây là môn đánh gôn để áp dụng tất cả các quy tắc chơi golf thông thường và mã ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s
code-golf  string  ascii-art 
— AdBorkBork
nguồn
Chúng ta có thể giả sử đầu vào không chứa khoảng trắng?
— DJMcMayhem
@DJMcMayhem Vâng, đó là một giả định hợp lý.
— admBorkBork
1
@Titus one guaranteed to be even in length and the other exactly one character longer. Chuỗi ngắn hơn luôn luôn chẵn
— Baldrickk

Câu trả lời:

7

Japt , 31 28 byte

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

Kiểm tra nó trực tuyến! Lấy chuỗi ngắn hơn trước.

Giải trình

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.
— Sản phẩm sinh học
nguồn
6

Than , 33 31 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lấy chuỗi ngắn hơn trước. Chỉnh sửa: Đã lưu 2 byte bằng cách điều chỉnh phát hiện điểm giữa. Giải trình:

→Ｆ²«

Lặp lại lần lượt từng chuỗi.

ＦＬθ«

Lặp lại lần lượt từng ký tự của chuỗi.

§θκ→

In ký tự và di chuyển thêm một hình vuông bên phải.

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

Đối với nửa đầu của chuỗi, cũng di chuyển con trỏ xuống hoặc lên nếu thích hợp.

Ｊ⁰ＬθＡηθ

Sau khi in chuỗi thứ nhất, nhảy đến điểm bắt đầu của chuỗi thứ hai và thay thế chuỗi thứ nhất bằng chuỗi thứ hai, để nó được in cho vòng lặp thứ hai. (Mã chạy trên cả hai vòng, nhưng lần thứ hai là không có.)

— Neil
nguồn
4

Thạch ,  27  26 byte

-1 byte nhờ vào Erik Outgolfer (sử dụng lặp lại ¡, để thay thế if ?, và một mệnh đề khác được thông qua ¹)

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

Một chương trình đầy đủ in kết quả với khoảng trắng hàng đầu, như được cho phép trong câu hỏi (hoặc liên kết dyadic trả về danh sách các ký tự).

Hãy thử trực tuyến!

Làm sao?

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
— Jonathan Allan
nguồn
C¹Ḃ?->CḂ¡
— Erik the Outgolfer
3

V , 47 38 30 27 26 25 byte

Cuối cùng đánh bại câu trả lời Jelly hiện tại \ o /

Đưa đầu vào với từ dài hơn trên đầu

Giải thích sắp tới, đừng nghĩ rằng có nhiều hơn để chơi gôn.

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

Hãy thử trực tuyến!

Giải trình

ò     ò      ' <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)
— nmjcman101
nguồn
2

V , 79 byte

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

Hãy thử trực tuyến!

Sau đây nên được đọc với nhiều châm biếm và trích dẫn không khí .

Dưới đây là một câu trả lời trong tôi chơi golf-ngôn ngữ đó là tốt tại ngắn câu trả lời cho những thách thức chuỗi dựa trên và ASCII-art .

Tại sao tôi cứ làm điều này với bản thân mình?

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
— DJMcMayhem
nguồn
V có lệnh "chuyển hàng với cột" không? Vì nếu không, bạn có thể muốn đầu tư vào đó ...
— Sản phẩm ETH
2

Thạch , 28 byte

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

Hãy thử trực tuyến!

Woo Jelly thực sự đang cạnh tranh trong một thử thách chuỗi và nghệ thuật ! \ o /

— Erik là người vượt trội
nguồn
Chủ yếu là vì mọi ngôn ngữ khác cũng gặp khó khăn. Nói về điều này, ai đó có thể muốn nói chuyện với V ...
— ETHproductions
Thật tuyệt, tôi đã quản lý 27 - nhưng có lẽ bạn cũng có thể lạm dụng trợ cấp không gian trắng hàng đầu / cuối?
— Jonathan Allan
@Jonathan ALLan Đáng buồn là tôi nghĩ điều đó là không thể. Loại bỏ Ṗsẽ không thêm một không gian dấu mà là một dấu 1. Và bỏ qua bất cứ điều gì có liên quan đến khoảng trắng sẽ loại bỏ các dòng chữ. Nói chung, thuật toán này sử dụng lập chỉ mục để các chữ cái đi đến một chỉ mục cụ thể trong một cột và sau đó phần còn lại được lấp đầy khoảng trắng, vì vậy tôi nghĩ rằng điều này không thể được đánh gôn thêm nữa. Ít nhất tôi cũng mừng vì Jelly không bị CJam vượt mặt. ;)
— Erik the Outgolfer
: | Jelly là golfer hơn Char than
— ASCII - chỉ
2

05AB1E , 26 23 byte

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

Hãy thử trực tuyến!

Giải trình

Với ví dụ đầu vào = 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
— Biểu tượng
nguồn
1
Tôi đã rất cố gắng với câu hỏi này như một tuần trước và bạn phải đi và ... đánh bại tôi. +1 để khiến tôi cố gắng hơn một chút!
— nmjcman101
@ nmjcman101: Tôi hy vọng bạn có thể khiến bạn thất vọng hơn một chút. Một số cuộc thi giao hữu luôn vui vẻ :)
— Emigna
1

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

Hãy thử trực tuyến!

Có lẽ rất nhiều môn đánh gôn để làm ở đây, nhưng đây là một nỗ lực phi LINQ ban đầu. Hàm Lambda có từ dài hơn trước và trả về một chuỗi với ouput.

— xương sống
nguồn
1
Sử dụng currying để lưu một byte ( l=>s=>) tức là Func<input1, Func<input2, output>>.
— TheLethalCoder
1

Java 8, 216 byte

Một lambda curried: mất Stringvà trả lại một lambda từ Stringđến String. Tham số cho lambda bên ngoài là chuỗi ngắn hơn.

Không thể lập chỉ mục thành Strings với cú pháp mảng là ... không may.

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

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

Giải trình

llà độ dài của đầu vào ngắn hơn và ilà một chỉ số đa mục đích, được khởi tạo để chỉ ký tự đầu tiên của nửa sau của đầu vào ngắn hơn. otích lũy kết quả, pcuối cùng lưu trữ không gian cho phần đệm và nlà bí danh cho "\n".

Vòng lặp thứ nhất xen kẽ nửa thứ hai của hai chuỗi (không bao gồm ký tự cuối cùng của đầu vào dài hơn) và xây dựng pđến số lượng đệm phù hợp cho đường giữa.

Dòng tiếp theo hoàn thành dòng giữa của đầu ra.

Tôi muốn xin lỗi James Gosling cho vòng lặp thứ hai. Nó thêm các dòng trên và dưới dòng giữa từ trong ra ngoài. Bước vào vòng lặp, ilà l - 1, vì vậy một nhân vật của padding được thêm vào phía trước cùng với ký tự cuối cùng của nửa đầu của chuỗi ngắn hơn. iđược giảm xuống để phần đệm tiếp theo (được thêm vào kết quả) ngắn hơn một ký tự. Bằng cách chia số nguyên, ký tự vị trí tương tự của chuỗi dài hơn được nối vào. Điều này lặp lại, và kết quả hoàn thành được trả lại.

Đồ mát

Dòng 13 đã từng 

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

bởi vì không có chuỗi trống, +đã thêm các giá trị ký tự lại với nhau và nối thêm một chuỗi số. Bằng cách mở rộng phép gán ghép, việc ghép ovà t.charAt(i)được đánh giá đầu tiên, mang lại kết quả mong muốn mà không cần chuỗi trống, tiết kiệm 2 byte. Đây là lần đầu tiên tôi thấy một phép gán ghép hoạt động khác với mở rộng của nó.

— Jakob
nguồn
0

Javascript (ES6), 140 137 133 byte

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

Khá chắc chắn rằng điều này có thể được chơi gôn hơn nữa

— Luke
nguồn
Ví dụ không `<newline>`+` `thể sáp nhập vào `<newline> `? (Tôi không biết JS).
— Kaz
@Kaz: không, bởi vì chúng tôi thực hiện phương thức lặp lại chỉ trên không gian chứ không phải dòng mới + dấu cách.
— Lu-ca
0

Toán học, 174 byte

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


Đầu vào

["Khóa kéo", "đoạn"]

— J42161217
nguồn
0

TXR Lisp , 126 byte

(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 `)""}`))
— Kaz
nguồn
0

PHP, 149 129 byte

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;

Chạy với -nrhoặc thử trực tuyến .

— Tít
nguồn
0

Perl 5 , 163 byte

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

Hãy thử trực tuyến!

Lấy chuỗi dài hơn trước.

— Xcali
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.