Disons que nous avons un ensemble particulier de fonctions sur les chaînes. Ces fonctions sont un peu comme remplir les blancs ou les madlibs, sauf qu'ils ne prennent qu'une seule entrée et l'utilisent pour remplir tous leurs blancs. Par exemple, nous pourrions avoir une fonction qui ressemble à

I went to the ____ store and bought ____ today.

Si nous appliquions cette fonction à la chaîne, cheesele résultat serait:

I went to the cheese store and bought cheese today.

Nous pouvons représenter ces fonctions comme une liste de chaînes non vide, où les blancs sont simplement les espaces entre les chaînes. Par exemple, notre fonction ci-dessus serait:

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

Avec cette représentation, il n'y a qu'une seule représentation pour chaque fonction de ce type et une seule fonction pour chaque représentation.

Une chose vraiment intéressante est que l'ensemble de ces fonctions est fermé sous la composition. C'est-à-dire que la composition de deux de nos fonctions est toujours une autre de ces fonctions. Par exemple, si je compose notre fonction ci-dessus avec

["blue ", ""]

(la fonction qui précède bluel'entrée) On obtient la fonction:

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

Celles-ci peuvent cependant devenir un peu plus complexes. Par exemple, si nous composons la première fonction avec

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

Le résultat est

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

Tâche

Votre tâche consiste à prendre deux fonctions décrites comme des listes de chaînes non vides et à afficher leur composition sous forme de liste de chaînes non vide.

Aux fins de ce défi, une liste peut être n'importe quel conteneur ordonné qui autorise les doublons et une chaîne peut être un type de chaîne natif, une liste de caractères ou une liste d'entiers.

Il s'agit de réponses au code-golf qui seront notées en octets, moins d'octets étant meilleurs.

Cas de 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"]

Gelée , 6 octets

j0j@ṣ0

Un lien dyadique acceptant la première représentation de fonction à droite et la deuxième représentation de fonction à gauche qui donne la représentation de fonction résultante. Chaque représentation de fonction est une liste de listes de caractères (Jelly n'a pas d'autres chaînes).

Essayez-le en ligne! (les arguments du programme complet sont donnés en notation Python; les chaînes deviennent des listes. Le pied de page montre une représentation Python de la sortie du lien.)

Voici une suite de tests qui reformate la sortie du lien comme les entrées.

Comment?

Profite des listes de types mixtes de Jelly pour autoriser tout le domaine des représentations (toute liste de listes de caractères) en utilisant le zéro entier comme espace réservé:

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 nous avions besoin de traiter l'une des listes mixtes de Jelly (y compris celles de n'importe quelle profondeur ou forme), nous pourrions utiliser ce huit octets: j,©⁹jœṣ®qui utilise les arguments appariés comme espace réservé .

Haskell , 78 octets

(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

Essayez-le en ligne!

Python 3.8 (pré-version) ,  60  58 octets

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

Une fonction sans nom acceptant deux listes de chaînes aet bqui renvoie une liste de chaînes.

Essayez-le en ligne! Ou consultez la suite de tests .

Comment?

Forme d'abord une chaîne de séparation, vintrouvable dans aou b. Forme ensuite une chaîne en joignant les chaînes bavec des copies de v. Forme ensuite une chaîne en joignant les chaînes aavec des copies de cela. Enfin, divise cette chaîne aux instances de vpour donner une liste de chaînes.

Tout en veillant à vn'est pas aou bnous devons également veiller à ce que vfont wont nous séparons tôt dans le cas où toutes les chaînes aet bsont égales. Pour ce faire, nous formons ven joignant toutes les chaînes des deux listes avec des instances d'une chaîne (ici '&') et en ajoutant un caractère différent et différent (ici '$'). Notez que faire l'une ou l'autre isolément n'est pas suffisant car toutes les chaînes dans les entrées peuvent être égales au caractère choisi.

05AB1E , 4 15 19 9 11 octets

«TýR©ý¹sý®¡

Contrairement à la réponse Jelly, la chaîne "0", l'entier 0et le flottant de 05AB1E 0.0sont tous (quelque peu) égaux, donc je ne peux pas séparer / joindre par un entier. C'est pourquoi nous avons eu les +15 octets comme solutions de contournement, bien que je les ai revus à 9 octets maintenant. Merci à @JonathanAllan d' avoir trouvé 2 bugs.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Essayez-le en ligne!

-1 grâce à Roman

Bien que ce ne soit pas une sortie valide, cela renvoie une fonction qui fait le travail. (34 octets)

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

Essayez-le en ligne!

Japt , 8 octets

Adapte l'approche de Jonathan .

qVqN²)qN

Essayez-le

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 octets

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

Essayez-le en ligne!

Voici ma réponse Haskell. Il fonctionne sur tout type de liste.

J , ^{44 43 42} 29 octets

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

Essayez-le en ligne!

-13 octets grâce aux miles!

Cette approche utilise des nombres entiers et est due aux miles.

approche originale avec des cordes

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

Essayez-le en ligne!

Remarque: J'ai ajusté -3 du TIO pour tenir compte de f=.

Utilise la méthode de Jonathan Allen, adaptée pour J.

Cela a été étonnamment difficile à jouer au golf, car J n'a pas de méthode intégrée de «jointure», et je serais curieux de voir si elle peut être améliorée de manière significative.

g est un verbe auxiliaire qui nous donne "rejoindre"

JavaScript (Node.js) , 85 79 octets

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

Essayez-le en ligne!

JavaScript, 37 octets

Adapte également l'approche de Jonathan .

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

Essayez-le en ligne

Perl 5 ( -lp), 20 octets

Comme l'a commenté @JonathanAllan, il s'agit d'un programme complet utilisant, pour IO, un onglet comme séparateur de liste et une nouvelle ligne pour séparer les deux listes.

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

TIO

l'onglet et le retour à la ligne ont été choisis parce qu'il est plus pratique de vérifier les cas de test, sinon ils pourraient être modifiés en caractères non imprimables \1et \2.

( -02l012p)

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

TIO

Comment ça fonctionne,

• -02 : pour définir le séparateur d'enregistrement d'entrée sur \2
• -l: pour supprimer le séparateur d'entrée de l'argument par défaut $_et pour ajouter le séparateur d'enregistrement de sortie à la sortie par défaut
• -012: pour définir le séparateur d'enregistrement de sortie sur \012( \n) afin que la sortie soit plus facile à vérifier

• -p : pour afficher l'argument par défaut

• $n=<>; : pour lire l'enregistrement suivant et attribuer à $n

• chop$n; : pour supprimer le séparateur de $n
• s/\x1/$n/g: pour remplacer toutes les occurrences de \1par$n

JavaScript (ES6),  62  59 octets

Enregistré 3 octets grâce à @Shaggy

Il s'agit d'une version fixe de la réponse de Luis (maintenant supprimée) pour prendre en charge tous les personnages.

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

Essayez-le en ligne!