Традиційний західний штамп являє собою куб, на якому цілі числа від 1 до 6, відзначені на обличчях. Пари, що додають до 7, розміщуються на протилежних гранях.

Оскільки це куб, ми можемо бачити лише від 1 до 3 граней (включно) ¹ в будь-який момент часу. Протилежні обличчя не можна побачити одночасно.

Ваше завдання - написати програму або функцію, яка за списком цілих чисел, що представляють сторони на плашці, визначає, чи можна одночасно бачити ці обличчя.

¹ _{Гаразд, можливо, ви можете побачити 4 або 5 обличчя парами очей, але для цього завдання ми спостерігаємо матрицю з однієї точки.}

Правила:

• Ваше повідомлення може взяти на себе список введення:
  • Не порожній.
  • Тільки містить значення, які задовольняють 1 ≤ n ≤ 6.
  • Не містить дублюючих елементів.
• Ви можете не припускати, що вхід сортований.
• У вашій подачі повинно виходити значення truthy / falesy : truthy - це обличчя, які можна побачити одночасно, фальшиві в іншому випадку.
• Це код-гольф , тому найкоротша відповідь (у байтах) виграє!
• Стандартні лазівки за замовчуванням заборонені.

Випробування

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)

Фальсі:

[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 байт

Вводиться як будь-яка кількість окремих параметрів. Повертається 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 або хибних :

# 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.

Приймає дані як масив. Повертається 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]))

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 байт

дякую Грегору за виправлення помилки

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

Спробуйте в Інтернеті!

Відповідь Порта Часа Брауна . Векторизовані операції допомагають зробити це значно коротшим у Р.

Математика, 20 байт

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

The є\[Function]

-12 байт від Мартіна Ендера
-7 байт від Міші Лаврова

Спробуйте в Інтернеті!

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

Лушпиння , 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 20 байт

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⁸Ṇ

Спробуйте в Інтернеті!

Порт Час Брауна відповідь .

Пояснення

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 врятував байт!

Рубі , 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 sed , 37 22 + 1 = 23 байти

+1 байт для -rпрапора. Вводить дані як цифри; друкує вхід для truthy та 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.

Рекурсивно віднімає кожне значення i від 7 і перевіряє, чи є воно у вихідному списку. ! змінює 1, якщо він є на 0 (обличчя не видно всіх).

Випробувальні випадки (TIO для формули нотаток не доступний)

Чисто , 49 байт

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

Спробуйте в Інтернеті!

Swift, 46 bytes

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

Takes input as [Int] (integer array) and returns a Bool (boolean).

Коротке пояснення (невольф)

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 bytes

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