Powiedzmy, że mamy określony zestaw funkcji na ciągach. Funkcje te przypominają wypełnianie pustych pól lub madlibów, z tym wyjątkiem, że pobierają tylko jeden wkład i używają go do wypełnienia wszystkich swoich pustych pól. Na przykład możemy mieć funkcję, która wygląda

I went to the ____ store and bought ____ today.

Jeśli zastosujemy tę funkcję do łańcucha, cheesewynikiem będzie:

I went to the cheese store and bought cheese today.

Możemy reprezentować te funkcje jako niepustą listę ciągów, gdzie puste miejsca są po prostu przerwami między ciągami. Na przykład nasza powyższa funkcja to:

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

Dzięki tej reprezentacji istnieje tylko jedna reprezentacja dla każdej funkcji tego rodzaju i tylko jedna funkcja dla każdej reprezentacji.

Naprawdę fajne jest to, że zestaw takich funkcji jest zamknięty w ramach kompozycji. To znaczy, że składanie się z dwóch naszych funkcji jest zawsze kolejną z tych funkcji. Na przykład, jeśli skomponuję naszą funkcję powyżej

["blue ", ""]

(funkcja, która przechodzi bluedo wejścia) Otrzymujemy funkcję:

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

Mogą się one jednak nieco bardziej skomplikować. Na przykład, jeśli skomponujemy pierwszą funkcję z

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

Wynik to

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

Zadanie

Twoim zadaniem jest przyjęcie dwóch funkcji opisanych jako niepuste listy ciągów i wygenerowanie ich składu jako niepustej listy ciągów.

Na potrzeby tego wyzwania listą może być dowolny uporządkowany kontener, który zezwala na duplikaty, a ciąg może być rodzimym typem ciągu, listą znaków lub listą liczb całkowitych.

To jest odpowiedź na golfa kodowanego w bajtach, przy czym mniej bajtów jest lepszych.

Przypadki testowe

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

Galaretka , 6 bajtów

j0j@ṣ0

Dyadyczny link akceptujący pierwszą reprezentację funkcji po prawej i drugą reprezentację funkcji po lewej, która daje wynikową reprezentację funkcji. Każda reprezentacja funkcji jest listą znaków (Jelly nie ma innych ciągów znaków).

Wypróbuj online! (argumenty pełnego programu podano w notacji Pythona; ciągi stają się listami. Stopka pokazuje reprezentację wyjścia Link w Pythonie).

Oto pakiet testowy, który formatuje dane wyjściowe łącza podobnie jak dane wejściowe.

W jaki sposób?

Korzysta z list mieszanych typów Jelly, aby umożliwić całą domenę reprezentacji (dowolną listę list znaków), używając liczby całkowitej zero jako symbolu zastępczego:

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

Gdybyśmy musieli poradzić sobie z dowolną z mieszanych list Jelly (w tym tych o dowolnej głębokości lub kształcie), moglibyśmy użyć tego ośmiu bajtów: j,©⁹jœṣ®który używa sparowanych argumentów jako elementu zastępczego .

Haskell , 78 bajtów

(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

Wypróbuj online!

Python 3.8 (wersja wstępna) ,  60  58 bajtów

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

Nienazwana funkcja akceptująca dwie listy ciągów ai b, która zwraca listę ciągów.

Wypróbuj online! Lub zobacz zestaw testowy .

W jaki sposób?

Najpierw tworzy ciąg separatora v, którego nie można znaleźć wewnątrz alub b. Następnie tworzy ciąg, łącząc ciągi bz kopiami v. Następnie tworzy ciąg, łącząc ciągi az kopiami tego. Na koniec dzieli ten ciąg w przypadkach, vaby uzyskać listę ciągów.

Zapewniając jednocześnie vnie jest alub bmusimy również zapewnić, że vprzyzwyczajenie uczynić nas podzielić wcześnie w przypadku, gdy wszystkie ciągi w ai bsą równe. Aby to zrobić, łączymy vwszystkie ciągi na obu listach z wystąpieniami ciągu (tutaj '&') i dodajemy inny, inny znak (tutaj '$'). Zauważ, że wykonanie jednego z nich osobno nie wystarczy, ponieważ wszystkie ciągi wejściowe mogą być równe wybranemu znakowi.

05AB1E , 4 15 19 9 11 bajtów

«TýR©ý¹sý®¡

W przeciwieństwie do odpowiedzi Jelly, ciąg 05AB1E "0", liczba całkowita 0i liczba zmiennoprzecinkowa 0.0są (nieco) równe, więc nie mogę podzielić / dołączyć liczby całkowitej. Właśnie dlatego mieliśmy obejście +15 bajtów jako obejście, chociaż teraz grałem w golfa z powrotem do 9 bajtów. Dzięki @JonathanAllan za znalezienie 2 błędów.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

«            # 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 bajtów

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

Wypróbuj online!

-1 dzięki Romanowi

Chociaż nie jest to poprawny wynik, zwraca funkcję, która faktycznie wykonuje zadanie. (34 bajty)

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

Wypróbuj online!

Japt , 8 bajtów

Dostosowuje podejście Jonathana .

qVqN²)qN

Spróbuj

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 bajty

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

Wypróbuj online!

Oto moja odpowiedź Haskella. Działa na każdym typie listy.

J , ^{44 43 42} 29 bajtów

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

Wypróbuj online!

-13 bajtów dzięki milom!

To podejście wykorzystuje liczby całkowite i wynika z mil.

oryginalne podejście ze sznurkami

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

Wypróbuj online!

Uwaga: Dostosowałem -3 do TIO, aby uwzględnić f=.

Wykorzystuje metodę Jonathana Allena, dostosowaną do J.

To było zaskakująco trudne do gry w golfa, ponieważ J nie ma wbudowanej metody „dołączenia” i byłbym ciekawy, czy można to znacznie poprawić.

g to czasownik pomocniczy, który daje nam „dołączyć”

JavaScript (Node.js) , 85 79 bajtów

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

Wypróbuj online!

JavaScript, 37 bajtów

Dostosowuje także podejście Jonathana .

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

Wypróbuj online

Perl 5 (-lp ), 20 bajtów

Jak skomentował @JonathanAllan, jest to pełny program wykorzystujący, dla IO, kartę jako separator listy i nowy wiersz do oddzielenia dwóch list.

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

TIO

wybrano zakładkę i nowy wiersz, ponieważ wygodniej było sprawdzać przypadki testowe, w przeciwnym razie można je zmienić na znaki niedrukowalne \1i\2 .

( -02l012p)

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

TIO

Jak to działa,

• -02 : aby ustawić separator rekordów wejściowych na \2
• -l: aby usunąć separator wejściowy z domyślnego argumentu $_i dodać separator rekordu wyjściowego do domyślnego wyjścia
• -012: aby ustawić separator rekordów wyjściowych na \012( \n), aby łatwiej było sprawdzić dane wyjściowe

• -p : aby wydrukować domyślny argument

• $n=<>; : aby przeczytać następny rekord i przypisać do $n

• chop$n; : aby usunąć separator $n
• s/\x1/$n/g: Zastąpienie wszystkich wystąpień \1z$n

JavaScript (ES6),  62  59 bajtów

Zaoszczędź 3 bajty dzięki @Shaggy

To jest poprawiona wersja odpowiedzi Luisa (teraz usunięta), która obsługuje wszystkie postacie.

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

Wypróbuj online!