Un juego de dominó estándar tiene 28 piezas únicas:

Dada una lista de 28 o menos fichas de dominó únicas, envíe la lista requerida para hacer un conjunto completo.

Dominó de entrada y salida son especificados por dos dígitos - el número de pips en cada lado de la dominó, por ejemplo 00, 34, 40, 66.

Los dígitos se pueden dar en cualquier orden, por lo que 34es el mismo dominó que43

Entradas de ejemplo

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>

Salidas de ejemplo correspondientes

<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*:$^}

Un bloque (función) sin nombre con E / S como una lista de pares de enteros.

Pruébalo aquí.

Explicación

:$   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

Entrada y salida en formato [[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

Pruébalo aquí

¡Gracias a @ MartinBüttner por guardar 2 bytes con un formato de entrada / salida diferente!

JavaScript (propuesto por ES7), 80 76 bytes

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

Toma la entrada como una cadena separada por espacios y devuelve una matriz de cadenas. Las comprensiones de matriz realmente pesan para este.

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}

Toma una matriz de cadenas, devuelve una matriz de cadenas.

Comentó en el programa de prueba

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

Salida

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

En el último ejemplo (ingrese la lista vacía) observe el orden de generación de la lista completa de fichas de dominó usando aritmética modular. Primero se generan 7 dobles, luego 7 fichas de dominó con una diferencia de 1 (o 6) pips entre cada lado, luego 7 fichas de dominó con una diferencia de 2 (o 5) fichas, y finalmente 7 fichas de dominó con una diferencia de 3 (o 4) pepitas

Julia 0.6 , 47 bytes

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

Pruébalo en línea!

(Inicio de rango corregido gracias a JayCe.)

48 bytes

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

Pruébalo en línea!

Perl, 48 + 1 = 49 bytes

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

Requiere la -nbandera, y la libre -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

Respuesta bastante aburrida en general, pero aquí va con una versión sin golf:

# '-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],[])

Pruébalo en línea!

JavaScript (SpiderMonkey) , 69 bytes

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

Pruébalo en línea!

optimizado de 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=''))

Pruébalo en línea!

No estoy realmente orgulloso de esto, pero R no es muy "golfista" al dividir / concatenar cuerdas ...

05AB1E , 12 11 bytes

6Ýã€{JI€{KÙ

-1 byte gracias a @Emigna .

Pruébalo en línea.

Explicación:

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}],#]&

La entrada es una lista de la lista de enteros.

Java 8, 105 bytes

Un lambda vacío que acepta un mutable 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);}

Pruébalo en línea

Sin golf

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

Expresiones de gratitud

• -1 byte gracias a Jonathan Frech

Jalea , 8 bytes

Ṣ€7ḶŒċ¤ḟ

Pruébalo en línea!

El argumento es una lista de listas de enteros de longitud 2. El pie de página transforma la entrada del formato en los casos de prueba al formato que acepta esta solución.

J, 26 , 24 bytes

-2 bytes gracias a FrownyFrog

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

• (;(,.i.,])&.>i.7) calcula el conjunto completo (creo que esta parte podría jugarse más, creo. Y por favor hazlo si ves cómo ...)
• -. es "set minus"
• /:~"1 ordena cada una de las entradas

Pruébalo en línea!

Original

Pruébalo en línea!

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

Python 2, 89 86 bytes

Ahorró algunos bytes al simplificar la generación de conjuntos de dominó.

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}

Pruébalo en línea!

Toma una lista de cadenas como ["00", "10", "02] como argumento para las fichas de dominó. Devuelve los objetos del conjunto de Python, que son listas distintas sin ordenar.

Explicación

# 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]

Ejemplo de uso:

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

Iterar aen un bucle exterior sobre todos los dígitos de 0a 6y ben un bucle interior sobre todos los dígitos de aa 6y guardan las abque ni abni base encuentran en la cadena de entrada.

En serio, 16 bytes

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

Toma la entrada como una lista de cadenas, genera una lista de cadenas

Pruébalo en línea!

Explicación:

,`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)

En realidad , 13 bytes (no competitivos)

♂S7r;∙`εjS`M-

Esto es idéntico a la respuesta en serio (con la excepción de la entrada implícita y ♂Ses una forma más corta de acortar cada cadena de entrada).

Pruébalo en línea!

raqueta

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