Katakanlah kita memiliki seperangkat fungsi khusus pada string. Fungsi-fungsi ini seperti mengisi kekosongan atau madlibs, kecuali bahwa mereka hanya mengambil satu input dan menggunakannya untuk mengisi semua kekosongannya. Misalnya kita mungkin memiliki fungsi yang mirip

I went to the ____ store and bought ____ today.

Jika kita menerapkan fungsi ini ke string cheesehasilnya adalah:

I went to the cheese store and bought cheese today.

Kita dapat merepresentasikan fungsi-fungsi ini sebagai daftar string yang tidak kosong, di mana yang kosong hanyalah celah di antara string. Misalnya fungsi kita di atas adalah:

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

Dengan representasi ini, hanya ada satu representasi untuk setiap fungsi semacam ini dan hanya satu fungsi untuk setiap representasi.

Suatu hal yang sangat rapi adalah bahwa himpunan fungsi tersebut ditutup di bawah komposisi. Artinya komposisi dua fungsi kita selalu merupakan salah satu dari fungsi ini. Sebagai contoh jika saya menyusun fungsi kami di atas dengan

["blue ", ""]

(fungsi yang bergantung bluepada input) Kami mendapatkan fungsi:

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

Ini bisa menjadi sedikit lebih rumit. Misalnya jika kita membuat fungsi pertama dengan

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

Hasilnya adalah

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

Tugas

Tugas Anda adalah untuk mengambil dua fungsi seperti yang dijelaskan sebagai daftar string yang tidak kosong dan menampilkan komposisi mereka sebagai daftar string yang tidak kosong.

Untuk tujuan tantangan ini daftar dapat berupa wadah yang dipesan yang memungkinkan duplikat dan string dapat berupa tipe string asli, daftar karakter atau daftar bilangan bulat.

Ini adalah kode-golf jawaban akan dicetak dalam byte dengan lebih sedikit byte yang lebih baik.

Uji kasus

["","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"]

Jelly , 6 byte

j0j@ṣ0

Tautan diad menerima representasi fungsi pertama di sebelah kanan dan representasi fungsi kedua di sebelah kiri yang menghasilkan representasi fungsi yang dihasilkan. Setiap representasi fungsi adalah daftar daftar karakter (Jelly tidak memiliki string lain).

Cobalah online!(argumen program penuh diberikan dalam notasi Python; string menjadi daftar. Footer menunjukkan representasi Python dari output Link.)

Ini dia test-suite yang memformat ulang keluaran Link seperti input.

Bagaimana?

Mengambil keuntungan dari daftar tipe campuran Jelly untuk memungkinkan seluruh domain representasi (daftar daftar karakter) dengan menggunakan integer nol sebagai place-holder:

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

Jika kami perlu berurusan dengan daftar campuran Jelly (termasuk yang memiliki kedalaman atau bentuk apa pun), kami dapat menggunakan byter delapan ini: j,©⁹jœṣ®yang menggunakan argumen berpasangan sebagai place-holder.

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

Cobalah online!

Python 3.8 (pra-rilis) ,  60  58 byte

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

Fungsi yang tidak disebutkan namanya menerima dua daftar string, adanb , yang mengembalikan daftar string.

Cobalah online! Atau lihat test-suite .

Bagaimana?

Pertama membentuk string pemisah v,, yang tidak dapat ditemukan di dalam aatau b. Kemudian bentuk string dengan menggabungkan string bdengan salinan v. Kemudian bentuk string dengan menggabungkan string adengan salinannya. Akhirnya membagi string itu pada contohv untuk memberikan daftar string.

Meskipun memastikan vtidak ada aatau bkita juga harus memastikan bahwa vtidak akan membuat kita terpecah lebih awal dalam kasus di mana semua string masuk adan bsama. Untuk melakukannya, kita membentuk vdengan menggabungkan semua string di kedua daftar dengan instance string (di sini '&') dan menambahkan karakter yang berbeda dan berbeda (di sini '$'). Perhatikan bahwa melakukan keduanya secara terpisah tidak cukup karena semua string dalam input dapat sama dengan karakter yang dipilih.

05AB1E , 4 15 19 9 11 byte

«TýR©ý¹sý®¡

Tidak seperti jawaban Jelly, string "0", integer 0, dan float 05AB1E 0.0semuanya (agak) sama, jadi saya tidak bisa memisahkan / bergabung dengan integer. Inilah sebabnya kami memiliki +15 byte sebagai solusi, meskipun saya telah memasukkannya kembali ke 9 byte sekarang. Terima kasih kepada @JonathanAllan untuk menemukan 2 bug.

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

«            # 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)

Bahasa Wolfram (Mathematica) , 62 61 byte

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

Cobalah online!

-1 berkat Roman

Meskipun ini bukan output yang valid, ini mengembalikan fungsi yang benar-benar berfungsi .. (34 byte)

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

Cobalah online!

Japt , 8 byte

Adaptasi pendekatan Jonathan .

qVqN²)qN

Cobalah

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)

Cobalah online!

Inilah jawaban Haskell saya. Ini bekerja pada semua jenis daftar.

J , ^{44 43 42} 29 byte

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

Cobalah online!

-13 bytes berkat mil!

Pendekatan ini menggunakan bilangan bulat dan karena mil.

pendekatan asli dengan string

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

Cobalah online!

Catatan: Saya telah menyesuaikan -3 dari TIO ke akun f=.

Menggunakan metode Jonathan Allen, diadaptasi untuk J.

Ini mengejutkan sulit untuk bermain golf, karena J tidak memiliki metode "bergabung", dan saya ingin tahu apakah ini dapat ditingkatkan secara signifikan.

g adalah kata kerja pembantu yang memberi kita "gabung"

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

Cobalah online!

JavaScript, 37 byte

Juga mengadaptasi pendekatan Jonathan .

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

Cobalah online

Perl 5 (-lp ), 20 byte

Seperti yang dikomentari @JonathanAllan, ini adalah program lengkap yang menggunakan, untuk IO, tab sebagai pemisah daftar dan baris baru untuk memisahkan kedua daftar.

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

TIO

tab dan baris baru dipilih karena lebih mudah untuk memeriksa kasus uji, jika tidak dapat diubah menjadi karakter yang tidak dapat dicetak \1dan\2 .

( -02l012p)

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

TIO

Bagaimana itu bekerja,

• -02 : untuk mengatur pemisah rekaman input \2
• -l: untuk menghapus pemisah input dari argumen default $_dan untuk menambahkan pemisah catatan output ke output default
• -012: untuk mengatur pemisah catatan keluaran ke \012( \n) sehingga keluaran lebih mudah untuk diperiksa

• -p : untuk mencetak argumen default

• $n=<>; : untuk membaca catatan selanjutnya dan untuk ditugaskan $n

• chop$n; : untuk menghapus pemisah dari $n
• s/\x1/$n/g: untuk mengganti semua kejadian \1dengan$n

JavaScript (ES6),  62  59 byte

Disimpan 3 byte berkat @Shaggy

Ini adalah versi tetap dari jawaban Luis (sekarang dihapus) untuk mendukung semua karakter.

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

Cobalah online!