Một khuôn phương Tây truyền thống là một khối lập phương, trên đó các số nguyên 1 đến 6 được đánh dấu trên các mặt. Các cặp thêm vào 7 được đặt trên các mặt đối diện.

Vì nó là khối lập phương, chúng ta chỉ có thể nhìn thấy từ 1 đến 3 khuôn mặt (bao gồm) ¹ tại bất kỳ thời điểm nào. Khuôn mặt đối diện không bao giờ có thể được nhìn thấy cùng một lúc.

Nhiệm vụ của bạn là viết một chương trình hoặc hàm, đưa ra một danh sách các số nguyên đại diện cho các mặt trên khuôn, xác định xem có thể nhìn thấy các mặt này cùng một lúc không.

¹ _{Được rồi, có thể bạn có thể nhìn thấy 4 hoặc 5 khuôn mặt với một đôi mắt, nhưng với mục đích của thử thách này, chúng tôi quan sát cái chết từ một điểm duy nhất.}

Quy tắc:

• Trình của bạn có thể giả sử danh sách đầu vào:
  • Là không trống rỗng.
  • Chỉ chứa các giá trị thỏa mãn 1 ≤ n ≤ 6.
  • Không chứa các yếu tố trùng lặp.
• Bạn không thể cho rằng đầu vào được sắp xếp.
• Trình của bạn nên xuất ra một giá trị trung thực / giả mạo : sự thật là khuôn mặt có thể được nhìn thấy cùng một lúc, giả mạo khác.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng!
• Các sơ hở tiêu chuẩn bị cấm theo mặc định.

Các trường hợp thử nghiệm

Sự thật:

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

Giả mạo:

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

Python 2 , 35 byte

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

Hãy thử trực tuyến!

JavaScript (ES6),  38 34 30 29  28 byte

Lấy đầu vào là bất kỳ số lượng tham số riêng biệt. Trả về 0hoặc 1.

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

Các trường hợp thử nghiệm

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

Làm sao?

Dưới đây là các phiên bản đơn giản hóa của biểu thức chính theo số lượng tham số được cung cấp, các biến không xác định được ép buộc thành 0 hoặc sai :

# 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

Lưu ý : Thứ tự của (a, b, c) không quan trọng vì chúng luôn XOR với nhau.

Trường hợp khó nhất là trường hợp thứ 3. Dưới đây là bảng hiển thị tất cả các kết hợp có thể:

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. phiên bản # 1, 32 byte

Đưa đầu vào như một mảng. Trả về một boolean.

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

Các trường hợp thử nghiệm

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. phiên bản # 2, Chrome / Firefox, 34 byte

Điều này lạm dụng các phương pháp sắp xếp của Chrome và Firefox. Nó không hoạt động với Edge.

Đưa đầu vào như một mảng. Trả về 0hoặc 1.

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

Các trường hợp thử nghiệm

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

Haskell , 24 byte

-3 byte nhờ H.PWiz.

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

Hãy thử trực tuyến!

Giải trình

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

APL (Dyalog) , 7 byte

~7∊∘.+⍨

Hãy thử trực tuyến!

∘.+⍨ - bảng bổ sung (mọi phần tử với mọi phần tử)

7∊ - 7 tồn tại?

~ - phủ nhận

APL (Dyalog) , 7 byte

⍬≡⊢∩7-⊢

Hãy thử trực tuyến!

7-⊢ - trừ từng phần tử từ 7

⊢∩ - giao với mảng ban đầu

⍬≡ - trống?

R , 27 byte

cảm ơn Gregor đã sửa lỗi

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

Hãy thử trực tuyến!

Câu trả lời của cảng Chas Brown . Có các hoạt động véc tơ giúp làm cho điều này ngắn hơn nhiều trong R.

Toán học, 20 byte

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

Cái là\[Function]

-12 byte từ Martin Ender
-7 byte từ Misha Lavrov

Hãy thử trực tuyến!

Haskell , 26 byte

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

Hãy thử trực tuyến!

Bình thường , 5 byte

!@-L7

Hãy thử nó ở đây.

Trên thực tế , 8 byte

;∙♂Σ7@cY

Hãy thử trực tuyến!(chạy tất cả các trường hợp thử nghiệm)

Giải trình:

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

Husk , 5 byte

Ëo≠7+

Hãy thử trực tuyến!

Giải trình

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

Võng mạc , 21 20 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Chỉnh sửa: Đã lưu 1 byte nhờ @MartinEnder. Giải trình:

O`.

Sắp xếp đầu vào.

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

Kiểm tra một cặp cạnh đối diện (sắp xếp 3 và 4 cạnh nhau). Điều này trả về 1 cho một chết không hợp lệ hoặc 0 cho một hợp lệ.

0

Logic phủ nhận kết quả.

Thạch , 5 byte

7_f⁸Ṇ

Hãy thử trực tuyến!

Câu trả lời của cảng Chas Brown .

Giải trình

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

Alice , 18 byte

/..y1nr@ 
\iReA6o/

Hãy thử trực tuyến!

Bản in Jabberwocky cho đầu vào hợp lệ và không có gì khác.

Giải trình

Mở ra luồng điều khiển ngoằn ngoèo, chương trình thực sự chỉ là:

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.

Bình thường , 5 byte

-7sM*

Bộ thử nghiệm.

isaacg đã lưu một byte!

Ruby , 36 31 24 23 byte

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

Hãy thử trực tuyến!

Nó rất đơn giản, tôi đã tìm kiếm giải pháp cho vấn đề sai mọi lúc.

05AB1E , 5 byte

7αå_P

Hãy thử trực tuyến!

Giải trình

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

Một trong nhiều cách để làm điều này trong 5 byte trong 05AB1E

Perl 5 , 51 + 1 ( -a) = 52 byte

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

Hãy thử trực tuyến!

Võng mạc , 20 byte

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

Hãy thử trực tuyến!

Một cách khác để tiếp cận Neil.

Giải trình

T`_654`d

Rẽ 6, 5, 4vào 1, 2, 3, tương ứng.

M`(.).*\1

Cố gắng tìm các ký tự lặp đi lặp lại và đếm số lượng trận đấu.

0

Hãy chắc chắn rằng kết quả bằng không (hiệu quả là phủ định logic).

Java (OpenJDK 8) , 43 byte

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

Hãy thử trực tuyến!

GNU sed , 37 22 + 1 = 23 byte

+1 byte cho -rcờ. Lấy đầu vào dưới dạng chữ số; in đầu vào cho trung thực và giả 0.

-10 byte nhờ @MartinEnder.

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

Hãy thử trực tuyến!

Giải trình

Tương tự như câu trả lời Alice của @ MartinEnder .

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

Perl 6 , 18 byte

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

Hãy thử trực tuyến!

1 & 6 | 2 & 5 | 3 & 4là một điểm nối bao gồm các số 1 và 6, HOẶC các số 2 và 5, HOẶC các số 3 và 4. Ngã ba này là một phần tử của ( ∈) danh sách đầu vào *nếu nó chứa 1 và 6, hoặc 2 và 5, hoặc 3 và 4. Kết quả đó sau đó được phủ định ( !) để lấy giá trị boolean cần thiết.

Haskell, 46 41 37 byte

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

Đưa sản phẩm của Cartesian vào danh sách, sau đó kiểm tra xem tất cả các danh sách kết quả có tổng bằng 7. (Nếu bất kỳ trong số chúng được tổng hợp thành 7, các mặt đối diện sẽ hiển thị và "tất cả không" ngắn hơn "không bat ki lam".)

J , 12 byte

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

Điều này khá giống với giải pháp APL đầu tiên của Uriel

Hãy thử trực tuyến!

Công thức ghi chú IBM / Lotus, 7 byte

!7-i*=i

Lấy đầu vào từ trường số nhiều giá trị i.

Đệ quy trừ từng giá trị của i từ 7 và kiểm tra xem nó có trong danh sách ban đầu không. ! thay đổi 1 nếu là 0 (tất cả các mặt không thể nhìn thấy).

Các trường hợp thử nghiệm (không có TIO cho Công thức ghi chú)

Sạch , 49 byte

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

Hãy thử trực tuyến!

Swift , 46 byte

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

Lấy đầu vào là [Int](mảng số nguyên) và trả về một Bool(boolean).

Giải thích ngắn gọn

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

Clojure , 89 80 72 byte

-9 byte vì tôi nhận ra việc sử dụng reduced là không cần thiết

-8 byte bằng cách thay đổi từ sử dụng reducesang sử dụngsome

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

Tôi đã thử viết điều này mà không nhìn vào bất kỳ thủ thuật nào mà các câu trả lời khác sử dụng. Tôi có thể cải thiện điều này sau.

Trả về truecho các trường hợp thực sự, falsenếu bất kỳ bên nào tổng hợp thành 7 và nilnếu số lượng bên là bất hợp pháp.

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