Hãy để chúng tôi nói rằng chúng tôi có một bộ chức năng cụ thể trên chuỗi. Các hàm này giống như điền vào chỗ trống hoặc madlib, ngoại trừ việc chúng chỉ lấy một đầu vào và sử dụng nó để điền vào tất cả các khoảng trống của chúng. Ví dụ, chúng ta có thể có một chức năng trông giống như

I went to the ____ store and bought ____ today.

Nếu chúng ta áp dụng hàm này cho chuỗi cheese, kết quả sẽ là:

I went to the cheese store and bought cheese today.

Chúng ta có thể biểu diễn các hàm này dưới dạng một danh sách các chuỗi không trống, trong đó các khoảng trống chỉ đơn giản là các khoảng trống ở giữa các chuỗi. Ví dụ chức năng của chúng tôi ở trên sẽ là:

["I went to the ", " store and bought ", " today."]

Với đại diện này, chỉ có một đại diện cho mọi chức năng của loại này và chỉ có một chức năng cho mỗi đại diện.

Một điều thực sự gọn gàng là tập hợp các chức năng như vậy được đóng dưới thành phần. Đó là để nói rằng thành phần của hai trong số các chức năng của chúng tôi luôn luôn là một trong những chức năng này. Ví dụ: nếu tôi soạn hàm của chúng tôi ở trên với

["blue ", ""]

(chức năng bluebổ sung cho đầu vào) Chúng tôi nhận được chức năng:

["I went to the blue ", " store and bought blue ", " today."]

Chúng có thể phức tạp hơn một chút mặc dù. Ví dụ: nếu chúng ta soạn hàm đầu tiên với

["big ", " and ", ""]

Kết quả là

["I went to the big ", " and ", " store and bought big ", "and", " today."]

Bài tập

Nhiệm vụ của bạn là nhận hai hàm như được mô tả dưới dạng danh sách các chuỗi không trống và xuất thành phần của chúng dưới dạng danh sách các chuỗi không trống.

Với mục đích của thách thức này, một danh sách có thể là bất kỳ vùng chứa được đặt hàng nào cho phép trùng lặp và một chuỗi có thể là loại chuỗi gốc, danh sách các ký tự hoặc danh sách các số nguyên.

Đây là mã - câu trả lời golf sẽ được tính bằng byte với ít byte hơn.

Các trường hợp thử nghiệm

["","xy"] ["ab",""] -> ["ab","xy"]
["x","y","z"] ["a","b"] -> ["xa","bya","bz"]
["xy"] ["ab"] -> ["xy"]
["","",""] ["a",""] -> ["a","a",""]
["x",""] ["","",""] -> ["x","",""]
["x","y","z"] ["a","b","c"] -> ["xa","b","cya","b","cz"]
["x","x","x"] ["a"] -> ["xaxax"]
["w","x","y","z"] ["ab","cd","e"] -> ["wab","cd","exab","cd","eyab","cd","ez"]

Thạch , 6 byte

j0j@ṣ0

Liên kết dyadic chấp nhận biểu diễn chức năng đầu tiên ở bên phải và biểu diễn chức năng thứ hai ở bên trái mang lại biểu diễn chức năng kết quả. Mỗi đại diện chức năng là một danh sách các danh sách các ký tự (Jelly không có chuỗi nào khác).

Hãy thử trực tuyến! (các đối số toàn chương trình được đưa ra trong ký hiệu Python; chuỗi trở thành danh sách. Chân trang hiển thị đại diện Python của đầu ra của Liên kết.)

Đây là bộ thử nghiệm định dạng lại đầu ra của Liên kết giống như đầu vào.

Làm sao?

Tận dụng lợi thế của danh sách loại hỗn hợp của Jelly để cho phép toàn bộ miền biểu diễn (bất kỳ danh sách danh sách ký tự nào) bằng cách sử dụng số nguyên 0 làm người giữ chỗ:

j0j@ṣ0 - Link: b, a        e.g.    b = [['a','b'],['c','d'],['e']]
       -                   ...and  a = [['w'],['x'],['y'],['z']]
                             (i.e. test-case ["w","x","y","z"] ["ab","cd","e"])
j0     - join b with zeros         ['a','b',0,'c','d',0,'e']    
  j@   - join a with that          ['w','a','b',0,'c','d',0,'e','x','a','b',0,'c','d',0,'e','y','a','b',0,'c','d',0,'e','z']
    ṣ0 - split at zeros            [['w','a','b'],['c','d'],['e','x','a','b'],['c','d'],['e','y','a','b'],['c','d'],['e','z']
                             (i.e.: ["wab","cd","exab","cd","eyab","cd","ez"])

Nếu chúng ta cần phải xử lý bất kỳ danh sách hỗn hợp nào của Jelly (bao gồm cả các danh sách có độ sâu hoặc hình dạng bất kỳ), chúng ta có thể sử dụng tám byter này: j,©⁹jœṣ®sử dụng các đối số được ghép nối làm trình giữ chỗ.

Haskell , 78 byte

(a:b:r)#t@(x:s)|s>[]=(a++x):init s++((last s++b):r)#t|z<-a++x++b=(z:r)#t
x#_=x

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

Python 3,8 (tiền phát hành) ,  60  58 byte

lambda a,b:(v:='&'.join(a+b)+'$').join(b).join(a).split(v)

Một hàm không tên chấp nhận hai danh sách các chuỗi avà btrả về danh sách các chuỗi.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Làm sao?

Đầu tiên tạo thành một chuỗi phân tách, vkhông thể tìm thấy bên trong ahoặc b. Sau đó tạo thành một chuỗi bằng cách nối các chuỗi bvới các bản sao của v. Sau đó, tạo thành một chuỗi bằng cách nối các chuỗi avới các bản sao của chuỗi đó. Cuối cùng tách chuỗi đó tại các trường hợp vđể đưa ra danh sách các chuỗi.

Mặc dù đảm bảo vkhông có ahoặc bchúng tôi cũng phải đảm bảo rằng vsẽ không khiến chúng tôi bị chia tách sớm trong trường hợp tất cả các chuỗi trong avà bbằng nhau. Để làm như vậy, chúng tôi hình thành vbằng cách nối tất cả các chuỗi trong cả hai danh sách với các phiên bản của chuỗi (ở đây '&') và thêm một ký tự khác, khác (ở đây '$'). Lưu ý rằng thực hiện một trong hai cách ly là không đủ vì tất cả các chuỗi trong đầu vào có thể bằng ký tự được chọn.

05AB1E , 4 15 19 9 11 byte

«TýR©ý¹sý®¡

Không giống như câu trả lời của Jelly, chuỗi "0", số nguyên 0và float của 05AB1E 0.0đều bằng nhau (phần nào), vì vậy tôi không thể chia / nối bởi một số nguyên. Đây là lý do tại sao chúng tôi có +15 byte như cách giải quyết, mặc dù bây giờ tôi đã đánh nó trở lại thành 9 byte. Cảm ơn @JonathanAllan vì đã tìm thấy 2 lỗi.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

«            # Merge the two (implicit) input-lists together
 Tý          # Then using a "10" delimiter join all strings together
   R         # Reverse this string
    ©        # Store this string in variable `®` (without popping)
     ý       # Use this string as delimiter to join the second (implicit) input-list
      ¹sý    # Then join the first input-list by this entire string
         ®¡  # And split it back on variable `®` so it's the expected list of strings
             # (after which this result is output implicitly)

Ngôn ngữ Wolfram (Mathicala) , 62 61 byte

""<>#&/@Flatten[#~(R=Riffle)~I/.I->#2~R~I]~SequenceSplit~{I}&

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

-1 nhờ La Mã

Mặc dù nó không phải là đầu ra hợp lệ, nhưng điều này trả về một hàm thực sự thực hiện công việc .. (34 byte)

(g=a""<>a~Riffle~#&)[#]@*g[#2]&

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

Japt , 8 byte

Thích nghi cách tiếp cận của Jonathan .

qVqN²)qN

Thử nó

qVqN²)qN     :Implicit input of arrays U & V (N=[U,V])
q            :Join U with
 Vq          :  V joined with
   N²        :    Push 2 to N (modifying the original), which gets coerced to a string
             >     e.g., N=[["a","b"],["c","d"]] -> N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"
     )       :End join
      qN     :Split on the modified N, which, again, gets coerced to a string
             > e.g., N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"

Haskell , 62 byte

[a]#(c:d)=(a++c):d
(a:b)#c=a:b#c
[a]%b=[a]
(a:b)%c=[a]#c#(b%c)

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

Đây là câu trả lời Haskell của tôi. Nó hoạt động trên bất kỳ loại danh sách.

J , ^{44 43 42} 29 byte

_<;._1@,(;@}:@,@,.(,_&,)&.>/)

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

-13 bytes nhờ dặm!

Cách tiếp cận này sử dụng số nguyên và là do dặm.

cách tiếp cận ban đầu với chuỗi

g=.[:}.@,,.
f=.(<@0<@;;._1@,];@g<"0@[)<@0<@g]

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

Lưu ý: Tôi đã điều chỉnh -3 khỏi TIO cho tài khoản f=.

Sử dụng phương pháp của Jonathan Allen, thích nghi với J.

Điều này thật khó khăn khi chơi golf, vì J không có phương pháp "tham gia" tích hợp và tôi tò mò muốn xem liệu nó có thể được cải thiện đáng kể hay không.

g là động từ trợ giúp cho chúng ta "tham gia"

JavaScript (Node.js) , 85 79 byte

([a,...b],[c,...d])=>b.map(e=>r.push(r.pop(r.push(r.pop()+c,...d))+e),r=[a])&&r

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

JavaScript, 37 byte

Cũng thích nghi cách tiếp cận của Jonathan .

a=>b=>a.join(b.join(a+=b+0)).split(a)

Dùng thử trực tuyến

Perl 5 ( -lp), 20 byte

Như @JonathanAllan đã nhận xét, đây là một chương trình đầy đủ sử dụng, đối với IO, một tab làm dấu tách danh sách và dòng mới để phân tách hai danh sách.

chop($n=<>);s/  /$n/g

TIO

tab và dòng mới đã được chọn vì thuận tiện hơn để kiểm tra các trường hợp kiểm tra, nếu không có thể thay đổi thành các ký tự không in được \1và \2.

( -02l012p)

chop($n=<>);s//$n/g

TIO

Làm thế nào nó hoạt động,

• -02 : để đặt dấu tách bản ghi đầu vào thành \2
• -l: để xóa dấu phân cách đầu vào khỏi đối số mặc định $_và thêm dấu tách bản ghi đầu ra vào đầu ra mặc định
• -012: để đặt dấu tách bản ghi đầu ra thành \012( \n) để kiểm tra đầu ra dễ dàng hơn

• -p : để in đối số mặc định

• $n=<>; : để đọc bản ghi tiếp theo và gán cho $n

• chop$n; : để xóa dấu phân cách khỏi $n
• s/\x1/$n/g: để thay thế tất cả các lần xuất hiện của \1với$n

JavaScript (ES6),  62  59 byte

Đã lưu 3 byte nhờ @Shaggy

Đây là phiên bản cố định của câu trả lời của Luis (hiện đã bị xóa) để hỗ trợ tất cả các nhân vật.

a=>b=>a.map(e=escape).join(b.map(e)).split`,`.map(unescape)

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