Digamos que tenemos un conjunto particular de funciones en cadenas. Estas funciones son como completar los espacios en blanco o madlibs, excepto que solo toman una entrada y la usan para completar todos sus espacios en blanco. Por ejemplo, podríamos tener una función similar a

I went to the ____ store and bought ____ today.

Si aplicamos esta función a la cadena, cheeseel resultado sería:

I went to the cheese store and bought cheese today.

Podemos representar estas funciones como una lista no vacía de cadenas, donde los espacios en blanco son simplemente los espacios entre cadenas. Por ejemplo, nuestra función anterior sería:

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

Con esta representación solo hay una representación para cada función de este tipo y solo una función para cada representación.

Una cosa realmente interesante es que el conjunto de tales funciones está cerrado bajo composición. Es decir, la composición de dos de nuestras funciones es siempre otra de estas funciones. Por ejemplo, si compongo nuestra función anterior con

["blue ", ""]

(la función que antecede bluea la entrada) Obtenemos la función:

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

Sin embargo, estos pueden volverse un poco más complejos. Por ejemplo, si componimos la primera función con

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

El resultado es

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

Tarea

Su tarea es tomar dos funciones como se describen como listas de cadenas no vacías y generar su composición como una lista de cadenas no vacía.

Para el propósito de este desafío, una lista puede ser cualquier contenedor ordenado que permita duplicados y una cadena puede ser un tipo de cadena nativa, una lista de caracteres o una lista de enteros.

Este es el código de respuestas de golf se puntuará en bytes, con menos bytes mejor.

Casos de prueba

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

Jalea , 6 bytes

j0j@ṣ0

Un enlace diádico que acepta la representación de la primera función a la derecha y la representación de la segunda función a la izquierda que produce la representación de la función resultante. Cada representación de función es una lista de listas de caracteres (Jelly no tiene otras cadenas).

Pruébalo en línea! (los argumentos del programa completo se dan en notación de Python; las cadenas se convierten en listas. El pie de página muestra una representación de Python de la salida del enlace).

Aquí hay un conjunto de pruebas que reformatea la salida del enlace como las entradas.

¿Cómo?

Aprovecha las listas de tipos mixtos de Jelly para permitir todo el dominio de representaciones (cualquier lista de listas de caracteres) utilizando el entero cero como marcador de posición:

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

Si necesitáramos lidiar con cualquiera de las listas mixtas de Jelly (incluidas las de cualquier profundidad o forma) podríamos usar este byte de ocho: j,©⁹jœṣ®que usa los argumentos emparejados como el marcador de posición.

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

Pruébalo en línea!

Python 3.8 (prelanzamiento) ,  60  58 bytes

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

Una función sin nombre que acepta dos listas de cadenas ay bque devuelve una lista de cadenas.

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

Primero forma una cadena de separación v, que no se puede encontrar dentro ao b. Luego forma una cadena uniendo las cadenas bcon copias de v. Luego forma una cadena uniendo las cadenas acon copias de eso. Finalmente divide esa cadena en instancias de vpara dar una lista de cadenas.

Garantizando al mismo tiempo vno está en ao btambién hay que asegurarse de que vno hará que nos separamos temprano en el caso en que todas las cuerdas en ay bson iguales. Para hacerlo, formamos vuniendo todas las cadenas en ambas listas con instancias de una cadena (aquí '&') y agregamos un carácter adicional diferente (aquí '$'). Tenga en cuenta que hacer cualquiera de ellas de forma aislada no es suficiente ya que todas las cadenas en las entradas podrían ser iguales al carácter elegido.

05AB1E , 4 15 19 9 11 bytes

«TýR©ý¹sý®¡

A diferencia de la respuesta de Jelly, la cadena "0", el entero 0y el flotador de 05AB1E 0.0son todos (algo) iguales, por lo que no puedo dividir / unir por un entero. Esta es la razón por la que teníamos los +15 bytes como soluciones alternativas, aunque ahora lo he devuelto a 9 bytes. Gracias a @JonathanAllan por encontrar 2 errores.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

«            # 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}&

Pruébalo en línea!

-1 gracias a Roman

Aunque no es una salida válida, devuelve una función que realmente hace el trabajo ... (34 bytes)

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

Pruébalo en línea!

Japt , 8 bytes

Adapta el enfoque de Jonathan .

qVqN²)qN

Intentalo

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)

Pruébalo en línea!

Aquí está mi respuesta de Haskell. Funciona en cualquier tipo de lista.

J , ^{44 43 42} 29 bytes

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

Pruébalo en línea!

-13 bytes gracias a millas!

Este enfoque utiliza números enteros y se debe a millas.

enfoque original con cuerdas

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

Pruébalo en línea!

Nota: He ajustado -3 fuera del TIO para tener en cuenta f=.

Utiliza el método de Jonathan Allen, adaptado para J.

Esto fue sorprendentemente difícil de jugar al golf, ya que J no tiene un método incorporado de "unión", y me gustaría ver si se puede mejorar significativamente.

g es un verbo auxiliar que nos da "unirse"

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

Pruébalo en línea!

JavaScript, 37 bytes

También adapta el enfoque de Jonathan .

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

Pruébalo en línea

Perl 5 ( -lp), 20 bytes

Como comentó @JonathanAllan, este es un programa completo que utiliza, para IO, una pestaña como separador de listas y una nueva línea para separar las dos listas.

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

TIO

la pestaña y la nueva línea se eligieron porque es más conveniente verificar los casos de prueba; de lo contrario, podrían cambiarse a caracteres no imprimibles \1y \2.

( -02l012p)

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

TIO

Cómo funciona,

• -02 : para establecer el separador de registro de entrada en \2
• -l: para eliminar el separador de entrada del argumento predeterminado $_y agregar el separador de registro de salida a la salida predeterminada
• -012: para establecer el separador de registro de salida en \012( \n) para que la salida sea más fácil de verificar

• -p : para imprimir el argumento predeterminado

• $n=<>; : para leer el siguiente registro y asignar a $n

• chop$n; : para eliminar el separador de $n
• s/\x1/$n/g: para reemplazar todas las ocurrencias de \1con$n

JavaScript (ES6),  62  59 bytes

Guardado 3 bytes gracias a @Shaggy

Esta es una versión fija de la respuesta de Luis (ahora eliminada) para admitir todos los caracteres.

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

Pruébalo en línea!