Bir standart domino seti 28 benzersiz parçaları vardır:

28 veya daha az benzersiz domino listesi göz önüne alındığında, tam bir set oluşturmak için gereken listeyi çıkar.

Giriş ve çıkış domino iki hane tarafından belirlenen edilir - domino her bir tarafında pip sayısı, örneğin 00, 34, 40, 66.

Rakamlar herhangi bir sırayla verilebilir, yani 34aynı domino43

Örnek Girişler

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>

İlgili Örnek Çıktılar

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

{:$7Ym*:$^}

Tamsayı çiftleri listesi olarak G / Ç içeren adsız bir blok (işlev)

Burada test et.

açıklama

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

-.CU7 2SMQ

Giriş ve çıkış 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

Burada dene.

Farklı giriş / çıkış formatlarında 2 byte tasarruf için @ MartinBüttner'e teşekkürler !

JavaScript (ES7 önerilir), 80 76 bayt

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

Girdiyi boşlukla ayrılmış bir dizge olarak alır ve bir dizi dizge döndürür. Dizi kavrayışları bunun için gerçekten ağırlıklarını çekiyor.

Yakut 74 bayt

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

Dizeleri alır, dizeleri döndürür.

Test programında yorum yaptı

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

Çıktı

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

Son örnekte (boş liste girişi), modüler aritmetik kullanılarak tüm domino listesinin oluşturulmasının sırasına dikkat edin. Önce 7 iki çift üretilir, daha sonra her iki taraf arasında 1 (veya 6) pip farkına sahip 7 domino, daha sonra 2 (veya 5) pip farkına sahip 7 domino ve 3 (veya 4) farkına sahip 7 domino pip.

Julia 0.6 , 47 bayt

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

Çevrimiçi deneyin!

(JayCe sayesinde düzeltilmiş aralık başlar.)

48 bayt

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

Çevrimiçi deneyin!

Perl, 48 + 1 = 49 bayt

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

-nBayrak ve ücretsiz gerektirir -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

Genel olarak oldukça sıkıcı bir cevap, ancak işte bir yıpranmış versiyonu:

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

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

Çevrimiçi deneyin!

JavaScript (SpiderMonkey) , 69 bayt

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

Çevrimiçi deneyin!

Neil'den optimize edilmiş

R , 111 bayt

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

Çevrimiçi deneyin!

Bundan gerçekten gurur duymuyorum, fakat R, karakter dizilerini bölme / birleştirmede çok "golf" değil ...

05AB1E , 12 11 bayt

6Ýã€{JI€{KÙ

@Emigna sayesinde -1 bayt .

Çevrimiçi deneyin.

Açıklama:

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 bayt

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

Giriş, tamsayıların listesidir.

Java 8, 105 bayt

Bir değişken kabul eden bir boş lambda 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);}

Çevrimiçi Deneyin

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

Teşekkür

• Jonathan Frech sayesinde -1 bayt

Jöle , 8 bayt

Ṣ€7ḶŒċ¤ḟ

Çevrimiçi deneyin!

Argüman, tamsayıların uzunluk-2 listelerinin listesidir. Altbilgi, girdiyi test senaryolarındaki formattan bu çözümün kabul ettiği formata dönüştürür.

J, 26 , 24 bayt

FrownyFrog sayesinde -2 bayt

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

• (;(,.i.,])&.>i.7) setin tamamını hesaplar (bu kısım daha fazla golf oynayabilir, inanıyorum. Ve lütfen nasıl yaparsanız bakın ...)
• -. "eksi ayarlandı"
• /:~"1 girişlerin her birini sıralar

Çevrimiçi deneyin!

orijinal

Çevrimiçi deneyin!

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

Python 2, 89 86 bayt

Domino seti neslini basitleştirerek birkaç bayt kurtardı.

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}

Çevrimiçi deneyin!

Dominolar için argüman olarak ["00", "10", "02] gibi bir dizginin listesini alır ve sıralanmamış ayrı listeler olan python set nesnelerini döndürür.

açıklama

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

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

Kullanım örneği:

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

Bıkmadan atüm rakamlar üzerinde bir dış döngü içinde 0hiç 6ve btüm rakamlar üzerinde bir iç döngüde aiçin 6ve bu tutmak abnerede ne abde bagiriş dizesi bulunur.

Cidden, 16 bayt

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

Dizelerin bir listesi olarak girdi alır, dizelerin bir listesini çıkarır

Çevrimiçi deneyin!

Açıklama:

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

Aslında , 13 bayt (rekabet etmeyen)

♂S7r;∙`εjS`M-

Bu, Cidden cevap ile aynıdır (örtük girdi hariç ♂S her girdi dizisini kısaltmanın daha kısa bir yoludur).

Çevrimiçi deneyin!

raket

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