Допустим, у нас есть определенный набор функций для строк. Эти функции похожи на заполнение пробелов или madlibs, за исключением того, что они принимают только один ввод и используют его для заполнения всех пробелов. Например, у нас может быть функция, которая выглядит как

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, строка 05AB1E "0", целое число 0и число с плавающей точкой 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 Language (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"

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 от TIO для учета f=.

Использует метод Джонатана Аллена, адаптированный для Дж.

Это было удивительно сложно для гольфа, поскольку у 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, это полная программа, использующая для ввода-вывода вкладку в качестве разделителя списка и новую строку для разделения двух списков.

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

Это исправленная версия ответа Луиса (теперь удалена) для поддержки всех персонажей.

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

Попробуйте онлайн!