어떤 도미노가 빠졌습니까?

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
어떤 입력 형식이 허용됩니까? 문자열 목록? 정수 목록?
— Martin Ender
1
@Martin 저는 "어떤 목록, 배열, 집합, 수집, 벡터, 행렬 등의 어딘가에 메타 합의가 있다고 가정했습니다. 언어에 적합합니다. 멤버는 숫자 또는 문자열 일 수 있습니다"
— Digital Trauma
즉, 각 도미노를 정수 쌍으로 요청할 수 있습니다 (예 : 03 16= [0, 3], [1, 6]?).
— FlipTack
1
@FlipTack 예, 물론
— Digital Trauma

답변:

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

여기에서 시도하십시오.

다른 입력 / 출력 형식으로 2 바이트를 저장 한 @ MartinBüttner 에게 감사 합니다!

— 손잡이
소스
4

자바 스크립트 (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 개의 이중이 먼저 생성 된 다음 각면 사이에 1 (또는 6) 핍 차이가있는 7 개의 도미노, 2 (또는 5) 핍 차이가있는 7 개의 도미노, 마지막으로 3 (또는 4)의 차이가있는 7 개의 도미노 핍.

— 레벨 리버 스트리트
소스
3

Julia 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
3AM에 반 잠을 자려고 노력한 결과입니다. 그렇습니다. 고맙습니다.
— sundar-복원 모니카
2

펄, 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

전반적으로 꽤 지루한 대답이지만 여기에 ungolfed 버전이 있습니다.

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

@Emigna 덕분에 -1 바이트 .

온라인으로 사용해보십시오.

설명:

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}],#]&

입력은 정수 목록입니다.

— 계산기
소스
3
마지막 테스트 케이스에서 실패합니다. 순서가없는 세트라는 것을 기억하십시오.
— LegionMammal978
@ LegionMammal978에 동의합니다. 이 답변은 유효하지 않은 것 같습니다.
— Jonathan Frech
1

자바 8, 105 바이트

mutable을 수락하는 void 람다 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);
}

감사의 말

  • Jonathan Frech 덕분에 -1 바이트
— 야콥
소스
1
int i=0,a,b;while(i<49일 수 있습니다 for(int i=0,a,b;i<49;.
— Jonathan Frech
1

파이썬 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

하스켈, 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))))
— 케빈
소스
2
라켓에서 골프를하는 사람들을 만나서 반갑습니다! 이것은 코드 골프 질문이므로 답에 바이트 수를 포함시켜야합니다. 이 답변에서 꽤 많은 공백을 제거 할 수도 있습니다.
— 밀 마법사
이 답변이 유효하기에 충분히 골프화되지 않은 것 같다는 점에서 @WW에 동의합니다.
— Jonathan Frech
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.