Tarea

Dadas dos listas de caracteres, genera su producto cartesiano, es decir, la lista de emparejamientos de cada letra de la primera lista con cada letra de la segunda lista.

Ejemplo

"123456"y "abcd"dar:

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

Entrada

Dos listas de caracteres o cadenas. Los caracteres utilizados serán alfanuméricos.a-z, A-Z, 0-9 y un carácter puede aparecer varias veces y en ambas entradas al mismo tiempo.

Salida

El producto cartesiano de las listas de entrada. Es decir, una lista de cada posible par ordenado de un personaje de la primera lista y un personaje de la segunda lista. Cada par es una lista o cadena o similar de dos caracteres, o de dos cadenas de longitud uno. La longitud de la salida será igual al producto de las longitudes de las entradas.

Los pares deben estar listados en orden; primero enumera el primer carácter de la primera lista con el primero de la segunda lista, seguido de todos los pares del primer carácter de la primera lista. El último par consiste en el último carácter de la primera lista junto con el último carácter de la segunda lista.

La salida debe ser una lista plana de pares; no es una matriz 2D donde los pares se agrupan por su primer o segundo elemento.

Casos de prueba

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 byte

â

Pruébalo en línea!

Haskell , 12 bytes

(<*>).map(,)

Pruébalo en línea!

Mathematica, 12 bytes

Tuples@{##}&

Toma dos listas de caracteres como entrada.

APL (Dyalog) , 4 bytes

,∘.,

Pruébalo en línea!

, aplanar

∘. el cartesiano

, concatenación

Rubí , 30 18 bytes

-12 bytes de Jordan recordándome una forma de usar las especificaciones para mi ventaja.

Toma listas de caracteres como entrada.

->a,b{a.product b}

Pruébalo en línea!

Perl 6 , 4 bytes

&[X]

Esto es solo una referencia al operador integrado de productos cruzados X. Funciona en listas de cualquier tipo, no solo en personajes.

Jalea , 1 byte

p

Pruébalo en línea!

Octava, 32 bytes

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

Pruébalo en línea!

Tcl , 60 bytes

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

Utilizar:

% 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 bytes

Requiere Firefox Toma ambas entradas como cadenas o como matrices de caracteres individuales.

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

• -1 byte gracias a CalculatorFeline que detecta un error <space>.

Intentalo

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

Esto se puede hacer con expansiones de llaves:

eval echo {$1}{$2}

Pruébalo en línea .

Brachylog , 5 bytes

{∋ᵐ}ᶠ

Pruébalo en línea!

Explicación

Bastante autoexplicativo

{  }ᶠ       Find all:
  ᵐ           Map:
 ∋              In

QBIC , 29 bytes

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

Esto imprime cadenas de 2 caracteres con todas las combinaciones en una línea cada una.

Explicación

   ;      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 bytes

*ww

Multiplicar dos cadenas solo actúa como el producto cartesiano.

¡Pruébalo en línea!

MATL , 2 bytes

Z*

*es el operador general de los productos y el prefijo lo Zconvierte en el producto cartesiano y puede tomar dos cadenas como argumentos.

Pruébalo en línea!

En realidad , 1 byte

∙

Pruébalo en línea!

∙ es el comando del producto cartesiano.

Ohm , 1 byte

╒

Pruébalo en línea!

Literalmente solo el incorporado

J, 3 bytes

,@{

Este es el verbo Catálogo en J. Necesitamos Ravel ( ,) el resultado para hacerlo 1 dimensional.

Pruébalo en línea!

Lisp común, 63 bytes

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

Pruébalo en línea!

Clojure, 21 bytes

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

PHP , 69 bytes

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

Pruébalo en línea!

Python 2 , 39 bytes

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

Pruébalo en línea!

Solución alternativa, 34 30 bytes

-4 bytes gracias a Anders Kaseorg.

Hay una función incorporada para esto ...

from itertools import*
product

Cheddar , 52 bytes

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

Pruébalo en línea!

05AB1E , 10 bytes

v²NFÀ}¹ø)˜

Pruébalo en línea!

Esto es sin el incorporado, y sin duda no será competitivo.

Retina , 49 bytes

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

Pruébalo en línea! Toma entrada en líneas separadas. Explicación:

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

Cada carácter en la primera cadena genera una línea separada con el prefijo de la segunda cadena.

¶¶.+
¶

La segunda cadena original se elimina.

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

Para cada carácter en la primera cadena, cada carácter en la segunda cadena genera una línea separada con el primer carácter como prefijo.

¶.¶
¶

Los caracteres sobrantes de la primera cadena se eliminan.

q / kdb +, 5 bytes

Solución:

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

Ejemplo:

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

Carbón , 8 7 bytes

ＦθＥη⁺ικ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: Las variables θe ηimplícitamente se refieren a las dos cadenas de entrada. El Ｆcomando recorre cada carácter de la primera entrada, mientras que elＥ comando asigna sobre cada carácter de la segunda entrada que concatena la variable de bucle ιy la variable del mapa κ, cuyo resultado se imprime implícitamente en líneas separadas.

R , 29 bytes

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

Pruébalo en línea!

Tenga en cuenta que la matriz R se llena por columna, por lo que el resultado está en el orden dictado por la especificación.

Si se permite tener factorsentrada y salida, hay una función incorporada ... pero es necesario extraer los niveles resultantes del factor para que al final sea más de 29 bytes.

R , 11 bytes

interaction

Pruébalo en línea!

Japt , 5 2 bytes

Japt ahora tiene un método para el producto cartesiano.

Toma la entrada como 2 matrices de cadenas de caracteres.

ïV

Intentalo

C # 7, 78 63 bytes

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