Um conjunto de dominó padrão possui 28 peças únicas:

Dada uma lista de 28 ou menos dominós exclusivos, produza a lista necessária para fazer um conjunto completo.

Dominó de entrada e de saída são especificados por dois dígitos - o número de sementes de cada lado do dominó, por exemplo 00, 34, 40, 66.

Os dígitos podem ser fornecidos em qualquer ordem, assim 34como o mesmo dominó que43

Exemplo de entradas

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>

Saídas de exemplo correspondentes

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

Um bloco (função) sem nome com E / S como uma lista de pares de números inteiros.

Teste aqui.

Explicação

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

Pitão, 12 10 bytes

-.CU7 2SMQ

Entrada e saída em 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

Experimente aqui.

Agradecemos a @ MartinBüttner por salvar 2 bytes com um formato de entrada / saída diferente!

JavaScript (ES7 proposto), 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]

Recebe a entrada como uma sequência separada por espaço e retorna uma matriz de sequências. As compreensões de matriz realmente contribuem 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}

Pega uma matriz de strings, retorna uma matriz de strings.

Comentado no programa de teste

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

Saída

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

No último exemplo (lista vazia de entrada), observe a ordem de geração da lista completa de dominós usando aritmética modular. 7 duplos são gerados primeiro, depois 7 dominós com uma diferença de 1 (ou 6) pips entre cada lado, depois 7 dominós com uma diferença de 2 (ou 5) pips e, finalmente, 7 dominós com uma diferença de 3 (ou 4) pips.

Julia 0.6 , 47 bytes

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

Experimente online!

(Início do intervalo corrigido graças a JayCe.)

48 bytes

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

Experimente online!

Perl, 48 + 1 = 49 bytes

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

Requer a -nbandeira e o livre -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

Resposta bastante chata no geral, mas aqui vai uma versão não destruída:

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

Experimente online!

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]

Experimente online!

otimizado a partir de Neil

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

Experimente online!

Não tem muito orgulho disso, mas R não é muito "empolgado" em dividir / concatenar cordas ...

05AB1E , 12 11 bytes

6Ýã€{JI€{KÙ

-1 byte graças a @Emigna .

Experimente online.

Explicação:

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

Entrada é uma lista da lista de números inteiros.

Java 8, 105 bytes

Um lambda vazio aceitando um mutável 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);}

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

Agradecimentos

• -1 byte graças a Jonathan Frech

Geléia , 8 bytes

Ṣ€7ḶŒċ¤ḟ

Experimente online!

Argumento é uma lista de 2 listas de números inteiros. O rodapé transforma a entrada do formato nos casos de teste para o formato que esta solução aceita.

J, 26 , 24 bytes

-2 bytes graças ao FrownyFrog

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

• (;(,.i.,])&.>i.7) calcula o conjunto completo (essa parte poderia ser ainda mais jogada, eu acredito. E, por favor, veja se ...)
• -. é "definido menos"
• /:~"1 solicita cada uma das entradas

Experimente online!

Original

Experimente online!

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

Python 2, 89 86 bytes

Economizou alguns bytes simplificando a geração de conjuntos de dominós.

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}

Experimente online!

Pega uma lista de cadeias de caracteres como ["00", "10", "02] como argumento para os dominós. Retorna objetos de conjunto python, que são listas distintas não ordenadas.

Explicação

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

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

Itere aem um loop externo sobre todos os dígitos de 0para 6e bem um loop interno sobre todos os dígitos de apara 6e mantenha aqueles abonde nem abnem basão encontrados na sequência de entrada.

Sério, 16 bytes

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

Recebe entrada como uma lista de strings, gera uma lista de strings

Experimente online!

Explicação:

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

Na verdade , 13 bytes (não concorrentes)

♂S7r;∙`εjS`M-

Isso é idêntico à resposta Sério (com exceção da entrada implícita e ♂S é uma maneira mais curta de encurtar cada sequência de entrada).

Experimente online!

raquete

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