Aufgabe

Geben Sie bei zwei gegebenen Zeichenlisten ihr kartesisches Produkt aus, dh die Liste der Paare jedes Buchstabens aus der ersten Liste mit jedem Buchstaben aus der zweiten Liste.

Beispiel

"123456"und "abcd"gib:

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

Eingang

Zwei Listen mit Zeichen oder Zeichenfolgen. Die verwendeten Zeichen sind alphanumerisch a-z, A-Z, 0-9und ein Zeichen kann sowohl mehrfach als auch in beiden Eingaben gleichzeitig vorkommen.

Ausgabe

Das kartesische Produkt der Eingabelisten. Das heißt, eine Liste jedes möglichen geordneten Paars eines Zeichens aus der ersten Liste und eines Zeichens aus der zweiten Liste. Jedes Paar ist eine Liste oder Zeichenfolge oder Ähnliches mit zwei Zeichen oder zwei Zeichenfolgen mit der Länge eins. Die Länge der Ausgabe entspricht dem Produkt der Länge der Eingaben.

Die Paare müssen der Reihe nach aufgelistet sein. erstes Auflisten des ersten Zeichens der ersten Liste mit dem ersten der zweiten Liste, gefolgt von allen Paarungen des ersten Zeichens der ersten Liste. Das letzte Paar besteht aus dem letzten Zeichen der ersten Liste und dem letzten Zeichen der zweiten Liste.

Die Ausgabe muss eine flache Liste von Paaren sein. keine 2D-Matrix, in der Paare nach ihrem ersten oder zweiten Element gruppiert sind.

Testfälle

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

â

Probieren Sie es online!

Haskell , 12 Bytes

(<*>).map(,)

Probieren Sie es online!

Mathematica, 12 Bytes

Tuples@{##}&

Nimmt zwei Listen von Zeichen als Eingabe.

APL (Dyalog) , 4 Bytes

,∘.,

Probieren Sie es online!

, ebnen

∘. der kartesische

, Verkettung

Ruby , 30 18 Bytes

-12 Bytes aus Jordanien, die mich daran erinnern, wie ich die Spezifikation zu meinem Vorteil nutzen kann!

Nimmt Listen von Zeichen als Eingabe.

->a,b{a.product b}

Probieren Sie es online!

Gelee , 1 Byte

p

Probieren Sie es online!

Oktave, 32 Bytes

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

Probieren Sie es online!

Tcl , 60 Bytes

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

Verwenden:

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

Perl 6 , 4 Bytes

&[X]

Dies ist nur ein Hinweis auf den integrierten produktübergreifenden Operator X. Es funktioniert auf Listen jeder Art, nicht nur auf Zeichen.

JavaScript (ES6), 45 36 34 33 Byte

Benötigt Firefox. Nimmt beide Eingaben als Zeichenfolgen oder als Arrays einzelner Zeichen.

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

• -1 Byte dank CalculatorFeline, die einen Fehler entdeckt <space>.

Versuch es

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

Dies kann mit Klammererweiterungen erfolgen:

eval echo {$1}{$2}

Probieren Sie es online aus .

Brachylog , 5 Bytes

{∋ᵐ}ᶠ

Probieren Sie es online!

Erläuterung

Ziemlich selbsterklärend

{  }ᶠ       Find all:
  ᵐ           Map:
 ∋              In

QBIC , 29 Bytes

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

Dies druckt 2-Zeichen-Zeichenfolgen mit allen Kombinationen in jeweils einer Zeile.

Erläuterung

   ;      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

Das Multiplizieren von zwei Zeichenketten wirkt nur als kartesisches Produkt.

Online testen!

MATL , 2 Bytes

Z*

*ist der allgemeine Operator für Produkte und das Präfix Zmacht es zum kartesischen Produkt und kann zwei Zeichenfolgen als Argumente verwenden.

Probieren Sie es online!

Eigentlich 1 Byte

∙

Probieren Sie es online!

∙ ist der kartesische Produktbefehl.

Ohm , 1 Byte

╒

Probieren Sie es online!

Wörtlich nur das eingebaute

J, 3 Bytes

,@{

Dies ist das Katalogverb in J. Wir müssen Ravel (, das Ergebnis ), um es eindimensional zu machen.

Probieren Sie es online!

Common Lisp, 63 Bytes

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

Probieren Sie es 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);

Probieren Sie es online!

Python 2 , 39 Bytes

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

Probieren Sie es online!

Alternative Lösung, 34 30 Bytes

-4 Bytes dank Anders Kaseorg.

Es ist ein eingebautes für diese ...

from itertools import*
product

Cheddar , 52 Bytes

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

Probieren Sie es online!

05AB1E , 10 Bytes

v²NFÀ}¹ø)˜

Probieren Sie es online!

Dies ist ohne die eingebaute und wird zweifellos nicht wettbewerbsfähig sein.

Netzhaut , 49 Bytes

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

Probieren Sie es online! Nimmt Eingaben in separaten Zeilen vor. Erläuterung:

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

Jedes Zeichen in der ersten Zeichenfolge generiert eine separate Zeile, der die zweite Zeichenfolge vorangestellt wird.

¶¶.+
¶

Die ursprüngliche zweite Zeichenfolge wird gelöscht.

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

Für jedes Zeichen in der ersten Zeichenfolge generiert jedes Zeichen in der zweiten Zeichenfolge eine separate Zeile, der das erste Zeichen vorangestellt ist.

¶.¶
¶

Die verbleibenden Zeichen aus der ersten Zeichenfolge werden gelöscht.

q / kdb + 5 Bytes

Lösung:

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

Beispiel:

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

Kohle , 8 7 Bytes

ＦθＥη⁺ικ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung: Die Variablen θund ηbeziehen sich implizit auf die beiden Eingabezeichenfolgen. Der ＦBefehl durchläuft jedes Zeichen der ersten Eingabe, während der ＥBefehl jedes Zeichen der zweiten Eingabe durchläuft, wobei die Schleifenvariable ιund die Zuordnungsvariable verkettet werden κ, deren Ergebnis implizit in separaten Zeilen gedruckt wird.

R 29 Bytes

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

Probieren Sie es online!

Beachten Sie, dass die R-Matrix spaltenweise gefüllt ist, sodass das Ergebnis in der von der Spezifikation vorgegebenen Reihenfolge angezeigt wird.

Wenn erlaubt zu haben factors für Ein- und Ausgabe zu haben, gibt es einen eingebauten ... aber man muss die resultierenden Pegel aus dem Faktor extrahieren, so dass es am Ende mehr als 29 Bytes wären.

R , 11 Bytes

interaction

Probieren Sie es online!

Japt , 5 2 Bytes

Japt hat jetzt eine Methode für das kartesische Produkt.

Nimmt die Eingabe als 2 Arrays von Zeichenketten auf.

ïV

Versuch es

C # 7, 78 63 Bytes

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