보이는 주사위 얼굴

21

전통적인 서 다이는 1 내지 6의 정수가면에 표시되는 정육면체이다. 7에 추가되는 쌍은 반대쪽면에 배치됩니다.

정육면체이므로 주어진 시간에 1 ~ 3 개의 얼굴 (포함) ¹ 만 볼 수 있습니다 . 반대쪽 얼굴은 동시에 볼 수 없습니다.

당신의 임무는 다이의 측면을 나타내는 정수 목록이 주어지면 동시에 이러한 얼굴을 볼 수 있는지 결정하는 프로그램이나 함수를 작성하는 것입니다.

¹_{네, 한 쌍의 눈으로 4 개 또는 5 개의 얼굴을 볼 수 있지만,이 도전의 목적을 위해 우리는 한 지점에서 주사위를 관찰합니다.}

규칙 :

제출물은 입력 목록을 가정 할 수 있습니다.
- 비어 있지 않습니다.
- 를 만족하는 값만 포함합니다 1 ≤ n ≤ 6.
- 중복 요소가 없습니다.
입력이 정렬되었다고 가정 하지 않을 수 있습니다 .
당신의 제출은 진실 / 허위 가치를 출력해야 합니다 : 진실은 얼굴을 동시에 볼 수 있고, 그렇지 않으면 허위입니다.
이것은 code-golf 이므로 가장 짧은 답변 (바이트)이 이깁니다!
표준 허점 은 기본적으로 금지되어 있습니다.

테스트 사례

진실한 :

[6]                 (One face)
[6, 2]              (Share a side)
[1, 3]              (Share a side)
[2, 1, 3]           (Share a vertex)
[3, 2, 6]           (Share a vertex)

거짓 :

[1, 6]              (1 and 6 are opposite)
[5, 4, 2]           (2 and 5 are opposite)
[3, 1, 4]           (3 and 4 are opposite)
[5, 4, 6, 2]        (Cannot see 4 faces)
[1, 2, 3, 4, 5, 6]  (Cannot see 6 faces)

code-golf decision-problem

— 플립 택
소스

관련 .

— FlipTack

3보다 긴 목록에는 반대되는 값이 포함되어 있기 때문에 마지막 두 가지 잘못된 사례는 불필요한 것 같습니다.

— Weckar E.

@WeckarE 네, 분명히-당신이 대답을 보면 그들은 모두 이것을 악용합니다. 작성하는 것이 더 쉬운 설명이었습니다.

— FlipTack

@FlipTack 실제로 길이를 전혀 확인할 필요는 없습니다. 3 개의 요소보다 긴 모든 목록에는 적어도 한 쌍의 반대면이 있습니다.

— Erik the Outgolfer

1

블랙홀과 같은 무거운 물체로 빛의 파도를

— 굽히면

답변:

15

파이썬 2 , 35 바이트

lambda a:any(7-i in a for i in a)<1

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

— 차스 브라운
소스

5

-1 바이트 파이썬 3에서

— notjagan

14

자바 스크립트 (ES6), 38 34 30 29 28 바이트

여러 개의 개별 매개 변수로 입력을받습니다. 반환 0또는 1.

(a,b,c,d)=>!(d|(a^b^c)%7)^!c

테스트 사례

코드 스 니펫 표시

let f =

(a,b,c,d)=>!(d|(a^b^c)%7)^!c

console.log('[Truthy]')
console.log(f(6      ))
console.log(f(6, 2   ))
console.log(f(1, 3   ))
console.log(f(2, 1, 3))
console.log(f(3, 2, 6))

console.log('[Falsy]')
console.log(f(1, 6            ))
console.log(f(5, 4, 2         ))
console.log(f(3, 1, 4         ))
console.log(f(5, 4, 6, 2      ))
console.log(f(1, 2, 3, 4, 5, 6))

스 니펫 확장

방법?

다음은 제공되는 매개 변수 수에 따른 기본 표현식의 단순화 된 버전으로, 정의되지 않은 변수는 0 또는 false 로 강제 변환됩니다 .

# of param. | simplified expression        | comment
------------+------------------------------+---------------------------------------------
     1      | !(a % 7) ^ 1                 | always true
     2      | !((a ^ b) % 7) ^ 1           | false for (1,6), (2,5) and (3,4)
     3      | !((a ^ b ^ c) % 7)           | see the table below
     4+     | !(d | (a ^ b ^ c) % 7)       | always false

NB : (a, b, c) 의 순서 는 항상 함께 XOR되기 때문에 중요하지 않습니다.

가장 까다로운 경우는 세 번째입니다. 가능한 모든 조합을 보여주는 표는 다음과 같습니다.

a | b | c | a^b^c | %7 | =0? | faces that sum to 7
--+---+---+-------+----+-----+--------------------
1 | 2 | 3 |   0   |  0 | Yes | none
1 | 2 | 4 |   7   |  0 | Yes | none
1 | 2 | 5 |   6   |  6 | No  | 2 + 5
1 | 2 | 6 |   5   |  5 | No  | 1 + 6
1 | 3 | 4 |   6   |  6 | No  | 3 + 4
1 | 3 | 5 |   7   |  0 | Yes | none
1 | 3 | 6 |   4   |  4 | No  | 1 + 6
1 | 4 | 5 |   0   |  0 | Yes | none
1 | 4 | 6 |   3   |  3 | No  | 1 + 6
1 | 5 | 6 |   2   |  2 | No  | 1 + 6
2 | 3 | 4 |   5   |  5 | No  | 3 + 4
2 | 3 | 5 |   4   |  4 | No  | 2 + 5
2 | 3 | 6 |   7   |  0 | Yes | none
2 | 4 | 5 |   3   |  3 | No  | 2 + 5
2 | 4 | 6 |   0   |  0 | Yes | none
2 | 5 | 6 |   1   |  1 | No  | 2 + 5
3 | 4 | 5 |   2   |  2 | No  | 3 + 4
3 | 4 | 6 |   1   |  1 | No  | 3 + 4
3 | 5 | 6 |   0   |  0 | Yes | none
4 | 5 | 6 |   7   |  0 | Yes | none

Alt. 버전 # 1, 32 바이트

입력을 배열로받습니다. 부울을 반환합니다.

a=>a.every(x=>a.every(y=>x+y-7))

테스트 사례

코드 스 니펫 표시

let f =

a=>a.every(x=>a.every(y=>x+y-7))

console.log('[Truthy]')
console.log(f([6]      ))
console.log(f([6, 2]   ))
console.log(f([1, 3]   ))
console.log(f([2, 1, 3]))
console.log(f([3, 2, 6]))

console.log('[Falsy]')
console.log(f([1, 6]            ))
console.log(f([5, 4, 2]         ))
console.log(f([3, 1, 4]         ))
console.log(f([5, 4, 6, 2]      ))
console.log(f([1, 2, 3, 4, 5, 6]))

스 니펫 확장

Alt. 버전 # 2, Chrome / Firefox, 34 바이트

이것은 Chrome과 Firefox의 정렬 방법을 남용합니다. Edge에서는 작동하지 않습니다.

입력을 배열로받습니다. 반환 0또는 1.

a=>a.sort((a,b)=>k&=a+b!=7,k=1)&&k

테스트 사례

코드 스 니펫 표시

let f =

a=>a.sort((a,b)=>k&=a+b!=7,k=1)&&k

console.log('[Truthy]')
console.log(f([6]      ))
console.log(f([6, 2]   ))
console.log(f([1, 3]   ))
console.log(f([2, 1, 3]))
console.log(f([3, 2, 6]))

console.log('[Falsy]')
console.log(f([1, 6]            ))
console.log(f([5, 4, 2]         ))
console.log(f([3, 1, 4]         ))
console.log(f([5, 4, 6, 2]      ))
console.log(f([1, 2, 3, 4, 5, 6]))

스 니펫 확장

— 아르나 울드
소스

8

하스켈 , 24 바이트

H.PWiz 덕분에 -3 바이트

f l=all(/=7)$(+)<$>l<*>l

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

설명

f l=all(/=7)$(+)<$>l<*>l

f l=                      -- make a function f that takes a single argument l
             (+)<$>l<*>l  -- take the sum of each pair in the cartesian product...
    all(/=7)$             -- ...and check if they're all inequal to 7

— 완전히 인간적인
소스

5

APL (Dyalog) , 7 바이트

~7∊∘.+⍨

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

∘.+⍨ -추가 테이블 (모든 요소가있는 모든 요소)

7∊ -7 존재?

~ -부정하다

APL (Dyalog) , 7 바이트

⍬≡⊢∩7-⊢

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

7-⊢ -7에서 각 원소를 빼기

⊢∩ -원래 배열과 교차

⍬≡ -비어있어?

— 우리엘
소스

5

아르 자형 , 27 바이트

버그를 수정 한 Gregor 덕분에

function(d)!any((7-d)%in%d)

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

포트 의 Chas 브라운의 대답 . 벡터화 된 연산을 사용하면 R에서 훨씬 짧아집니다.

— 주세페
소스

나는 당신이 주변에 약간의 괄호가 필요하다고 생각하고 (7-d), 다른 현명한 것이 d%in%d우선합니다.

— Gregor

@Gregor 당신은 절대적으로 맞습니다.

— 주세페

4

Mathematica, 20 바이트

xFreeQ[#+x&/@x,7]

그만큼  이다\[Function]

Martin Ender에서 -12 바이트
Misha Lavrov에서 -7 바이트

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

— J42161217
소스

3

하스켈 , 26 바이트

f x=null[1|7<-(+)<$>x<*>x]

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

— H.PWiz
소스

3

Pyth , 5 바이트

!@-L7

여기에서 시도하십시오.

— 아웃 골퍼 에릭
소스

나는 2 분 전에 이것을 시도했지만 작동하지 않았다고 맹세 할 수 있었다 ... 허 무슨 일이 있었는지 궁금하다

— Mr. Xcoder

내가 제일 먼저 생각한 것은? Sandlot .

— maxathousand

3

실제로 8 바이트

;∙♂Σ7@cY

온라인으로 사용해보십시오! (모든 테스트 사례를 실행)

설명:

;∙♂Σ7@cY
;∙        Cartesian product with self
  ♂Σ      sum all pairs
    7@c   count 7s
       Y  logical negate

— 메고
소스

3

껍질 , 5 바이트

Ëo≠7+

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

설명

Ëo     Check that the following function gives a truthy value for all pairs 
       from the input.
    +    Their sum...
  ≠7     ...is not equal to 7.

— 마틴 엔더
소스

3

망막 , 21 20 바이트

O`.
M`1.*6|2.*5|34
0

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 편집 : @MartinEnder 덕분에 1 바이트가 절약되었습니다. 설명:

O`.

입력을 정렬하십시오.

M`1.*6|2.*5|34

한 쌍의 반대쪽을 확인하십시오 (3과 4가 서로 옆에 정렬). 유효하지 않은 주사위의 경우 1을, 유효한 주사위의 경우 0을 반환합니다.

결과를 논리적으로 부정합니다.

— 닐
소스

2

젤리 , 5 바이트

7_f⁸Ṇ

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

Chas Brown의 답변 .

설명

7_f⁸Ṇ
7_    Subtract each element from 7
  f⁸  Filter with the original list
    Ṇ Check if empty

— 아웃 골퍼 에릭
소스

2

Alice , 18 바이트

/..y1nr@ 
\iReA6o/

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

Jabberwocky유효한 입력을 위해 인쇄 합니다.

설명

지그재그 제어 흐름을 전개하면 프로그램은 실제로 다음과 같습니다.

i.e16r.RyAno

i.  Read all input and duplicate it.
e16 Push "16".
r   Range expansion to get "123456".
.R  Duplicate and reverse.
y   Transliterate, replaces each face with its opposite.
A   Intersection with input.
n   Logical NOT, turns empty strings into "Jabberwocky"
    and everything else into an empty string.

— 마틴 엔더
소스

2

Pyth , 5 바이트

-7sM*

테스트 스위트.

isaacg는 바이트를 저장했습니다!

— 미스터 Xcoder
소스

2

루비 , 36 31 24 23 바이트

->l{l-l.map{|x|7-x}==l}

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

너무 간단해서 항상 잘못된 문제에 대한 해결책을 찾고있었습니다.

— GB
소스

1

05AB1E , 5 바이트

7αå_P

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

설명

7α      # absolute difference between 7 an each in input list
  å     # check each element if it exist in input
   _    # logical negate
    P   # product of list

05AB1E에서 5 바이트로이를 수행하는 여러 가지 방법 중 하나

— 에미 냐
소스

1

펄 5 , 51 + 1 ( `-a`) = 52 바이트

say$F[0]+($t=$F[1])-7&&$F[0]+$t-7&&$t+$F[2]-7&&@F<4

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

— Xcali
소스

3 1 4사실은 무엇입니까say 1>grep{$x=$_;grep$_+$x==7,@F}@F

— Nahuel Fouilleul

25 + 1 (-p) 나오지 용액으로부터 고무

— 나우 Fouilleul

1

레티 나 , 20 바이트

T`_654`d
M`(.).*\1
0

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

Neil의 접근법에 대한 대안.

설명

T`_654`d

돌려 6, 5, 4에 1, 2,는 3각각.

M`(.).*\1

반복되는 문자를 찾아서 일치 횟수를 세십시오.

결과가 0인지 확인하십시오 (효과적으로 논리적 부정).

— 마틴 엔더
소스

1

자바 (OpenJDK 8) , 43 바이트

l->l.stream().noneMatch(x->l.contains(7-x))

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

— 올리비에 그레고리
소스

1

GNU sed , 37 22 + 1 = 23 바이트

-r플래그의 경우 +1 바이트 입력을 숫자로 취합니다. 진실과 허위에 대한 입력을 인쇄합니다 0.

@MartinEnder 덕분에 -10 바이트

y/123/654/
/(.).*\1/c0

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

설명

@MartinEnder의 Alice answer 와 유사합니다 .

y/123/654/   # Transliterate 1-3 to 6-4
/(.).*\1/c0  # If a digit appears twice, replace the pattern space with 0

— 요르단
소스

진실을 위해 입력을 정확하게 인쇄하지는 않고 입력을 1-3으로 대체하여 6-4로 인쇄합니다.

— 앤드류는 Reinstate Monica가

1

펄 6 , 18 바이트

!(1&6|2&5|3&4∈*)

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

1 & 6 | 2 & 5 | 3 & 4는 1과 6, 또는 2와 5, 또는 3과 4로 구성된 정션입니다.이 정션은 ∈입력 목록 *에 1과 6이 있거나 2와 5가 포함 된 경우 입력 목록 의 요소입니다. 4. 그런 다음 !필요한 부울 값을 얻기 위해 결과가 무효화됩니다 ( ).

— 션
소스

0

하스켈, 46 41 37 바이트

f z=all ((/=7).sum) [[x,y]|x<-z,y<-z]

리스트의 카티 전 곱을 자체로 취한 다음 결과리스트가 모두 7의 합계가 아닌지 확인합니다. (7 개 중 하나를 합산하면 반대쪽면이 표시되고 "모두"가 "not not"보다 짧습니다 아무거나 "

— 드라코 니스
소스

0

J , 12 바이트

7-.@e.[:,+/~

이것은 Uriel의 첫 번째 APL 솔루션과 거의 동일합니다.

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

— 갈렌 이바노프
소스

0

IBM / Lotus Notes 공식, 7 바이트

!7-i*=i

다중 값 숫자 필드 i에서 입력을받습니다.

7에서 i의 각 값을 재귀 적으로 빼고 원래 목록에 있는지 확인합니다. ! 0 인 경우 1을 변경합니다 (얼굴을 모두 볼 수는 없습니다).

테스트 사례 (Notes 수식에 사용 가능한 TIO 없음)

— 엘 페드로
소스

0

클린 , 49 바이트

import StdEnv
f l=and[(a+b)<>7\\(a,b)<-diag2 l l]

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

— 뇨
소스

1

@StephenLeppik이 답변이 반드시 파일 이름 을 사용하여 정보를 저장 한다고 생각하지 않습니다 .

— Steadybox

@StephenLeppik 공정한 점은 가져 오기가 필요하지만 특정 모듈에서 함수를 선언 할 필요는 없다는 것입니다. 감사.

— OUurous

0

스위프트 , 46 바이트

f(a:Int)->[Int]{!a.contains{a.contains(7-$0)}}

입력을 [Int](정수 배열) 로 가져 와서Bool (부울)을 .

간단한 설명 (무용지물)

f(a:Int)->[Int]{
    !a.contains (where: {n in    // The input doesn't have an element where
        a.contains(7 - n)        //    the opposite side is in the input
    })
}

— 허먼 L
소스

0

클로저 , 89 80 72 바이트

-9 바이트 사용을 실현했기 때문에 reduced 이 불필요

-11하여 행 바꿈으로써 바이트를 reduce사용하여some

#(if(< 0(count %)4)(not(some(fn[[a b]](=(+ a b)7))(for[a % b %][a b]))))

다른 답변이 사용하는 트릭을 보지 않고 이것을 작성했습니다. 나중에 이것을 개선 할 수 있습니다.

변의 합이 7 인 경우 와 변의 수가 잘못된 true경우에 false해당하는 경우에 반환 합니다 nil.

(defn can-see? [dice-sides]
  ; Ensure its a valid length
  (if (< 0 (count dice-sides) 4)

    ; Then check if any of the permutations sum to 7
    (not (some (fn [[a b]]
                 (= (+ a b) 7))

               ; Generate all permutations
               (for [a dice-sides, b dice-sides] [a b])))))

— 발암 성 물질
소스

당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.

Licensed under cc by-sa 3.0 with attribution required.