Какие домино отсутствуют?

34

Стандартный набор домино состоит из 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 Да, конечно
— Цифровая травма

Ответы:

10

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.
— Мартин Эндер
источник
Зачем вам {}скобки?
— Chromium
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

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) пипсов.

— Уровень реки St
источник
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 - Восстановить Монику
источник
Я думаю, что нулевое домино, кажется, отсутствует в вашем третьем тестовом примере TIO. Для я = 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

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

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

Попробуйте онлайн

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 байт благодаря Джонатану Фреху
— Jakob
источник
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]
— Triggernometry
источник
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 Это происходит из-за несовместимых назад изменений, внесенных со времени публикации.
— Mego
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))))
— Kevin
источник
2
Приятно видеть людей, играющих в гольф в ракетке! Это вопрос по коду для игры в гольф, поэтому вам, вероятно, следует включить свой бай-счет в свой ответ. Вы также можете определенно удалить немного пробела из этого ответа.
— Пшеничный волшебник
Я бы согласился с @WW в том, что этот ответ, кажется, не достаточно удачен, чтобы быть действительным.
— Джонатан Фрех
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.