Standardowy zestaw domino posiada 28 niepowtarzalnych kawałków:

Biorąc pod uwagę listę 28 lub mniej unikalnych domino, wypisz listę wymaganą do utworzenia pełnego zestawu.

Domino wejściowe i wyjściowe są określone przez dwie cyfry - liczba oczek na każdej stronie, np domina 00, 34, 40, 66.

Cyfry mogą być podawane w dowolnej kolejności, 34podobnie jak domino43

Przykładowe dane wejściowe

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>

Odpowiadające przykładowe wyniki

<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 bajtów

{:$7Ym*:$^}

Nienazwany blok (funkcja) z I / O jako listą liczb całkowitych.

Sprawdź to tutaj.

Wyjaśnienie

:$   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 bajtów

-.CU7 2SMQ

Dane wejściowe i wyjściowe w formacie [[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

Wypróbuj tutaj.

Dzięki @ MartinBüttner za zapisanie 2 bajtów w innym formacie wejścia / wyjścia!

JavaScript (proponowany ES7), 80 76 bajtów

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

Pobiera dane wejściowe jako ciąg oddzielony spacją i zwraca tablicę ciągów. Zrozumienia tablic naprawdę przyciągają na siebie uwagę.

Ruby 74 bajty

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

Bierze tablicę ciągów, zwraca tablicę ciągów.

Skomentowane w programie testowym

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

Wydajność

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

W ostatnim przykładzie (wprowadź pustą listę) zwróć uwagę na kolejność generowania pełnej listy domino przy użyciu arytmetyki modułowej. Najpierw generowanych jest 7 podwójnych, następnie 7 domino z różnicą 1 (lub 6) pipsów między każdą stroną, następnie 7 domino z różnicą 2 (lub 5) pipsów, a na koniec 7 domino z różnicą 3 (lub 4) pestki.

Julia 0.6 , 47 bajtów

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

Wypróbuj online!

(Skorygowany start zakresu dzięki JayCe.)

48 bajtów

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

Wypróbuj online!

Perl, 48 + 1 = 49 bajtów

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

Wymaga -nflagi i darmowego -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

Ogólnie dość nudna odpowiedź, ale tutaj jest wersja bez golfa:

# '-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 bajtów

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

Wypróbuj online!

JavaScript (SpiderMonkey) , 69 bajtów

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

Wypróbuj online!

zoptymalizowany od Neila

R , 111 bajtów

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

Wypróbuj online!

Nie jestem z tego naprawdę dumny, ale R nie jest zbyt „golfowy” w dzieleniu / łączeniu łańcuchów ...

05AB1E , 12 11 bajtów

6Ýã€{JI€{KÙ

-1 bajt dzięki @Emigna .

Wypróbuj online.

Wyjaśnienie:

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 bajtów

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

Dane wejściowe to lista liczb całkowitych.

Java 8, 105 bajtów

Pusta lambda akceptuje 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);}

Wypróbuj online

Bez golfa

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

Podziękowanie

• -1 bajt dzięki Jonathan Frech

Galaretka , 8 bajtów

Ṣ€7ḶŒċ¤ḟ

Wypróbuj online!

Argument jest listą liczb całkowitych o długości 2. Stopka przekształca dane wejściowe z formatu w przypadkach testowych na format akceptowany przez to rozwiązanie.

J, 26 , 24 bajtów

-2 bajty dzięki FrownyFrog

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

• (;(,.i.,])&.>i.7) oblicza pełny zestaw (uważam, że ta część może być dalej golfa. I proszę, jeśli zobaczycie, jak ...)
• -. to „set minus”
• /:~"1 zamawia każde z wejść

Wypróbuj online!

Oryginalny

Wypróbuj online!

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

Python 2, 89 86 bajtów

Zaoszczędzono kilka bajtów, upraszczając generowanie zestawu domino.

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}

Wypróbuj online!

Bierze listę ciągów takich jak [„00”, „10”, „02] jako argument dla domino Zwraca obiekty zestawu python, które są nieuporządkowanymi odrębnymi listami.

Wyjaśnienie

# 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 bajtów

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

Przykład użycia:

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

Iteruj aw zewnętrznej pętli nad wszystkimi cyframi od 0do 6oraz bw wewnętrznej pętli nad wszystkimi cyframi od ado 6i przechowuj te, w abktórych ani abnie baznajdują się w ciągu wejściowym.

Poważnie, 16 bajtów

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

Pobiera dane wejściowe jako listę ciągów, wyświetla listę ciągów

Wypróbuj online!

Wyjaśnienie:

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

Właściwie 13 bajtów (niekonkurujących)

♂S7r;∙`εjS`M-

Jest to identyczne z odpowiedzią Poważnie (z wyjątkiem niejawnych danych wejściowych i ♂S krótszym sposobem na zwieranie każdego ciągu wejściowego).

Wypróbuj online!

rakieta

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