Tarefa

Dadas duas listas de caracteres, produza seu produto cartesiano, ou seja, a lista de pares de cada letra da primeira lista com cada letra da segunda lista.

Exemplo

"123456"e "abcd"dê:

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

Duas listas de caracteres ou seqüências de caracteres. Os caracteres usados ​​serão alfanuméricos a-z, A-Z, 0-9e um caractere pode ocorrer várias vezes e em ambas as entradas ao mesmo tempo.

Resultado

O produto cartesiano das listas de entrada. Ou seja, uma lista de cada par ordenado possível de um personagem da primeira lista e um caractere da segunda lista. Cada par é uma lista ou sequência ou similar de dois caracteres ou de duas seqüências de comprimento um. O comprimento da saída será igual ao produto dos comprimentos das entradas.

Os pares devem ser listados em ordem; primeiro listando o primeiro caractere da primeira lista com o primeiro da segunda lista, seguido por todos os pares do primeiro caractere da primeira lista. O último par consiste no último caractere da primeira lista, juntamente com o último caractere da segunda lista.

A saída deve ser uma lista simples de pares; não é uma matriz 2D em que os pares são agrupados por seu primeiro ou segundo elemento.

Casos de teste

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

â

Experimente online!

Haskell , 12 bytes

(<*>).map(,)

Experimente online!

Mathematica, 12 bytes

Tuples@{##}&

Leva duas listas de caracteres como entrada.

APL (Dyalog) , 4 bytes

,∘.,

Experimente online!

, aplainar

∘. o cartesiano

, concatenação

Ruby , 30 18 bytes

-12 bytes da Jordânia, lembrando-me de uma maneira de usar as especificações em meu proveito!

Leva listas de caracteres como entrada.

->a,b{a.product b}

Experimente online!

Perl 6 , 4 bytes

&[X]

Esta é apenas uma referência ao operador interno de produtos cruzados X. Funciona em listas de qualquer tipo, não apenas em caracteres.

Geléia , 1 byte

p

Experimente online!

Oitava, 32 bytes

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

Experimente online!

Tcl , 60 bytes

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

Usar:

% 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

Requer Firefox. Recebe as duas entradas como seqüências de caracteres ou como matrizes de caracteres individuais.

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

• -1 byte graças ao CalculatorFeline detectando um erro <space>.

Tente

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

Isso pode ser feito com expansões de chaves:

eval echo {$1}{$2}

Experimente online .

Braquilog , 5 bytes

{∋ᵐ}ᶠ

Experimente online!

Explicação

Bastante auto-explicativo

{  }ᶠ       Find all:
  ᵐ           Map:
 ∋              In

QBIC , 29 bytes

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

Isso imprime seqüências de caracteres de 2 caracteres com todas as combinações em uma linha cada.

Explicação

   ;      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

Pitão , 3 bytes

*ww

Multiplicar duas cordas apenas atua como o produto cartesiano.

Teste online!

MATL , 2 bytes

Z*

*é o operador geral de produtos e o prefixo o Ztorna o produto cartesiano e pode usar duas seqüências de caracteres como argumentos.

Experimente online!

Na verdade , 1 byte

∙

Experimente online!

∙ é o comando do produto cartesiano.

Ohm , 1 byte

╒

Experimente online!

Literalmente apenas o built-in

J, 3 bytes

,@{

Este é o verbo Catalog em J. Precisamos Ravel ( ,) do resultado para torná-lo unidimensional.

Experimente online!

Lisp comum, 63 bytes

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

Experimente online!

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

Experimente online!

Python 2 , 39 bytes

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

Experimente online!

Solução alternativa, 34 30 bytes

-4 bytes graças a Anders Kaseorg.

Há um built-in para isso ...

from itertools import*
product

Cheddar , 52 bytes

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

Experimente online!

05AB1E , 10 bytes

v²NFÀ}¹ø)˜

Experimente online!

Isso é sem o built-in e, sem dúvida, não será competitivo.

Retina , 49 bytes

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

Experimente online! Recebe entrada em linhas separadas. Explicação:

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

Cada caractere na primeira string gera uma linha separada prefixada pela segunda string.

¶¶.+
¶

A segunda sequência original é excluída.

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

Para cada caractere na primeira string, cada caractere na segunda string gera uma linha separada prefixada com o primeiro caractere.

¶.¶
¶

Os caracteres restantes da primeira string são excluídos.

q / kdb +, 5 bytes

Solução:

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

Exemplo:

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

Carvão , 8 7 bytes

ＦθＥη⁺ικ

Experimente online! Link é a versão detalhada do código. Explicação: As variáveis θe se ηreferem implicitamente às duas cadeias de entrada. O Ｆcomando faz um loop sobre cada caractere da primeira entrada, enquanto o Ｅcomando mapeia cada caractere da segunda entrada concatenando a variável de loop ιe a variável de mapa κ, cujo resultado é impresso implicitamente em linhas separadas.

R , 29 bytes

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

Experimente online!

Observe que a matriz R é preenchida por coluna, portanto, o resultado está na ordem ditada pela especificação.

Se houver permissão factorspara entrada e saída, existe um built-in ... mas é preciso extrair os níveis resultantes do fator, de modo que no final seriam mais de 29 bytes.

R , 11 bytes

interaction

Experimente online!

Japonês , 5 2 bytes

Japt agora tem um método para o produto cartesiano.

Recebe entrada como 2 matrizes de cadeias de caracteres.

ïV

Tente

C # 7, 78 63 bytes

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