Angenommen, wir haben einen bestimmten Satz von Funktionen für Zeichenfolgen. Diese Funktionen ähneln dem Ausfüllen von Leerzeichen oder Madlibs, mit der Ausnahme, dass sie nur eine Eingabe verwenden, um alle Leerzeichen auszufüllen. Zum Beispiel könnten wir eine Funktion haben, die so aussieht

I went to the ____ store and bought ____ today.

Wenn wir diese Funktion auf den String anwenden cheesewürden, wäre das Ergebnis:

I went to the cheese store and bought cheese today.

Wir können diese Funktionen als eine nicht leere Liste von Zeichenfolgen darstellen, wobei die Leerzeichen einfach die Lücken zwischen den Zeichenfolgen sind. Zum Beispiel wäre unsere obige Funktion:

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

Bei dieser Darstellung gibt es für jede Funktion dieser Art nur eine Darstellung und für jede Darstellung nur eine Funktion.

Eine wirklich nette Sache ist, dass die Menge solcher Funktionen unter Komposition geschlossen ist. Das heißt, die Zusammensetzung von zwei unserer Funktionen ist immer eine dieser Funktionen. Zum Beispiel, wenn ich unsere obige Funktion mit komponiere

["blue ", ""]

(Die Funktion, bluedie der Eingabe vorangeht. ) Wir erhalten die Funktion:

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

Diese können jedoch etwas komplexer werden. Zum Beispiel, wenn wir die erste Funktion mit komponieren

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

Das Ergebnis ist

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

Aufgabe

Ihre Aufgabe ist es, zwei Funktionen zu übernehmen, die als nicht leere Listen von Zeichenfolgen beschrieben werden, und deren Zusammensetzung als nicht leere Liste von Zeichenfolgen auszugeben.

Für diesen Zweck kann eine Liste ein beliebiger sortierter Container sein, der Duplikate zulässt, und eine Zeichenfolge kann ein systemeigener Zeichenfolgentyp, eine Liste von Zeichen oder eine Liste von ganzen Zahlen sein.

Dies ist Code-Golf- Antworten werden in Bytes bewertet, wobei weniger Bytes besser sind.

Testfälle

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

Gelee , 6 Bytes

j0j@ṣ0

Ein dyadischer Link, der die erste Funktionsdarstellung rechts und die zweite Funktionsdarstellung links akzeptiert und die resultierende Funktionsdarstellung ergibt. Jede Funktionsdarstellung ist eine Liste von Zeichenlisten (Jelly hat keine anderen Zeichenfolgen).

Probieren Sie es online! (Die vollständigen Programmargumente werden in Python-Notation angegeben. Zeichenfolgen werden zu Listen. In der Fußzeile wird eine Python-Darstellung der Ausgabe des Links angezeigt.)

Hier ist eine Testsuite, die die Ausgabe des Links wie die Eingaben neu formatiert.

Wie?

Nutzt Jellys gemischte Typenlisten, um die gesamte Domäne von Darstellungen (jede Liste von Zeichenlisten) zuzulassen, indem die Ganzzahl Null als Platzhalter verwendet wird:

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

Wenn wir uns mit einer der gemischten Listen von Jelly befassen müssten (einschließlich derer mit beliebiger Tiefe oder Form), könnten wir diesen 8-Byte-Code j,©⁹jœṣ®verwenden, der die paarweisen Argumente als Platzhalter verwendet.

Haskell , 78 Bytes

(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

Probieren Sie es online!

Python 3.8 (pre-release) ,  60  58 Bytes

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

Eine unbenannte Funktion, die zwei Listen von Zeichenfolgen akzeptiert aund beine Liste von Zeichenfolgen zurückgibt.

Probieren Sie es online! Oder sehen Sie sich die Testsuite an .

Wie?

Bildet zunächst eine Trennzeichenkette v, die in aoder nicht zu finden ist b. Bilden Sie dann eine Zeichenfolge, indem Sie die Zeichenfolgen in zusammenfügenb mit Kopien von v. Bilden Sie dann eine Zeichenfolge, indem Sie die Zeichenfolgen amit Kopien davon zusammenfügen. Teilt diese Zeichenfolge schließlich in Instanzen von vauf, um eine Liste von Zeichenfolgen zu erhalten.

Während sichergestellt vist , ist nicht in aoder bwir müssen auch sicherstellen, vdass wir uns nicht früh in dem Fall trennen, in dem alle Saiten in aund bgleich sind. Zu diesem Zweck verbinden wir valle Zeichenfolgen in beiden Listen mit Instanzen einer Zeichenfolge (hier '&') und fügen ein zusätzliches, anderes Zeichen hinzu (hier '$'). Beachten Sie, dass es nicht ausreicht, eine der beiden Optionen einzeln zu verwenden, da alle Zeichenfolgen in den Eingaben dem ausgewählten Zeichen entsprechen können.

05AB1E , 4 15 19 9 11 Bytes

«TýR©ý¹sý®¡

Anders als bei der Jelly-Antwort sind der String "0", die Ganzzahl 0und der Float von 05AB1E 0.0alle (etwas) gleich, sodass ich nicht durch eine Ganzzahl trennen / verbinden kann. Aus diesem Grund hatten wir die +15 Bytes als Workarounds, obwohl ich es jetzt auf 9 Bytes zurückgesetzt habe. Vielen Dank an @ JonathanAllan für das Auffinden von 2 Bugs.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

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

Probieren Sie es online!

-1 danke an Roman

Obwohl es sich nicht um eine gültige Ausgabe handelt, wird eine Funktion zurückgegeben, die den Job tatsächlich ausführt. (34 Byte)

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

Probieren Sie es online!

Japt , 8 Bytes

Passt Jonathans Ansatz an .

qVqN²)qN

Versuch es

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 Bytes

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

Probieren Sie es online!

Hier ist meine Haskell-Antwort. Es funktioniert mit jeder Art von Liste.

J , ^{44 43 42} 29 Bytes

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

Probieren Sie es online!

-13 Bytes dank Meilen!

Dieser Ansatz verwendet ganze Zahlen und ist auf Meilen zurückzuführen.

origineller Ansatz mit Streichern

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

Probieren Sie es online!

Hinweis: Ich habe -3 aus dem TIO angepasst, um das zu berücksichtigen f=.

Verwendet Jonathan Allens Methode, angepasst für J.

Es war überraschend schwierig, Golf zu spielen, da J keine eingebaute "Join" -Methode hat, und ich wäre gespannt, ob es sich erheblich verbessern lässt.

g ist ein Hilfsverb, das uns "beitreten" lässt

JavaScript (Node.js) , 85 79 Bytes

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

Probieren Sie es online!

JavaScript, 37 Bytes

Auch passt Jonathan Ansatz .

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

Probieren Sie es online aus

Perl 5 ( -lp), 20 Bytes

Wie @JonathanAllan bemerkte, handelt es sich hierbei um ein Vollprogramm, das für IO einen Tabulator als Listentrennzeichen und eine neue Zeile zum Trennen der beiden Listen verwendet.

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

TIO

Der Tabulator und die Zeilenvorschubzeile wurden ausgewählt, da dies die Prüfung von Testfällen erleichtert. Andernfalls können die Zeichen \1und in nicht druckbare Zeichen geändert werden\2 .

( -02l012p)

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

TIO

Wie es funktioniert,

• -02 : um das Trennzeichen für den Eingabesatz auf zu setzen \2
• -l : um das Eingabetrennzeichen aus dem Standardargument zu entfernen $_ und Hinzufügen des Ausgabesatztrennzeichens zur Standardausgabe
• -012: um das Trennzeichen für Ausgabedatensätze auf \012( \n) zu setzen, damit die Ausgabe leichter überprüft werden kann

• -p : um das Standardargument zu drucken

• $n=<>; : um den nächsten Datensatz zu lesen und zuzuweisen $n

• chop$n; : um das Trennzeichen von zu entfernen $n
• s/\x1/$n/g: um alle Vorkommen von \1durch zu ersetzen$n

JavaScript (ES6),  62  59 Bytes

3 Bytes gespart dank @Shaggy

Dies ist eine feste Version von Luis 'Antwort (jetzt gelöscht), um alle Charaktere zu unterstützen.

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

Probieren Sie es online!