Diciamo che abbiamo un insieme particolare di funzioni sulle stringhe. Queste funzioni sono un po 'come riempire gli spazi vuoti o i madlibs, tranne che prendono solo un input e lo usano per riempire tutti i loro spazi. Ad esempio potremmo avere una funzione simile

I went to the ____ store and bought ____ today.

Se applicassimo questa funzione alla stringa cheeseil risultato sarebbe:

I went to the cheese store and bought cheese today.

Possiamo rappresentare queste funzioni come un elenco non vuoto di stringhe, in cui gli spazi vuoti sono semplicemente gli spazi tra le stringhe. Ad esempio la nostra funzione sopra sarebbe:

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

Con questa rappresentazione esiste una sola rappresentazione per ogni funzione di questo tipo e una sola funzione per ogni rappresentazione.

Una cosa davvero ordinata è che l'insieme di tali funzioni è chiuso sotto composizione. Ciò significa che la composizione di due delle nostre funzioni è sempre un'altra di queste funzioni. Ad esempio se compongo la nostra funzione sopra con

["blue ", ""]

(la funzione che antepone bluel'ingresso) Otteniamo la funzione:

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

Questi possono però diventare un po 'più complessi. Ad esempio se componiamo la prima funzione con

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

Il risultato è

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

Compito

Il tuo compito è quello di prendere due funzioni come descritte come elenchi di stringhe non vuoti e generare la loro composizione come un elenco di stringhe non vuoti.

Ai fini di questa sfida, un elenco può essere qualsiasi contenitore ordinato che consente duplicati e una stringa può essere un tipo di stringa nativo, un elenco di caratteri o un elenco di numeri interi.

Questo è il codice-golf le risposte saranno segnate in byte con meno byte migliori.

Casi test

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

j0j@ṣ0

Un collegamento diadico che accetta la prima rappresentazione della funzione a destra e la seconda rappresentazione della funzione a sinistra che produce la rappresentazione della funzione risultante. Ogni rappresentazione di funzione è un elenco di elenchi di caratteri (Jelly non ha altre stringhe).

Provalo online! (gli argomenti del programma completo sono riportati nella notazione Python; le stringhe diventano elenchi. Il piè di pagina mostra una rappresentazione Python dell'output del Link.)

Ecco una suite di test che riformatta l'output del Link come gli input.

Come?

Sfrutta gli elenchi di tipi misti di Jelly per consentire l'intero dominio di rappresentazioni (qualsiasi elenco di elenchi di caratteri) utilizzando lo zero intero come segnaposto:

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 avessimo bisogno di trattare una delle liste miste di Jelly (comprese quelle di qualsiasi profondità o forma) potremmo usare questo otto byte: j,©⁹jœṣ®che usa gli argomenti accoppiati come segnaposto .

Haskell , 78 byte

(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

Provalo online!

Python 3.8 (pre-release) ,  60  58 byte

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

Una funzione senza nome che accetta due elenchi di stringhe ae bche restituisce un elenco di stringhe.

Provalo online! Oppure vedi la suite di test .

Come?

Innanzitutto forma una stringa di separazione v, che non può essere trovata all'interno ao b. Quindi forma una stringa unendo le stringhe bcon copie di v. Quindi forma una stringa unendo le stringhe acon copie di quella. Infine divide quella stringa nelle istanze di vper dare un elenco di stringhe.

Pur garantendo che vnon ci sia ao bdobbiamo anche assicurarci che vnon ci facciano dividere in anticipo nel caso in cui tutte le stringhe siano ae bsiano uguali. Per fare ciò, ci formiamo vunendo tutte le stringhe in entrambe le liste con le istanze di una stringa (qui '&') e aggiungiamo un ulteriore carattere diverso (qui '$'). Notare che eseguire una delle due operazioni separatamente non è sufficiente poiché tutte le stringhe negli input potrebbero eguagliare il carattere scelto.

05AB1E , 4 15 19 9 11 byte

«TýR©ý¹sý®¡

A differenza della risposta di Jelly, stringa "0", numero intero 0e float di 05AB1E 0.0sono tutti (un po ') uguali, quindi non posso dividere / unire per un numero intero. Questo è il motivo per cui abbiamo avuto i +15 byte come soluzioni alternative, anche se ora l'ho ripristinato a 9 byte. Grazie a @JonathanAllan per aver trovato 2 bug.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

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

Provalo online!

-1 grazie a Roman

Sebbene non sia un output valido, restituisce una funzione che svolge effettivamente il lavoro. (34 byte)

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

Provalo online!

Japt , 8 byte

Adatta l'approccio di Jonathan .

qVqN²)qN

Provalo

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 byte

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

Provalo online!

Ecco la mia risposta Haskell. Funziona su qualsiasi tipo di elenco.

J , ^{44 43 42} 29 byte

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

Provalo online!

-13 byte grazie alle miglia!

Questo approccio utilizza numeri interi ed è dovuto alle miglia.

approccio originale con stringhe

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

Provalo online!

Nota: ho modificato -3 del TIO per tener conto f=.

Utilizza il metodo di Jonathan Allen, adattato per J.

È stato sorprendentemente difficile giocare a golf, dal momento che J non ha un metodo "join" integrato e sarei curioso di vedere se può essere migliorato in modo significativo.

g è un verbo helper che ci dà "unisciti"

JavaScript (Node.js) , 85 79 byte

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

Provalo online!

JavaScript, 37 byte

Adatta anche l'approccio di Jonathan .

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

Provalo online

Perl 5 ( -lp), 20 byte

Come ha commentato @JonathanAllan, questo è un programma completo che utilizza, per IO, una scheda come separatore di elenchi e una nuova riga per separare i due elenchi.

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

TIO

la scheda e la nuova riga sono state scelte perché più convenienti per controllare i casi di test, altrimenti potrebbero essere cambiati in caratteri non stampabili \1e \2.

( -02l012p)

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

TIO

Come funziona,

• -02 : per impostare il separatore record di input su \2
• -l: per rimuovere il separatore di input dall'argomento predefinito $_e per aggiungere il separatore del record di output all'output predefinito
• -012: per impostare il separatore dei record di output su \012( \n) in modo che l'output sia più facile da controllare

• -p : per stampare l'argomento predefinito

• $n=<>; : leggere il prossimo record e assegnare a $n

• chop$n; : per rimuovere il separatore da $n
• s/\x1/$n/g: per sostituire tutte le occorrenze di \1con$n

JavaScript (ES6),  62  59 byte

Salvato 3 byte grazie a @Shaggy

Questa è una versione fissa della risposta di Luis (ora eliminata) per supportare tutti i personaggi.

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

Provalo online!