ชุดโดมิโนมาตรฐานมี 28 ชิ้นไม่ซ้ำกัน:

รับรายการของแต้มโดมิโนที่ไม่ซ้ำกัน 28 ตัวหรือน้อยกว่าเอาท์พุทรายการที่จำเป็นเพื่อสร้างชุดสมบูรณ์

input และ output แต้มที่ระบุไว้โดยตัวเลขสองหลัก - จำนวนของจุดในแต่ละด้านของโดมิโนเช่น00, 34, ,4066

อาจกำหนดตัวเลขในลำดับใดก็ได้ดังนั้นจึง34เป็นโดมิโนเดียวกันกับ43

อินพุตตัวอย่าง

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>

ผลลัพธ์ตัวอย่างที่สอดคล้องกัน

<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 ไบต์

{:$7Ym*:$^}

บล็อก (ฟังก์ชัน) ที่ไม่มีชื่อที่มี I / 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.

Pyth, 12 10 ไบต์

-.CU7 2SMQ

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

ลองที่นี่

ขอบคุณ@ MartinBüttnerสำหรับการบันทึก 2 ไบต์ด้วยรูปแบบอินพุต / เอาต์พุตอื่น!

JavaScript (เสนอ ES7), 80 76 ไบต์

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

รับอินพุตเป็นสตริงที่คั่นด้วยช่องว่างและส่งคืนอาร์เรย์ของสตริง Array comprehensions ดึงน้ำหนักของพวกเขาสำหรับอันนี้จริงๆ

Ruby 74 ไบต์

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

รับอาร์เรย์ของสตริงส่งคืนอาร์เรย์ของสตริง

แสดงความคิดเห็นในโปรแกรมทดสอบ

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

เอาท์พุต

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

ในตัวอย่างสุดท้าย (รายการอินพุตว่าง) บันทึกลำดับของการสร้างรายการทั้งหมดของโดมิโนโดยใช้การคำนวณแบบแยกส่วน 7 คู่ถูกสร้างขึ้นก่อนจากนั้น 7 แต้มด้วยความแตกต่างของ 1 (หรือ 6) จุดระหว่างแต่ละด้านจากนั้น 7 แต้มด้วยความแตกต่างของ 2 (หรือ 5) จุดและสุดท้าย 7 แต้มด้วยความแตกต่าง 3 (หรือ 4) pips

Julia 0.6 , 47 bytes

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

ลองออนไลน์!

(ช่วงที่ถูกต้องเริ่มต้นขอบคุณ JayCe)

48 ไบต์

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

ลองออนไลน์!

Perl, 48 + 1 = 49 ไบต์

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

ต้องใช้-nธงและฟรี-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

คำตอบที่น่าเบื่อโดยรวมก็สวย แต่ที่นี่จะมีเวอร์ชั่นที่ไม่น่ารังเกียจ:

# '-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 ไบต์

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

ลองออนไลน์!

JavaScript (SpiderMonkey) , 69 ไบต์

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

ลองออนไลน์!

ปรับให้เหมาะสมจาก Neil's

R , 111 ไบต์

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

ลองออนไลน์!

ไม่ได้ภูมิใจในสิ่งนี้ แต่ R ไม่ได้ "กอล์ฟ" ในการแยก / เชื่อมสตริง ...

05AB1E , 12 11 ไบต์

6Ýã€{JI€{KÙ

-1 ขอบคุณไบต์@Emigna

ลองออนไลน์

คำอธิบาย:

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 ไบต์

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

อินพุตคือรายการของรายการจำนวนเต็ม

Java 8, 105 ไบต์

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

ลองใช้ออนไลน์

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

กิตติกรรมประกาศ

• -1 ไบต์ขอบคุณ Jonathan Frech

เยลลี่ขนาด 8 ไบต์

Ṣ€7ḶŒċ¤ḟ

ลองออนไลน์!

อาร์กิวเมนต์คือรายการของรายการจำนวนเต็ม 2 ความยาว ส่วนท้ายแปลงอินพุตจากรูปแบบในกรณีทดสอบเป็นรูปแบบที่โซลูชันนี้ยอมรับ

J, 26 , 24 ไบต์

-2 ไบต์ขอบคุณ FrownyFrog

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

• (;(,.i.,])&.>i.7) คำนวณชุดเต็ม (ส่วนนี้สามารถ golfed เพิ่มเติมฉันเชื่อและโปรดทำถ้าคุณเห็นว่า ... )
• -. คือ "set minus"
• /:~"1 สั่งซื้อแต่ละอินพุต

ลองออนไลน์!

เป็นต้นฉบับ

ลองออนไลน์!

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

Python 2, 89 86 ไบต์

บันทึกสองสามไบต์โดยทำให้การสร้างชุดโดมิโนง่ายขึ้น

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}

ลองออนไลน์!

ใช้รายการของสตริงเช่น ["00", "10", "02] เป็นอาร์กิวเมนต์สำหรับแต้มส่งคืนวัตถุชุดหลามซึ่งเป็นรายการที่แตกต่างกัน unordered

คำอธิบาย

# 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 ไบต์

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

ตัวอย่างการใช้งาน:

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

วนซ้ำaในวงรอบนอกของตัวเลขทั้งหมดจาก0ถึง6และbในลูปด้านในเหนือตัวเลขทั้งหมดจากaไปยัง6และเก็บไว้ในabตำแหน่งที่ไม่พบabหรือไม่baพบในสตริงอินพุต

อย่างจริงจัง 16 ไบต์

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

รับอินพุตเป็นรายการของสตริงเอาต์พุตรายการของสตริง

ลองออนไลน์!

คำอธิบาย:

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

จริงแล้ว 13 ไบต์ (ไม่ใช่การแข่งขัน)

♂S7r;∙`εjS`M-

นี่เป็นเหมือนคำตอบที่จริงจัง (ยกเว้นการป้อนข้อมูลโดยนัยและ ♂Sเป็นวิธีที่สั้นกว่าในการย่อแต่ละสตริงอินพุต)

ลองออนไลน์!

แร็กเกต

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