Ein Standard-Domino-Set besteht aus 28 Einzelstücken:

Geben Sie bei einer Liste von 28 oder weniger eindeutigen Dominosteinen die Liste aus, die für die Erstellung eines vollständigen Satzes erforderlich ist.

Eingangs- und Ausgangsdomino werden durch zwei Ziffern angegeben - die Anzahl der Zacken auf jeder Seite des Domino, zB 00, 34, 40, 66.

Die Ziffern können in beliebiger Reihenfolge angegeben werden, es handelt sich also 34um das gleiche Domino wie43

Beispieleingaben

00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 33 34 35 36 44 45 46 55 56 66
00 10 11 20 21 22 30 31 32 33 40 41 42 43 44 50 51 52 53 54 55 60 61 62 63 64 65 66
00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 34 35 36 44 45 46 55 56 66
00 02 03 04 05 06 11 13 14 15 16 22 24 25 26 33 35 36 44 46 55 66
<empty list>

Entsprechende Beispielausgaben

<empty list>
<empty list>
33
01 12 23 34 45 56
00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 33 34 35 36 44 45 46 55 56 66

CJam, 11 Bytes

{:$7Ym*:$^}

Ein unbenannter Block (Funktion) mit E / A als Liste von Ganzzahlpaaren.

Teste es hier.

Erläuterung

:$   e# Sort each pair in the input.
7Ym* e# Get all pairs with elements in range [0 .. 6] using a Cartesian product.
:$   e# Sort each pair.
^    e# Symmetric set-difference. This will remove all pairs that are in the input
     e# and also remove duplicates, because it's a set operation.

Pyth, 12 10 Bytes

-.CU7 2SMQ

Ein- und Ausgabe im Format [[0, 0], [0, 1], ...].

   U7       generate range [0, 1, ..., 6]
 .C   2     all combinations-with-replacement of 2, generates [[0,0],[0,1],...]
         Q  get the input
       SM   sort each domino (turns ex. [1,0] into [0,1])
-           remove the map-sort'd input from the full array

Probieren Sie es hier aus.

Vielen Dank an @ MartinBüttner für das Speichern von 2 Bytes mit einem anderen Eingabe- / Ausgabeformat!

JavaScript (ES7 vorgeschlagen), 80 bis 76 Byte

s=>[for(n of d="0123456")for(o of d.slice(n))if(s.search(n+o+'|'+o+n)<0)n+o]

Nimmt Eingaben als durch Leerzeichen getrennte Zeichenfolge und gibt ein Array von Zeichenfolgen zurück. Das Array-Verständnis spielt für dieses wirklich eine große Rolle.

Ruby 74 Bytes

->b{a=(0..27).map{|i|"%d%d"%[i%7,(i+i/7)%7]}
b.map{|e|a-=[e,e.reverse]}
a}

Nimmt ein Array von Zeichenfolgen und gibt ein Array von Zeichenfolgen zurück.

Kommentiert im Testprogramm

f=->b{a=(0..27).map{|i|"%d%d"%[i%7,(i+i/7)%7]} #generate complete set of dominos (each domino once) and store in a
b.map{|e|a-=[e,e.reverse]}                     #remove provided dominos (check both forward and reverse representations)
a}                                             #return a

p f[%w{00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 33 34 35 36 44 45 46 55 56 66}]
p f[%w{00 10 11 20 21 22 30 31 32 33 40 41 42 43 44 50 51 52 53 54 55 60 61 62 63 64 65 66}]
p f[%w{00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 34 35 36 44 45 46 55 56 66}]
p f[%w{00 02 03 04 05 06 11 13 14 15 16 22 24 25 26 33 35 36 44 46 55 66}]
p f[[]]

Ausgabe

[]
[]
["33"]
["01", "12", "23", "34", "45", "56"]
["00", "11", "22", "33", "44", "55", "66", "01", "12", "23", "34", "45", "56", "60", "02", "13", "24", "35", "46", "50", "61", "03", "14", "25","36", "40", "51", "62"]

Beachten Sie im letzten Beispiel (leere Liste eingeben) die Reihenfolge der Generierung der vollständigen Dominoliste mit modularer Arithmetik. Es werden zuerst 7 Doppel generiert, dann 7 Dominosteine ​​mit einem Unterschied von 1 (oder 6) Pips zwischen jeder Seite, dann 7 Dominosteine ​​mit einem Unterschied von 2 (oder 5) Pips und schließlich 7 Dominosteine ​​mit einem Unterschied von 3 (oder 4). pips.

Julia 0,6 , 47 Bytes

A->setdiff([[i,j]for i=0:6 for j=i:6],sort.(A))

Probieren Sie es online!

(Der Start der Reichweite wurde dank JayCe korrigiert.)

48 Bytes

A->[(i,j)for i=0:6 for j=i:6 if[i,j]∉sort.(A)]

Probieren Sie es online!

Perl, 48 + 1 = 49 Bytes

for$=(0..6){for$.($=..6){/$=$.|$.$=/||say$=.$.}}

Benötigt die -nFlagge und die freie -M5.010| -E:

$ perl -nE'for$=(0..6){for$.($=..6){/$=$.|$.$=/||say$=.$.}}' <<< '00 02 03 04 05 06 11 13 14 15 16 22 24 25 26 33 35 36 44 46 55 66'                      
01
12
23
34
45
56

Ziemlich langweilige Antwort insgesamt, aber hier geht es mit einer ungolfed Version:

# '-n' auto reads first line into `$_`:
# $_ = <>;
foreach $a (0..6) {
  foreach $b ($a..6) {
    say $a . $b unless $_ =~ /$a$b|$b$a/;
  }
}

Python 2 , 91 Bytes

lambda A,S="0123456":sum([[i+j for j in S[int(i):]if(i+j in A)+(j+i in A)<1]for i in S],[])

Probieren Sie es online!

JavaScript (SpiderMonkey) , 69 Byte

s=>[for(n of d="0123456")for(o of d)if(n<o<!s.match(n+o+'|'+o+n))n+o]

Probieren Sie es online!

optimiert von Neil's

R , 111 Bytes

function(s,p=paste0,L=lapply)setdiff(p(sequence(1:7)-1,rep(0:6,t=1:7)),L(L(strsplit(s,''),sort),p,collapse=''))

Probieren Sie es online!

Nicht wirklich stolz darauf, aber R ist nicht sehr "golfen" beim Teilen / Verketten von Saiten ...

05AB1E , 12 11 Bytes

6Ýã€{JI€{KÙ

-1 Byte dank @Emigna .

Probieren Sie es online aus.

Erläuterung:

6Ý         # [0,1,2,3,4,5,6]
  ã        # Duplicate and take the cartesian product (pair up each)
   €{      # Sort each pair
     J     # Join them together to strings
I€{        # Sort each pair-string of the input
K          # Remove all pairs from the input from the cartesian list
Ù          # Only leave unique values

Mathematica, 49 Bytes

Complement[Join@@Table[{x,y},{x,0,6},{y,0,6}],#]&

Die Eingabe ist eine Liste mit ganzen Zahlen.

Java 8, 105 Bytes

Ein leeres Lambda, das einen veränderlichen annimmt java.util.Set<String>.

s->{for(int i=0,a,b;i<49;)if(s.add(""+(a=i/7)+(b=i++%7))&(s.add(""+b+a)|a==b))System.out.print(" "+a+b);}

Probieren Sie es online

Ungolfed

s -> {
    for (int i = 0, a, b; i < 49;)
        if (
            s.add("" + (a = i / 7) + (b = i++ % 7))
            & (
                s.add("" + b + a)
                | a == b
            )
        )
            System.out.print(" " + a + b);
}

Danksagung

• -1 Byte Danke an Jonathan Frech

Gelee , 8 Bytes

Ṣ€7ḶŒċ¤ḟ

Probieren Sie es online!

Argument ist eine Liste von Länge-2-Listen von ganzen Zahlen. Die Fußzeile transformiert die Eingabe aus dem Format in den Testfällen in das von dieser Lösung akzeptierte Format.

J, 26 , 24 Bytes

-2 Bytes dank FrownyFrog

(;(,.i.,])&.>i.7)-.\:~"1

• (;(,.i.,])&.>i.7) berechnet den vollen Satz (dieser Teil könnte, glaube ich, weiter golfen werden. Und bitte tun Sie, wenn Sie sehen, wie ...)
• -. ist "set minus"
• /:~"1 bestellt jeden der Eingänge

Probieren Sie es online!

Original

Probieren Sie es online!

((#~<:/"1)>,{;~i.7)-./:~"1

Python 2, 89 86 Bytes

Ein paar Bytes gespart, indem die Generierung von Domino-Sets vereinfacht wurde.

lambda z,s="0123456":{x+y for x in s for y in s[int(x):]}-{(a+b,b+a)[a>b]for a,b in z}

Probieren Sie es online!

Verwendet eine Liste von Zeichenfolgen wie ["00", "10", "02] als Argument für die Dominosteine. Gibt Python-Set-Objekte zurück, bei denen es sich um ungeordnete unterschiedliche Listen handelt.

Erläuterung

# anonymous function, s should always have its default value
lambda z,s="0123456":
                     # contents are a set
                     {                                  }
                          # iterate over characters in string
                          for x in s
                                     # for each x, iterate over x from index of current item forward
                                     for y in s[int(x):]
                     # add characters together for domino string
                     x+y
                                                         # contents are a set, return the difference between these two sets 
                                                         -{                          }
                                                             # iterate over items in input list, split strings into two characters
                                                                         for a,b in z
                                                             # sort strings in input list (so that i.e. "10" => "01")
                                                             # essentially, "ab" if a<b, otherwise "ba"
                                                             (a+b,b+a)[a>b]

Haskell, 65 Bytes

f x=[[a,b]|a<-"0123456",b<-[a..'6'],notElem[a,b]x&&notElem[b,a]x]

Anwendungsbeispiel:

*Main> f ["00","02","03","04","05","06","11","13","14","15","16","22","24","25","26","33","35","36","44","46","55","66"]
["01","12","23","34","45","56"]

Iterieren Sie ain einer äußeren Schleife über alle Ziffern von 0bis 6und bin einer inneren Schleife über alle Ziffern von abis 6und behalten Sie diejenigen abbei, die weder in der Eingabezeichenfolge abnoch bain der Eingabezeichenfolge enthalten sind.

Im Ernst, 16 Bytes

,`S`M7r;∙`εjS`M-

Übernimmt die Eingabe als Liste von Zeichenfolgen und gibt eine Liste von Zeichenfolgen aus

Probieren Sie es online!

Erläuterung:

,`S`M7r;∙`εjS`M-
,`S`M             map: sort each input string
     7r;∙         cartesian product of range(0,7) ([0,1,2,3,4,5,6]) with itself
         `εjS`M   map: join on empty string, sort (results in all valid dominoes with some duplicates)
               -  set difference (all values present in valid dominoes set not present in input, with duplicates removed)

Eigentlich 13 Bytes (nicht konkurrierend)

♂S7r;∙`εjS`M-

Dies ist identisch mit der Antwort "Ernsthaft" (mit Ausnahme der impliziten Eingabe und ♂Seiner kürzeren Methode zum Kurzschließen der einzelnen Eingabezeichenfolgen).

Probieren Sie es online!

Schläger

(define (missing-dominoes input)
  (filter
   (lambda (n)
     (not (member n (map
                     (lambda (n)
                       (let ((x (quotient n 10)) (y (remainder n 10)))
                         (if (<= x y) n (+ (* y 10) x))))
                     input))))
   (for*/list ([i (in-range 7)] [j (in-range i 7)])
     (+ (* 10 i) j))))