Một bộ domino tiêu chuẩn có 28 mảnh độc đáo:

Đưa ra một danh sách gồm 28 hoặc ít hơn các domino duy nhất, xuất ra danh sách cần thiết để tạo thành một bộ hoàn chỉnh.

Đầu vào và đầu ra domino được quy định bởi hai chữ số - số pip trên mỗi bên của domino, ví dụ như 00, 34, 40, 66.

Các chữ số có thể được đưa ra theo bất kỳ thứ tự nào, 34cũng giống như domino như43

Ví dụ đầu vào

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>

Đầu ra ví dụ tương ứng

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

{:$7Ym*:$^}

Một khối không tên (hàm) với I / O là danh sách các cặp số nguyên.

Kiểm tra nó ở đây.

Giải trình

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

Bình thường, 12 10 byte

-.CU7 2SMQ

Đầu vào và đầu ra ở định dạng [[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

Hãy thử nó ở đây.

Cảm ơn @ MartinBüttner vì đã lưu 2 byte với định dạng đầu vào / đầu ra khác nhau!

JavaScript (đề xuất ES7), 80 76 byte

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

Lấy đầu vào dưới dạng một chuỗi được phân tách bằng dấu cách và trả về một chuỗi các chuỗi. Hiểu mảng thực sự kéo trọng lượng của họ cho cái này.

Ruby 74 byte

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

Lấy một chuỗi các chuỗi, trả về một chuỗi các chuỗi.

Nhận xét trong chương trình thử nghiệm

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

Đầu ra

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

Trong ví dụ cuối cùng (danh sách trống đầu vào) lưu ý thứ tự tạo ra danh sách domino hoàn chỉnh sử dụng số học mô-đun. 7 nhân đôi được tạo trước, sau đó 7 domino với chênh lệch 1 (hoặc 6) pips giữa mỗi bên, sau đó 7 domino với chênh lệch 2 (hoặc 5) pips và cuối cùng là 7 domino với chênh lệch 3 (hoặc 4) pips.

Julia 0,6 , 47 byte

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

Hãy thử trực tuyến!

(Phạm vi bắt đầu chính xác nhờ JayCe.)

48 byte

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

Hãy thử trực tuyến!

Perl, 48 + 1 = 49 byte

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

Yêu cầu -ncờ và miễn phí -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

Câu trả lời khá nhàm chán về tổng thể, nhưng ở đây đi với một phiên bản không có căn cứ:

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

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

Hãy thử trực tuyến!

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]

Hãy thử trực tuyến!

được tối ưu hóa từ Neil

R , 111 byte

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

Hãy thử trực tuyến!

Không thực sự tự hào về điều này, nhưng R không "chơi gôn" lắm trong việc tách / nối dây ...

05AB1E , 12 11 byte

6Ýã€{JI€{KÙ

-1 byte nhờ @Emigna .

Hãy thử trực tuyến.

Giải trình:

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

Toán học, 49 byte

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

Đầu vào là danh sách các số nguyên.

Java 8, 105 byte

Một lambda void chấp nhận một đột biến 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);}

Dùng thử trực tuyến

Bị đánh cắp

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

Lời cảm ơn

• -1 byte nhờ Jonathan Frech

Thạch , 8 byte

Ṣ€7ḶŒċ¤ḟ

Hãy thử trực tuyến!

Đối số là một danh sách dài 2 danh sách các số nguyên. Chân trang biến đổi đầu vào từ định dạng trong các trường hợp thử nghiệm sang định dạng mà giải pháp này chấp nhận.

J, 26 , 24 byte

-2 byte nhờ FrownyFrog

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

• (;(,.i.,])&.>i.7) tính toán toàn bộ (phần này có thể được đánh gôn hơn nữa, tôi tin. Và làm ơn nếu bạn thấy ...)
• -. là "thiết lập trừ"
• /:~"1 đặt hàng từng đầu vào

Hãy thử trực tuyến!

Nguyên

Hãy thử trực tuyến!

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

Con trăn 2 89 86 byte

Đã lưu một vài byte bằng cách đơn giản hóa việc tạo tập 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}

Hãy thử trực tuyến!

Lấy một danh sách các chuỗi như ["00", "10", "02] làm đối số cho domino. Trả về các đối tượng tập python, là các danh sách riêng biệt không có thứ tự.

Giải trình

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

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

Ví dụ sử dụng:

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

Lặp atrong một vòng lặp bên ngoài khắp chữ số từ 0đến 6và btrong một vòng lặp bên trong khắp chữ số từ ađể 6và giữ những abnơi không phải abvà cũng không bađược tìm thấy trong chuỗi đầu vào.

Nghiêm túc, 16 byte

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

Lấy đầu vào dưới dạng danh sách các chuỗi, xuất ra danh sách các chuỗi

Hãy thử trực tuyến!

Giải trình:

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

Trên thực tế , 13 byte (không cạnh tranh)

♂S7r;∙`εjS`M-

Điều này giống hệt với câu trả lời Nghiêm túc (ngoại trừ đầu vào ẩn và ♂Slà một cách ngắn hơn để rút ngắn mỗi chuỗi đầu vào).

Hãy thử trực tuyến!

vợt

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