ตายแบบตะวันตกเป็นก้อนซึ่งเลข 1 ถึง 6 มีการทำเครื่องหมายบนใบหน้า คู่ที่เพิ่มไปยัง 7 จะวางอยู่บนใบหน้าตรงข้าม

เนื่องจากเป็นคิวบ์เราสามารถมองเห็นได้ระหว่าง 1 และ 3 ใบหน้า (รวม) ¹ในเวลาที่กำหนด ไม่สามารถมองเห็นใบหน้าตรงข้ามได้ในเวลาเดียวกัน

งานของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นที่กำหนดรายการจำนวนเต็มแทนด้านตายกำหนดว่าเป็นไปได้ที่จะเห็นใบหน้าเหล่านี้ในเวลาเดียวกัน

¹ _{โอเคบางทีคุณอาจเห็นใบหน้า 4 หรือ 5 หน้าด้วยดวงตาคู่หนึ่ง แต่สำหรับจุดประสงค์ของการท้าทายนี้เราจะสังเกตเห็นความตายจากจุดเดียว}

กฎ:

• การส่งของคุณอาจถือว่ารายการอินพุต:
  • ไม่ว่างเปล่า
  • 1 ≤ n ≤ 6มีเฉพาะค่าที่พอใจ
  • ไม่มีองค์ประกอบที่ซ้ำกัน
• คุณอาจไม่คิดว่าอินพุตถูกเรียงลำดับ
• การส่งของคุณควรให้คุณค่าที่เป็นความจริง / เป็นเท็จ : ความจริงคือใบหน้าสามารถมองเห็นได้ในเวลาเดียวกัน
• นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุด (เป็นไบต์) ชนะ!
• ช่องโหว่มาตรฐานจะถูกห้ามโดยค่าเริ่มต้น

กรณีทดสอบ

Truthy:

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

Falsy:

[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 ไบต์

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

ลองออนไลน์!

JavaScript (ES6),  38 34 30 29  28 ไบต์

รับอินพุตเป็นพารามิเตอร์แยกจำนวนเท่าใดก็ได้ ผลตอบแทนหรือ01

(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หรือเท็จ :

# 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

หมายเหตุ : ลำดับของ(a, b, c)ไม่สำคัญเพราะพวกเขาอยู่ด้วยกันเสมอ XOR

กรณีที่ยากที่สุดคือกรณีที่ 3 นี่คือตารางแสดงชุดค่าผสมที่เป็นไปได้ทั้งหมด:

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

รับอินพุตเป็นอาร์เรย์ ผลตอบแทนหรือ01

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

Haskell , 24 ไบต์

-3 ไบต์ขอบคุณ H.PWiz

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

APL (Dyalog) 7 ไบต์

~7∊∘.+⍨

ลองออนไลน์!

∘.+⍨ - ตารางเพิ่มเติม (ทุกองค์ประกอบที่มีทุกองค์ประกอบ)

7∊ - 7 อยู่แล้ว?

~ - ปฏิเสธ

APL (Dyalog) 7 ไบต์

⍬≡⊢∩7-⊢

ลองออนไลน์!

7-⊢ - ลบแต่ละองค์ประกอบจาก 7

⊢∩ - ตัดกับอาร์เรย์เดิม

⍬≡ - ว่างเปล่า

R , 27 ไบต์

ขอบคุณGregorสำหรับการแก้ไขข้อผิดพลาด

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

ลองออนไลน์!

ท่าเรือคำตอบ Chas ของบราวน์ การมีการดำเนินการแบบเวกเตอร์ช่วยทำให้เรื่องนี้สั้นลงมากในอาร์

Mathematica ขนาด 20 ไบต์

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

คือ\[Function]

-12 bytes จาก Martin Ender
-7 bytes จาก Misha Lavrov

ลองออนไลน์!

Haskell , 26 ไบต์

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

ลองออนไลน์!

Pyth , 5 ไบต์

!@-L7

ลองที่นี่

ที่จริงแล้ว 8 ไบต์

;∙♂Σ7@cY

ลองออนไลน์! (ดำเนินการกรณีทดสอบทั้งหมด)

คำอธิบาย:

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

Husk , 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.

เรติน่า21 21ไบต์

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ แก้ไข: บันทึก 1 ไบต์ขอบคุณ @MartinEnder คำอธิบาย:

O`.

จัดเรียงอินพุต

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

ตรวจสอบคู่ของด้านตรงข้าม (เรียง 3 และ 4 เรียงติดกัน) สิ่งนี้จะคืนค่า 1 สำหรับการตายที่ไม่ถูกต้องหรือ 0 สำหรับการตายที่ถูกต้อง

0

ลบล้างผลลัพธ์อย่างมีเหตุผล

เยลลี่ 5 ไบต์

7_f⁸Ṇ

ลองออนไลน์!

ท่าเรือ Chas บราวน์คำตอบ

คำอธิบาย

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

อลิซอายุ 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.

Pyth , 5 ไบต์

-7sM*

ชุดทดสอบ

isaacg บันทึกไบต์!

Ruby , 36 31 24 23 ไบต์

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

ลองออนไลน์!

มันง่ายมากฉันกำลังมองหาวิธีแก้ไขปัญหาที่ผิดตลอดเวลา

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

หนึ่งในหลายวิธีในการทำเช่นนี้ใน 5 ไบต์ใน 05AB1E

Perl 5 , 51 + 1 ( -a) = 52 ไบต์

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

ลองออนไลน์!

เรติน่า 20 ไบต์

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

ลองออนไลน์!

ทางเลือกของแนวทางของนีล

คำอธิบาย

T`_654`d

เลี้ยว6, 5, 4เข้า1, 2, 3ตามลำดับ

M`(.).*\1

พยายามค้นหาตัวละครซ้ำและนับจำนวนการแข่งขัน

0

ตรวจสอบให้แน่ใจว่าผลลัพธ์เป็นศูนย์ (ลบล้างตรรกะได้อย่างมีประสิทธิภาพ)

Java (OpenJDK 8) , 43 ไบต์

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

ลองออนไลน์!

รุ่น GNU , 37 22 + 1 = 23 ไบต์

+1 ไบต์สำหรับการ-rตั้งค่าสถานะ ใช้อินพุตเป็นตัวเลข พิมพ์อินพุตสำหรับความจริงและ0เป็นเท็จ

-10 ไบต์ขอบคุณ @MartinEnder

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

ลองออนไลน์!

คำอธิบาย

คล้ายกับ @ 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 ไบต์

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

ลองออนไลน์!

1 & 6 | 2 & 5 | 3 & 4คือจุดเชื่อมต่อที่ประกอบด้วยหมายเลข 1 และ 6 หรือหมายเลข 2 และ 5 หรือหมายเลข 3 และ 4 จุดเชื่อมต่อนี้เป็นองค์ประกอบของ ( ∈) รายการอินพุต*หากมี 1 และ 6 หรือ 2 และ 5 หรือ 3 และ 4. ผลลัพธ์นั้นจะถูกทำให้เป็นโมฆะ ( !) เพื่อรับค่าบูลีนที่ต้องการ

Haskell, 46 41 37 ไบต์

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

ใช้ผลิตภัณฑ์คาร์ทีเซียนของรายการด้วยตัวเองจากนั้นตรวจสอบว่ารายการผลลัพธ์ทั้งหมดไม่รวมเป็น 7 (ถ้ามีทั้งหมด 7 รายการจะมีใบหน้าที่ตรงข้ามกันและ "ทั้งหมดไม่" สั้นกว่า "ไม่ ใด ๆ ที่ทำ ".)

J , 12 ไบต์

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

นี่เป็นวิธีการแก้ปัญหา APL แรกโดย Uriel

ลองออนไลน์!

สูตร IBM / Lotus Notes ขนาด 7 ไบต์

!7-i*=i

รับอินพุตจากฟิลด์หมายเลขค่าหลายค่า i

ลบแต่ละค่าของฉันซ้ำจาก 7 และตรวจสอบเพื่อดูว่ามันอยู่ในรายการเดิม ! เปลี่ยน 1 หากเป็น 0 (ไม่สามารถเห็นใบหน้าทั้งหมดได้)

กรณีทดสอบ (ไม่มี TIO สำหรับสูตร Notes)

ทำความสะอาด , 49 ไบต์

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

ลองออนไลน์!

Swiftขนาด 46 ไบต์

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

รับอินพุตเป็น[Int](อาร์เรย์จำนวนเต็ม) และส่งคืน a Bool(บูลีน)

คำอธิบายสั้น ๆ (ungolfed)

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 ไบต์

-9 ไบต์เพราะฉันรู้ว่าการใช้reducedไม่จำเป็น

-8 ไบต์โดยเปลี่ยนจากการใช้reduceเป็นการใช้some

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

ฉันพยายามเขียนสิ่งนี้โดยไม่ดูเคล็ดลับอื่น ๆ ที่ใช้ ฉันอาจจะปรับปรุงได้ในภายหลัง

ส่งคืนtrueสำหรับกรณีจริงfalseถ้าด้านใด ๆ รวมเป็น 7 และ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])))))