Compito

Dati due elenchi di caratteri, genera il loro prodotto cartesiano, ovvero l'elenco di accoppiamenti di ogni lettera dal primo elenco con ogni lettera dal secondo elenco.

Esempio

"123456"e "abcd"dare:

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

Ingresso

Due elenchi di caratteri o stringhe. I caratteri utilizzati saranno alfanumerici a-z, A-Z, 0-9e un personaggio può apparire contemporaneamente più volte e in entrambi gli input.

Produzione

Il prodotto cartesiano delle liste di input. Cioè, un elenco di ogni possibile coppia ordinata di un carattere dal primo elenco e un carattere dal secondo elenco. Ogni coppia è un elenco o una stringa o simile di due caratteri o di due stringhe lunghezza-uno. La lunghezza dell'output sarà uguale al prodotto delle lunghezze degli input.

Le coppie devono essere elencate in ordine; prima elencando il primo carattere del primo elenco con il primo del secondo elenco, seguito da tutti gli accoppiamenti del primo carattere del primo elenco. L'ultima coppia è costituita dall'ultimo carattere del primo elenco insieme all'ultimo carattere del secondo elenco.

L'output deve essere un elenco semplice di coppie; non una matrice 2D in cui le coppie sono raggruppate per il loro primo o secondo elemento.

Casi 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 byte

â

Provalo online!

Haskell , 12 byte

(<*>).map(,)

Provalo online!

Mathematica, 12 byte

Tuples@{##}&

Accetta due elenchi di caratteri come input.

APL (Dyalog) , 4 byte

,∘.,

Provalo online!

, appiattire

∘. il cartesiano

, concatenazione

Rubino , 30 18 byte

-12 byte dalla Giordania che mi ricordano un modo per usare le specifiche a mio vantaggio!

Accetta gli elenchi di caratteri come input.

->a,b{a.product b}

Provalo online!

Perl 6 , 4 byte

&[X]

Questo è solo un riferimento all'operatore di prodotti incrociati integrato X. Funziona su elenchi di qualsiasi tipo, non solo sui personaggi.

Gelatina , 1 byte

p

Provalo online!

Ottava, 32 byte

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

Provalo online!

Tcl , 60 byte

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

Uso:

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

Richiede Firefox. Prende entrambi gli input come stringhe o come array di singoli caratteri.

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

• -1 byte grazie a CalculatorFeline che rileva un errore <space>.

Provalo

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 anni

Questo può essere fatto con espansioni di parentesi graffe:

eval echo {$1}{$2}

Provalo online .

Brachylog , 5 byte

{∋ᵐ}ᶠ

Provalo online!

Spiegazione

Abbastanza autoesplicativo

{  }ᶠ       Find all:
  ᵐ           Map:
 ∋              In

QBIC , 29 byte

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

Questo stampa stringhe a 2 caratteri con tutte le combinazioni su una riga ciascuna.

Spiegazione

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

*ww

Moltiplicare due stringhe agisce semplicemente come prodotto cartesiano.

Provalo online!

MATL , 2 byte

Z*

*è l'operatore generale per i prodotti e il prefisso lo Zrende il prodotto cartesiano e può assumere due stringhe come argomenti.

Provalo online!

In realtà , 1 byte

∙

Provalo online!

∙ è il comando del prodotto cartesiano.

Ohm , 1 byte

╒

Provalo online!

Letteralmente solo il built-in

J, 3 byte

,@{

Questo è il verbo del catalogo in J. Dobbiamo Ravel ( ,) il risultato per renderlo 1 dimensionale.

Provalo online!

Lisp comune, 63 byte

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

Provalo online!

Clojure, 21 byte

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

PHP , 69 byte

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

Provalo online!

Python 2 , 39 byte

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

Provalo online!

Soluzione alternativa, 34 30 byte

-4 byte grazie ad Anders Kaseorg.

C'è un built-in per questo ...

from itertools import*
product

Cheddar , 52 byte

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

Provalo online!

05AB1E , 10 byte

v²NFÀ}¹ø)˜

Provalo online!

Questo è senza built-in e senza dubbio non sarà competitivo.

Retina , 49 byte

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

Provalo online! Accetta input su righe separate. Spiegazione:

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

Ogni carattere nella prima stringa genera una riga separata preceduta dalla seconda stringa.

¶¶.+
¶

La seconda stringa originale viene eliminata.

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

Per ogni carattere nella prima stringa, ogni carattere nella seconda stringa genera una riga separata con il prefisso del primo carattere.

¶.¶
¶

I caratteri rimasti della prima stringa vengono eliminati.

q / kdb +, 5 byte

Soluzione:

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

Esempio:

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

Carbone , 8 7 byte

ＦθＥη⁺ικ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: Le variabili θe ηimplicitamente si riferiscono alle due stringhe di input. Il Ｆcomando scorre su ogni carattere del primo input, mentre il Ｅcomando esegue il mapping su ciascun carattere del secondo input concatenando la variabile loop ιe la variabile map κ, il cui risultato viene implicitamente stampato su righe separate.

R , 29 byte

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

Provalo online!

Si noti che la matrice R è riempita per colonna, quindi il risultato è nell'ordine dettato dalla specifica.

Se è permesso avere factorsper input e output, c'è un built-in ... ma è necessario estrarre i livelli risultanti dal fattore in modo che alla fine sarebbe più di 29 byte.

R , 11 byte

interaction

Provalo online!

Japt , 5 2 byte

Japt ora ha un metodo per il prodotto cartesiano.

Accetta input come 2 array di stringhe di caratteri.

ïV

Provalo

C # 7, 78 63 byte

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