Стандартний набір доміно складається з 28 унікальних предметів:

Враховуючи список з 28 або менше унікальних доміно, виведіть список, необхідний для створення повного набору.

Вхідні і вихідні Доміно задаються двома цифрами - кількість пунктів на кожній стороні доміно, наприклад 00, 34, 40, 66.

Цифри можуть бути надані в будь-якому порядку, так 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

code-golf dominoes

— Цифрова травма
джерело

2

Які формати введення дозволені? Списки рядків? Списки списків цілих чисел?

— Мартін Ендер

1

@Martin Я припускав, що у нас є мета-консенсус десь уздовж рядків "будь-який список, масив, набір, колекція, вектор, матриця, ... підходить для вашої мови. Учасники можуть бути числами або рядками"

— Digital Trauma

Чи означає це, що ми можемо запитувати кожне доміно як пару цілих чисел, наприклад 03 16= [0, 3], [1, 6]?

— FlipTack

1

@FlipTack Так, звичайно

— Digital Trauma

10

CJam, 11 байт

{:$7Ym*:$^}

Безіменний блок (функція) з введенням-виводом як список пар цілих чисел.

Тестуйте це тут.

Пояснення

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

— Мартін Ендер
джерело

Для чого потрібні {}дужки?

— Хром

6

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-х байт з різним форматом введення / виводу!

— Дверна ручка
джерело

4

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]

Приймає введення як пробіл, розділений пробілом, і повертає масив рядків. Зрозуміння масиву дійсно тягнуть свою вагу для цього.

— Ніл
джерело

3

Рубін 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) піпси.

— Рівень річки Св
джерело

3

Джулія 0,6 , 47 байт

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

Спробуйте в Інтернеті!

— sundar - Відновлення Моніки
джерело

Я думаю, що у вашому 3-му тестовому випадку TIO, здається, відсутні нульові доміно. Для i = 0: 6 можливо?

— JayCe

Ось що я отримую від спроби розмістити напівсин о 3 ранку! Так, виправлено зараз (сподіваємось), дякую.

— sundar

2

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

— andlrc
джерело

2

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

Спробуйте в Інтернеті!

— FlipTack
джерело

2

JavaScript (SpiderMonkey) , 69 байт

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

Спробуйте в Інтернеті!

оптимізований від Ніла

— l4m2
джерело

2

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 не дуже "гофрований" у розщепленні / об'єднанні струн ...

— digEmAll
джерело

2

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

— Кевін Круїссен
джерело

1

Математика, 49 байт

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

Введення - це список списку цілих чисел.

— CalculatorFeline
джерело

3

Невдача в останньому тестовому випадку; пам’ятайте, це не упорядковані набори.

— LegionMammal978

Я погодився б з @ LegionMammal978; ця відповідь видається недійсною.

— Джонатан Фрех

1

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

Спробуйте це в Інтернеті

Безумовно

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 байт завдяки Джонатану Фреху

— Якоб
джерело

1

int i=0,a,b;while(i<49може бути for(int i=0,a,b;i<49;.

— Джонатан Фрех

1

Желе , 8 байт

Ṣ€7ḶŒċ¤ḟ

Спробуйте в Інтернеті!

Аргумент - це список довжин-2 списки цілих чисел. Футер перетворює вхідні дані з формату в тестових випадках у формат, який приймає це рішення.

— Ерік Аутгольфер
джерело

1

J, 26 , 24 байти

-2 байти завдяки FrownyFrog

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

(;(,.i.,])&.>i.7) підраховує повний набір (я вважаю, що ця частина може бути додатково гольф. І, будь ласка, зробіть, якщо ви бачите, як ...)
-. є "встановити мінус"
/:~"1 замовляє кожен із входів

Спробуйте в Інтернеті!

Оригінал

Спробуйте в Інтернеті!

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

— Йона
джерело

(;(,.i.,])&.>i.7)економить 2 (скасовує порядок)

— FrownyFrog

@FrownyFrog спасибі, оновлено.

— Йона

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] як аргумент для доміно. Повертає об'єкти набору python, які є не упорядкованими різними списками.

Пояснення

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

— Тригернометрія
джерело

0

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знайдені у вхідному рядку.

— німі
джерело

0

Серйозно, 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є більш коротким способом короткого введення кожного рядка введення).

Спробуйте в Інтернеті!

— Мего
джерело

1

У вас є дублікати на виході

— Digital Trauma

@DigitalTrauma Це пов’язано з невідповідними змінами, що відбулися з моменту публікації.

— Мего

0

ракетка

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

— Кевін
джерело

2

Приємно бачити, як люди грають у ракетку! Це питання з кодовим гольфом, тож вам, ймовірно, слід було б включити свій рахунок у відповідь. Ви також можете точно вилучити пробіл із цієї відповіді.

— Пшеничний майстер

Я погодився б з @WW в тому, що ця відповідь, здається, недостатньо гольф, щоб бути дійсною.

— Джонатан Фрех

Які доміно відсутні?

Приклади введення

Відповідні приклади виходів

CJam, 11 байт

Пояснення

Pyth, 12 10 байт

JavaScript (запропоновано ES7), 80 76 байт

Рубін 74 байти

Джулія 0,6 , 47 байт

48 байт

Perl, 48 + 1 = 49 байт

Python 2 , 91 байт

JavaScript (SpiderMonkey) , 69 байт

R , 111 байт

05AB1E , 12 11 байт

Математика, 49 байт

Java 8, 105 байт

Безумовно

Подяка

Желе , 8 байт

J, 26 , 24 байти

Оригінал

Python 2, 89 86 байт

Haskell, 65 байт

Серйозно, 16 байт

Насправді 13 байт (не конкуруючий)

ракетка