Un ensemble domino standard comprend 28 pièces uniques:

Avec une liste de 28 dominos uniques ou moins, indiquez la liste requise pour créer un jeu complet.

Dominos d'entrée et de sortie sont spécifiés par deux chiffres - le nombre de pépins de chaque côté du domino, par exemple 00, 34, 40, 66.

Les chiffres peuvent être donnés dans n’importe quel ordre. 34Le même domino que43

Exemple d'entrées

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>

Exemples de sorties correspondants

<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 octets

{:$7Ym*:$^}

Un bloc non nommé (fonction) avec I / O sous forme de liste de paires d'entiers.

Testez-le ici.

Explication

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

-.CU7 2SMQ

Entrée et sortie au 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

Essayez ici.

Merci à @ MartinBüttner pour la sauvegarde de 2 octets avec un format d’entrée / sortie différent!

JavaScript (ES7 proposé), 80 76 octets

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

Prend l'entrée en tant que chaîne séparée par des espaces et renvoie un tableau de chaînes. Les compréhensions de tableaux tirent vraiment leur poids pour celui-ci.

Ruby 74 octets

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

Prend un tableau de chaînes, retourne un tableau de chaînes.

Commenté dans le programme de test

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

Sortie

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

Dans le dernier exemple (liste vide d'entrée), notez l'ordre de génération de la liste complète des dominos à l'aide de l'arithmétique modulaire. 7 doubles sont générés en premier, puis 7 dominos avec une différence de 1 (ou 6) pips entre chaque côté, puis 7 dominos avec une différence de 2 (ou 5) pips, et enfin 7 dominos avec une différence de 3 (ou 4) pépins.

Julia 0.6 , 47 bytes

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

Essayez-le en ligne!

(Début de la plage corrigée grâce à JayCe.)

48 octets

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

Essayez-le en ligne!

Perl, 48 + 1 = 49 octets

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

Nécessite le -ndrapeau et le gratuit -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

Réponse plutôt ennuyeuse dans l'ensemble, mais voici une version non-golfée:

# '-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 octets

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

Essayez-le en ligne!

JavaScript (SpiderMonkey) , 69 octets

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

Essayez-le en ligne!

optimisé par Neil

R , 111 octets

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

Essayez-le en ligne!

Pas vraiment fier de ça, mais R n’est pas très "golfy" dans la division / concaténation de chaînes ...

05AB1E , 12 à 11 octets

6Ýã€{JI€{KÙ

-1 octet grâce à @Emigna .

Essayez-le en ligne.

Explication:

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 octets

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

L'entrée est la liste de la liste des entiers.

Java 8, 105 octets

Un vide lambda acceptant 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);}

Essayez-le en ligne

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

Remerciements

• -1 octet grâce à Jonathan Frech

Gelée , 8 octets

Ṣ€7ḶŒċ¤ḟ

Essayez-le en ligne!

L'argument est une liste de listes d'entiers de longueur 2. Le pied de page transforme l'entrée du format dans les scénarios de test au format accepté par cette solution.

J, 26 , 24 octets

-2 octets grâce à FrownyFrog

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

• (;(,.i.,])&.>i.7) calcule l'ensemble complet (cette partie pourrait être complétée, je crois. Et s'il vous plaît faites-le si vous voyez comment ...)
• -. est "réglé moins"
• /:~"1 ordonne chacune des entrées

Essayez-le en ligne!

Original

Essayez-le en ligne!

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

Python 2, 89 86 octets

Sauvegardé quelques octets en simplifiant la génération de jeux de dominos.

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}

Essayez-le en ligne!

Prend une liste de chaînes comme ["00", "10", "02] en tant qu'argument pour les dominos. Renvoie des objets de jeu python, qui sont des listes distinctes non ordonnées.

Explication

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

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

Exemple d'utilisation:

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

Itérer adans une boucle extérieure sur tous les chiffres de 0la 6et bdans une boucle intérieure sur tous les chiffres de ala 6et de garder ceux aboù ni abne base trouvent dans la chaîne d'entrée.

Sérieusement, 16 octets

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

Prend les entrées sous forme de liste de chaînes, génère une liste de chaînes

Essayez-le en ligne!

Explication:

,`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 fait , 13 octets (non concurrents)

♂S7r;∙`εjS`M-

Ceci est identique à la réponse Sérieusement (à l'exception de l'entrée implicite et ♂Sétant un moyen plus court de raccourcir chaque chaîne d'entrée).

Essayez-le en ligne!

raquette

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