Tâche

Étant donné deux listes de caractères, sortez leur produit cartésien, c'est-à-dire la liste des appariements de chaque lettre de la première liste avec chaque lettre de la deuxième liste.

Exemple

"123456"et "abcd"donner:

[["1","a"],["1","b"],["1","c"],["1","d"],["2","a"],["2","b"],["2","c"],["2","d"],["3","a"],["3","b"],["3","c"],["3","d"],["4","a"],["4","b"],["4","c"],["4","d"],["5","a"],["5","b"],["5","c"],["5","d"],["6","a"],["6","b"],["6","c"],["6","d"]]

Contribution

Deux listes de caractères ou de chaînes. Les caractères utilisés seront alphanumériques a-z, A-Z, 0-9et un caractère peut apparaître à la fois plusieurs fois et dans les deux entrées en même temps.

Production

Produit cartésien des listes d'entrées. C'est-à-dire une liste de chaque paire ordonnée possible d'un caractère de la première liste et d'un caractère de la seconde liste. Chaque paire est une liste ou une chaîne ou similaire de deux caractères ou de deux chaînes de longueur un. La longueur de la sortie sera égale au produit des longueurs des entrées.

Les paires doivent être répertoriées dans l'ordre; listant d'abord le premier caractère de la première liste avec le premier de la deuxième liste, suivi de tous les appariements du premier caractère de la première liste. La dernière paire se compose du dernier caractère de la première liste avec le dernier caractère de la deuxième liste.

La sortie doit être une liste plate de paires; pas une matrice 2D où les paires sont groupées par leur premier ou deuxième élément.

Cas de test

inputs               output

"123456", "abcd"     [["1","a"],["1","b"],["1","c"],["1","d"],["2","a"],["2","b"],["2","c"],["2","d"],["3","a"],["3","b"],["3","c"],["3","d"],["4","a"],["4","b"],["4","c"],["4","d"],["5","a"],["5","b"],["5","c"],["5","d"],["6","a"],["6","b"],["6","c"],["6","d"]]
"abc", "123"         [["a","1"],["a","2"],["a","3"],["b","1"],["b","2"],["b","3"],["c","1"],["c","2"],["c","3"]]
"aa", "aba"          [["a","a"],["a","b"],["a","a"],["a","a"],["a","b"],["a","a"]]

05AB1E , 1 octet

â

Essayez-le en ligne!

Haskell , 12 octets

(<*>).map(,)

Essayez-le en ligne!

Mathematica, 12 octets

Tuples@{##}&

Prend deux listes de caractères en entrée.

APL (Dyalog) , 4 octets

,∘.,

Essayez-le en ligne!

, aplatir

∘. le cartésien

, enchaînement

Rubis , 30 18 octets

-12 octets de Jordan me rappelant un moyen d'utiliser la spécification à mon avantage!

Prend des listes de caractères en entrée.

->a,b{a.product b}

Essayez-le en ligne!

Perl 6 , 4 octets

&[X]

Ceci est juste une référence à l'opérateur intégré de produits croisés X. Il fonctionne sur des listes de toutes sortes, pas seulement sur des personnages.

Gelée , 1 octet

p

Essayez-le en ligne!

Octave, 32 octets

@(a,b)[(a+~b')(:) (b'+~a)(:) '']

Essayez-le en ligne!

Tcl , 60 octets

proc p x\ y {lmap X $x {lmap Y $y {lappend l $X\ $Y}};set l}

Utilisation:

% p {1 2 3} {a 2 2}
{1 a} {1 2} {1 2} {2 a} {2 2} {2 2} {3 a} {3 2} {3 2}

JavaScript (ES6), 45 36 34 33 octets

Nécessite Firefox. Prend les deux entrées sous forme de chaînes ou de tableaux de caractères individuels.

a=>b=>[for(x of a)for(y of b)x+y]

• -1 octet grâce à CalculatorFeline repérant un errant <space>.

Essayez-le

f=
a=>b=>[for(x of a)for(y of b)x+y]
oninput=_=>console.clear()&console.log(f(i.value)(j.value))
console.log(f(i.value="123456")(j.value="abcd"))

<input id=i><input id=j>

Bash, 18 ans

Cela peut être fait avec des extensions d'accolade:

eval echo {$1}{$2}

Essayez-le en ligne .

Brachylog , 5 octets

{∋ᵐ}ᶠ

Essayez-le en ligne!

Explication

Assez explicite

{  }ᶠ       Find all:
  ᵐ           Map:
 ∋              In

QBIC , 29 octets

[_l;||[_l;||?_sA,a,1|+_sB,b,1

Cela imprime des chaînes de 2 caractères avec toutes les combinaisons sur une ligne chacune.

Explication

   ;      Read in string A$
 _l |     Get its length as b
[    |    and kick off a FOR-loop from 1 to that
[_l;||    Do the same for B$
          Note that, while the FOR-loop may pass this code several times, the
          'read-from cmd line' is done only once.
?_sA,a,1| PRINT the character from A$ at the position of the 'a' loop counter
+_sB,a,1   concatenated with the char from B$ at the pos of the 'b' loop counter

Pyth , 3 octets

*ww

La multiplication de deux chaînes agit simplement comme le produit cartésien.

Testez-le en ligne!

MATL , 2 octets

Z*

*est l'opérateur général des produits et le préfixe en Zfait le produit cartésien et peut prendre deux chaînes comme arguments.

Essayez-le en ligne!

En fait , 1 octet

∙

Essayez-le en ligne!

∙ est la commande de produit cartésien.

Ohm , 1 octet

╒

Essayez-le en ligne!

Littéralement seulement le intégré

J, 3 octets

,@{

C'est le verbe Catalogue dans J. Il faut Ravel ( ,) le résultat pour le rendre 1 dimensionnel.

Essayez-le en ligne!

Lisp commun, 63 octets

(lambda(a b)(mapcan(lambda(x)(mapcar(lambda(y)(list x y))b))a))

Essayez-le en ligne!

Clojure, 21 octets

#(for[i % j %2][i j])

PHP , 69 octets

<?foreach($_GET[0]as$x)foreach($_GET[1]as$y)$r[]=[$x,$y];print_r($r);

Essayez-le en ligne!

Python 2 , 39 octets

lambda x,y:[[i,j]for i in x for j in y]

Essayez-le en ligne!

Solution alternative, 34 30 octets

-4 octets grâce à Anders Kaseorg.

Il y a un intégré pour cela ...

from itertools import*
product

Cheddar , 52 octets

a->b->a.chars.map(i->b.chars.map(i&(+))).reduce((+))

Essayez-le en ligne!

05AB1E , 10 octets

v²NFÀ}¹ø)˜

Essayez-le en ligne!

C'est sans le intégré, et sans aucun doute ne sera pas compétitif.

Rétine , 49 octets

.(?=.*¶(.+))
$1$&¶
¶¶.+
¶
.(?=.*(.)¶)
$1$&¶
¶.¶
¶

Essayez-le en ligne! Prend l'entrée sur des lignes distinctes. Explication:

.(?=.*¶(.+))
$1$&¶

Chaque caractère de la première chaîne génère une ligne distincte préfixée par la deuxième chaîne.

¶¶.+
¶

La deuxième chaîne d'origine est supprimée.

.(?=.*(.)¶)
$1$&¶

Pour chaque caractère de la première chaîne, chaque caractère de la deuxième chaîne génère une ligne distincte préfixée avec le premier caractère.

¶.¶
¶

Les caractères restants de la première chaîne sont supprimés.

q / kdb +, 5 octets

Solution:

cross           / yup, there's a built-in to do exactly this

Exemple:

q)"123456"cross"abcd"
"1a"
"1b"
"1c"
"1d"
"2a"
"2b"
"2c"
"2d"
"3a"
"3b"
"3c"
"3d"
"4a"
"4b"
...etc

Fusain , 8 7 octets

ＦθＥη⁺ικ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication: Les variables θet ηfont implicitement référence aux deux chaînes d'entrée. La Ｆcommande boucle sur chaque caractère de la première entrée, tandis que la Ｅcommande mappe sur chaque caractère de la deuxième entrée concaténant la variable de boucle ιet la variable de mappage κ, dont le résultat est implicitement imprimé sur des lignes distinctes.

R , 29 octets

function(x,y)outer(x,y,paste)

Essayez-le en ligne!

Notez que la matrice R est remplie par colonne, donc le résultat est dans l'ordre dicté par la spécification.

S'il est permis d'avoir factorspour l'entrée et la sortie, il y a un intégré ... mais il faut extraire les niveaux résultants du facteur donc à la fin ce serait plus de 29 octets.

R , 11 octets

interaction

Essayez-le en ligne!

Japt , 5 2 octets

Japt dispose désormais d'une méthode pour le produit cartésien.

Prend l'entrée comme 2 tableaux de chaînes de caractères.

ïV

Essayez-le

C # 7, 78 63 octets

(a,b)=>$"({string.Join(",",a.SelectMany(x=>b,(x,y)=>(x,y)))})";