ให้เราบอกว่าเรามีชุดของฟังก์ชั่นเฉพาะเกี่ยวกับสตริง ฟังก์ชั่นเหล่านี้มีลักษณะเหมือนเติมในช่องว่างหรือ madlib ยกเว้นว่าพวกเขาจะใช้เพียงหนึ่งอินพุตและใช้เพื่อเติมลงในช่องว่างทั้งหมดของพวกเขา ตัวอย่างเช่นเราอาจมีฟังก์ชั่นที่ดูเหมือน

I went to the ____ store and bought ____ today.

หากเราใช้ฟังก์ชันนี้กับสตริงcheeseผลลัพธ์จะเป็น:

I went to the cheese store and bought cheese today.

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

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

ด้วยการแทนค่านี้มีเพียงหนึ่งการแทนสำหรับทุก ๆ ฟังก์ชันของการเรียงลำดับนี้และเพียงหนึ่งฟังก์ชันสำหรับแต่ละการแทนเท่านั้น

สิ่งที่เรียบร้อยจริงๆคือชุดของฟังก์ชั่นดังกล่าวปิดภายใต้องค์ประกอบ กล่าวคือการจัดองค์ประกอบของฟังก์ชั่นสองอย่างของเราเป็นหน้าที่หนึ่งของฟังก์ชันเหล่านี้เสมอ เช่นถ้าฉันเขียนฟังก์ชันของเราด้านบนด้วย

["blue ", ""]

(ฟังก์ชั่นที่blueเพิ่มเข้าสู่อินพุต) เรารับฟังก์ชั่น:

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

สิ่งเหล่านี้จะซับซ้อนกว่านี้เล็กน้อย เช่นถ้าเราเขียนฟังก์ชันแรกด้วย

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

ผลที่ได้คือ

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

งาน

งานของคุณคือการรับฟังก์ชั่นสองอย่างตามที่อธิบายไว้ในรายการสตริงที่ไม่ว่างเปล่าและแสดงองค์ประกอบเป็นสตริงที่ไม่ว่างเปล่า

สำหรับจุดประสงค์ของการท้าทายรายการสามารถเป็นคอนเทนเนอร์ที่เรียงลำดับซึ่งอนุญาตการทำซ้ำและสตริงอาจเป็นชนิดสตริงดั้งเดิมรายการของอักขระหรือรายการจำนวนเต็ม

นี่คือคำตอบของcode-golfจะได้คะแนนเป็นไบต์ด้วยจำนวนไบต์ที่น้อยกว่าจะดีกว่า

กรณีทดสอบ

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

เยลลี่ 6 ไบต์

j0j@ṣ0

ลิงก์ dyadic ยอมรับการแสดงฟังก์ชันแรกทางด้านขวาและการแทนฟังก์ชันที่สองทางด้านซ้ายซึ่งให้การแทนฟังก์ชันที่เป็นผลลัพธ์ การแทนฟังก์ชันแต่ละรายการเป็นรายการของอักขระ (วุ้นไม่มีสตริงอื่น)

ลองออนไลน์! (ข้อโต้แย้งแบบเต็มโปรแกรมมีการระบุไว้ในสัญกรณ์ Python สตริงกลายเป็นรายการส่วนท้ายแสดงการแสดง Python ของเอาต์พุตของ Link)

นี่คือชุดทดสอบซึ่งทำการรีฟอร์แมตเอาต์พุตของลิงก์เช่นอินพุต

อย่างไร?

ใช้ประโยชน์จากรายการประเภทผสมของเจลลี่เพื่ออนุญาตการแสดงโดเมนทั้งหมด (รายการใด ๆ ของตัวละคร) โดยใช้ศูนย์จำนวนเต็มเป็นตัวยึดตำแหน่ง:

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

หากเราจำเป็นต้องจัดการกับรายการผสมของวุ้นใด ๆ (รวมถึงรายการที่มีความลึกหรือรูปร่างใด ๆ ) เราสามารถใช้แปด byter นี้: j,©⁹jœṣ®ซึ่งใช้อาร์กิวเมนต์คู่ที่เป็นเจ้าของสถานที่

Haskell , 78 ไบต์

(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

ลองออนไลน์!

Python 3.8 (เผยแพร่ล่วงหน้า) ,  60  58 ไบต์

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

ฟังก์ชั่นที่ไม่มีชื่อยอมรับสองรายการของสตริงaและbซึ่งจะส่งกลับรายการของสตริง

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

รูปแบบแรกสตริงคั่นvซึ่งไม่สามารถพบได้ในหรือa bจากนั้นรูปแบบสตริงโดยการเข้าร่วมขึ้นสตริงในสำเนาb vจากนั้นจัดรูปแบบสตริงโดยรวมสตริงเข้าaด้วยกัน ในที่สุดก็แยกสตริงที่อินสแตนซ์ของvเพื่อให้รายการของสตริง

ในขณะที่มั่นใจvไม่ได้อยู่ในaหรือbเราต้องมั่นใจว่าvจะไม่ทำให้เราแตกในช่วงต้นในกรณีที่สตริงทั้งหมดในaและbมีความเท่าเทียมกัน ในการทำเช่นนั้นเราจัดตั้งvโดยการรวมสตริงทั้งหมดในทั้งสองรายการด้วยอินสแตนซ์ของสตริง (ที่นี่'&') และเพิ่มอักขระพิเศษที่แตกต่างกัน (ที่นี่'$') โปรดทราบว่าการแยกอย่างใดอย่างหนึ่งไม่เพียงพอเนื่องจากสตริงทั้งหมดในอินพุตอาจเท่ากับอักขระที่เลือก

05AB1E , 4 15 19 9 11 ไบต์

«TýR©ý¹sý®¡

ต่างจากคำตอบของเยลลี่สตริง"0"และจำนวนเต็ม0และลอยของ 05AB1E มี0.0ค่าเท่ากัน (ดังนั้น) ดังนั้นฉันจึงไม่สามารถแยก / เข้าร่วมด้วยจำนวนเต็ม นี่คือสาเหตุที่เรามีวิธีแก้ปัญหา +15 ไบต์เป็นวิธีแก้ปัญหาถึงแม้ว่าฉันได้เล่นกอล์ฟกลับไปเป็น 9 ไบต์แล้ว ขอบคุณ@JonathanAllanสำหรับการค้นหา 2 ข้อบกพร่อง

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

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

ภาษา Wolfram (Mathematica) , 62 61 ไบต์

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

ลองออนไลน์!

-1 ขอบคุณชาวโรมัน

แม้ว่ามันจะไม่ใช่เอาต์พุตที่ถูกต้อง แต่มันจะส่งคืนฟังก์ชันที่ทำงานจริง .. (34 ไบต์)

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

ลองออนไลน์!

Japtet , 8 ไบต์

ปรับวิธีการโจนาธาน

qVqN²)qN

ลองมัน

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

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

ลองออนไลน์!

นี่คือคำตอบของฉัน Haskell ใช้งานได้กับรายการทุกประเภท

J , ^{44 43 42} 29 ไบต์

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

ลองออนไลน์!

-13 ไบต์ขอบคุณไมล์!

วิธีนี้ใช้จำนวนเต็มและครบกำหนดเป็นไมล์

วิธีการดั้งเดิมกับสตริง

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

ลองออนไลน์!

หมายเหตุ: ฉันได้ปรับ -3 off TIO ให้เป็นบัญชีแล้ว f=.

ใช้วิธีการของ Jonathan Allen ดัดแปลงสำหรับ J.

นี่เป็นเรื่องยากสำหรับกอล์ฟเนื่องจาก J ไม่มีวิธีการ "เข้าร่วม" ในตัวและฉันอยากรู้ว่าจะสามารถปรับปรุงให้ดีขึ้นได้หรือไม่

g คำกริยาช่วยที่ทำให้เรา "เข้าร่วม"

JavaScript (Node.js) , 85 79 ไบต์

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

ลองออนไลน์!

JavaScript ขนาด 37 ไบต์

นอกจากนี้ยังปรับวิธีโจนาธาน

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

ลองออนไลน์

Perl 5 ( -lp), 20 ไบต์

ตามที่ @JonathanAllan แสดงความคิดเห็นนี่เป็นโปรแกรมเต็มรูปแบบที่ใช้สำหรับ IO แท็บเป็นตัวคั่นรายการและบรรทัดใหม่เพื่อแยกทั้งสองรายการ

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

TIO

แท็บและการขึ้นบรรทัดใหม่ได้รับการแต่งตั้งเพราะสะดวกมากขึ้นในการตรวจสอบกรณีทดสอบมิฉะนั้นอาจมีการเปลี่ยนแปลงกับตัวละครที่ไม่สามารถพิมพ์และ\1\2

( -02l012p)

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

TIO

มันทำงานอย่างไร,

• -02 : เพื่อตั้งค่าตัวคั่นเรคคอร์ดอินพุตเป็น \2
• -l: เพื่อลบตัวแยกอินพุตออกจากอาร์กิวเมนต์เริ่มต้น$_และเพื่อเพิ่มตัวคั่นระเบียนผลลัพธ์ไปยังเอาต์พุตเริ่มต้น
• -012: เพื่อตั้งค่าตัวแยกเร็กคอร์ดเอาท์พุทเป็น\012( \n) เพื่อให้เอาต์พุตตรวจสอบได้ง่ายขึ้น

• -p : เพื่อพิมพ์อาร์กิวเมนต์เริ่มต้น

• $n=<>; : เพื่ออ่านบันทึกถัดไปและเพื่อมอบหมายให้ $n

• chop$n; : เพื่อลบตัวคั่นออกจาก $n
• s/\x1/$n/g: เพื่อแทนที่สิ่งที่เกิดขึ้นทั้งหมด\1ด้วย$n

JavaScript (ES6),  62  59 ไบต์

บันทึก 3 ไบต์ด้วย @Shaggy

นี่เป็นคำตอบที่แน่นอนของLuis (ลบแล้ว) เพื่อรองรับตัวละครทุกตัว

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

ลองออนไลน์!