Скажімо, у нас є певний набір функцій на рядках. Ці функції схожі на заповнення заготовок або мадлібів, за винятком того, що вони беруть лише один вхід і використовують його для заповнення всіх своїх заготовок. Наприклад, у нас може бути функція, яка виглядає так

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

Завдання

Ваше завдання - взяти дві функції, описані як непусті списки рядків, і вивести їх склад у вигляді не порожнього списку рядків.

Для цього завдання викликом списку може бути будь-який упорядкований контейнер, який дозволяє копії, а рядок може бути власним типом рядка, списком символів або списком цілих чисел.

Це відповіді на код-гольф будуть набрані в байтах, а менша кількість байтів буде кращою.

Тестові справи

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

Діадичне посилання, що приймає перше представлення функції праворуч і друге представлення функції зліва, яке дає результуюче представлення функції. Кожне представлення функції - це список списків символів (у Jelly немає інших рядків).

Спробуйте в Інтернеті! (повнопрограмні аргументи наведені в нотації Python; рядки стають списками. Нижній колонтитул відображає Python-представлення виводу Link.)

Ось тестовий набір, який переформатує вихід Link, як і входи.

Як?

Скористайтеся списками змішаного типу Jelly, щоб дозволити весь домен представлень (будь-який список списків символів), використовуючи цілий нуль у якості власника місця:

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

Якщо нам знадобиться мати справу з будь-яким зі змішаних списків Jelly (включаючи будь-яку глибину чи форму), ми могли б використовувати цей вісім байт: 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ý®¡

На відміну від відповіді Jelly, рядок "0", ціле число 0і float 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)

Мова Вольфрама (Mathematica) , 62 61 байт

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

Спробуйте в Інтернеті!

-1 завдяки Роману

Хоча це не є дійсним результатом, це повертає функцію, яка насправді виконує роботу .. (34 байти)

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

Спробуйте в Інтернеті!

Japt , 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"

Хаскелл , 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 від TIO для обліку f=.

Використовує метод Джонатана Аллена, адаптований для Дж.

Це було напрочуд важко для гольфу, оскільки J не має вбудованого методу "приєднатися", і мені було б цікаво побачити, чи можна його значно покращити.

g є дієсловом helper, яке дає нам "приєднатися"

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

ТІО

вкладку та новий рядок обрано тому, що зручніше перевіряти тестові випадки, інакше їх можна було б змінити на символи, що не друкуються, \1та \2.

( -02l012p)

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

ТІО

Як це працює,

• -02 : встановити роздільник запису вхідного сигналу на \2
• -l: видалити роздільник вводу з аргументу за замовчуванням $_та додати роздільник записів виводу до виводу за замовчуванням
• -012: встановити роздільник записів на вихідний \012( \n), щоб виведення було легше перевірити

• -p : для друку аргументу за замовчуванням

• $n=<>; : читати наступний запис і призначити його $n

• chop$n; : видалити роздільник з $n
• s/\x1/$n/g: Замінити всі входження \1з$n

JavaScript (ES6),  62  59 байт

Збережено 3 байти завдяки @Shaggy

Це виправлена ​​версія відповіді Луїса (тепер видалена) для підтримки всіх символів.

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

Спробуйте в Інтернеті!