Digamos que temos um conjunto específico de funções em strings. Essas funções são como preencher os espaços em branco ou madlibs, exceto que eles apenas recebem uma entrada e a usam para preencher todos os espaços em branco. Por exemplo, podemos ter uma função que se parece com

I went to the ____ store and bought ____ today.

Se aplicássemos essa função à string, cheeseo resultado seria:

I went to the cheese store and bought cheese today.

Podemos representar essas funções como uma lista não vazia de cadeias, onde os espaços em branco são simplesmente as lacunas entre as cadeias. Por exemplo, nossa função acima seria:

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

Com essa representação, há apenas uma representação para cada função desse tipo e apenas uma função para cada representação.

Uma coisa realmente interessante é que o conjunto de tais funções é fechado sob composição. Ou seja, a composição de duas de nossas funções é sempre outra dessas funções. Por exemplo, se eu compor nossa função acima com

["blue ", ""]

(a função que antecede bluea entrada) Recebemos a função:

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

Estes podem ficar um pouco mais complexos. Por exemplo, se compormos a primeira função com

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

O resultado é

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

Tarefa

Sua tarefa é executar duas funções, como descritas como listas de cadeias não vazias, e produzir sua composição como uma lista de cadeias não vazias.

Para o objetivo desse desafio, uma lista pode ser qualquer contêiner ordenado que permita duplicatas e uma sequência pode ser do tipo nativo, uma lista de caracteres ou uma lista de números inteiros.

Esse é o código do golfe - as respostas serão pontuadas em bytes, com menos bytes sendo melhores.

Casos de teste

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

Gelatina , 6 bytes

j0j@ṣ0

Um link diádico que aceita a primeira representação de função à direita e a segunda representação de função à esquerda, que produz a representação de função resultante. Cada representação de função é uma lista de listas de caracteres (o Jelly não possui outras strings).

Experimente online! (os argumentos do programa completo são fornecidos na notação Python; as strings se tornam listas. O rodapé mostra uma representação Python da saída do Link.)

Aqui está um conjunto de testes que reformata a saída do Link como as entradas.

Quão?

Aproveita as listas de tipos mistos de Jelly para permitir todo o domínio de representações (qualquer lista de listas de caracteres) usando o número inteiro zero como marcador de posição:

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

Se precisássemos lidar com qualquer uma das listas mistas de Jelly (incluindo aquelas de qualquer profundidade ou forma), poderíamos usar este oito byter: j,©⁹jœṣ®que usa os argumentos emparelhados como o marcador de posição.

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

Experimente online!

Python 3.8 (pré-lançamento) ,  60  58 bytes

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

Uma função sem nome que aceita duas listas de cadeias ae b, que retorna uma lista de cadeias.

Experimente online! Ou veja a suíte de testes .

Quão?

Primeiro forma uma cadeia separadora v, que não pode ser encontrada dentro aou b. Em seguida, forma uma string juntando as strings bcom cópias de v. Em seguida, forma uma string juntando as strings acom cópias disso. Finalmente divide essa string nas instâncias de vpara fornecer uma lista de strings.

Garantindo ao mesmo tempo vnão está na aou bdevemos também garantir que vnão vai nos fazer dividir cedo no caso em que todas as cordas em ae bsão iguais. Para fazer isso, formamos vjuntando todas as seqüências de caracteres em ambas as listas às instâncias de uma sequência de caracteres (aqui '&') e adicionamos um caractere extra diferente (aqui '$'). Observe que fazer isso isoladamente não é suficiente, pois todas as seqüências de caracteres nas entradas podem ser iguais ao caractere escolhido.

05AB1E , 4 15 19 9 11 bytes

«TýR©ý¹sý®¡

Diferentemente da resposta Jelly, a string "0", o inteiro 0e o float de 05AB1E 0.0são todos (um pouco) iguais, então não posso dividir / unir por um número inteiro. É por isso que tínhamos os +15 bytes como soluções alternativas, embora eu tenha devolvido agora aos 9 bytes. Graças a @ JonathanAllan por encontrar 2 bugs.

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Experimente online!

-1 graças a Roman

Embora não seja uma saída válida, isso retorna uma função que realmente faz o trabalho .. (34 bytes)

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

Experimente online!

Japt , 8 bytes

Adapta a abordagem de Jonathan .

qVqN²)qN

Tente

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)

Experimente online!

Aqui está a minha resposta Haskell. Funciona em qualquer tipo de lista.

J , ^{44 43 42} 29 bytes

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

Experimente online!

-13 bytes graças a milhas!

Essa abordagem usa números inteiros e é devido a milhas.

abordagem original com strings

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

Experimente online!

Nota: ajustei -3 do TIO para dar conta de f=.

Usa o método de Jonathan Allen, adaptado para J.

Isso foi surpreendentemente difícil para o golfe, já que J não possui um método de "associação" incorporado, e eu ficaria curioso para ver se ele pode ser melhorado significativamente.

g é um verbo auxiliar que nos dá "junção"

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

Experimente online!

JavaScript, 37 bytes

Também se adapta a abordagem de Jonathan .

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

Experimente online

Perl 5 (-lp ), 20 bytes

Como @JonathanAllan comentou, este é um programa completo usando, para E / S, uma guia como separador de lista e uma nova linha para separar as duas listas.

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

TIO

a guia e a nova linha foram escolhidas porque era mais conveniente verificar os casos de teste; caso contrário, poderiam ser alterados para caracteres não imprimíveis \1e\2 .

( -02l012p)

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

TIO

Como funciona,

• -02 : para definir o separador de registros de entrada como \2
• -l: para remover o separador de entrada do argumento padrão $_e adicionar o separador de registro de saída à saída padrão
• -012: para definir o separador de registros de saída como \012( \n) para facilitar a verificação da saída

• -p : para imprimir o argumento padrão

• $n=<>; : ler o próximo registro e atribuir a $n

• chop$n; : para remover o separador de $n
• s/\x1/$n/g: para substituir todas as ocorrências de \1por$n

JavaScript (ES6),  62  59 bytes

Guardado 3 bytes graças a @Shaggy

Esta é uma versão fixa da resposta de Luis (agora excluída) para suportar todos os caracteres.

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

Experimente online!