Um dado ocidental tradicional é um cubo, no qual os números inteiros 1 a 6 são marcados nas faces. Pares que somam 7 são colocados em faces opostas.

Como é um cubo, só podemos ver entre 1 e 3 faces (inclusive) ¹ a qualquer momento. Rostos opostos nunca podem ser vistos ao mesmo tempo.

Sua tarefa é escrever um programa ou função que, dada uma lista de números inteiros representando os lados de um dado, determine se é possível ver esses rostos ao mesmo tempo.

¹ _{Ok, talvez você possa ver 4 ou 5 rostos com um par de olhos, mas, para o propósito desse desafio, observamos o dado a partir de um único ponto.}

Regras:

• Seu envio pode assumir a lista de entrada:
  • Não está vazio.
  • Contém apenas valores que satisfazem 1 ≤ n ≤ 6.
  • Não contém elementos duplicados.
• Você não pode assumir que a entrada está classificada.
• Seu envio deve gerar um valor de verdade / falsidade : verdade é que os rostos podem ser vistos ao mesmo tempo, caso contrário, falso.
• Isso é código-golfe , então a resposta mais curta (em bytes) vence!
• As brechas padrão são proibidas por padrão.

Casos de teste

Verdade:

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

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

Experimente online!

JavaScript (ES6),  38 34 30 29  28 bytes

Recebe a entrada como qualquer número de parâmetros separados. Retorna 0ou 1.

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

Casos de teste

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

Quão?

Abaixo estão as versões simplificadas da expressão principal de acordo com o número de parâmetros fornecidos, variáveis ​​indefinidas sendo coagidas a 0 ou 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 ordem de (a, b, c) não importa, porque eles sempre estão juntos no XOR.

O caso mais complicado é o terceiro. Aqui está uma tabela mostrando todas as combinações possíveis:

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. versão 1, 32 bytes

Recebe entrada como uma matriz. Retorna um booleano.

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

Casos de teste

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. versão 2, Chrome / Firefox, 34 bytes

Este abusa dos métodos de classificação do Chrome e Firefox. Não funciona com o Edge.

Recebe entrada como uma matriz. Retorna 0ou 1.

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

Casos de teste

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 bytes

-3 bytes graças a H.PWiz.

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

Experimente online!

Explicação

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 bytes

~7∊∘.+⍨

Experimente online!

∘.+⍨ - tabela de adição (cada elemento com cada elemento)

7∊ - 7 existe?

~ - negar

APL (Dyalog) , 7 bytes

⍬≡⊢∩7-⊢

Experimente online!

7-⊢ - subtraia cada elemento de 7

⊢∩ - cruzar com a matriz original

⍬≡ vazio?

R , 27 bytes

graças a Gregor por corrigir um erro

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

Experimente online!

Resposta do porto de Chas Brown . Ter operações vetorizadas ajuda a tornar isso muito mais curto em R.

Mathematica, 20 bytes

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

O é\[Function]

-12 bytes de Martin Ender
-7 bytes de Misha Lavrov

Experimente online!

Haskell , 26 bytes

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

Experimente online!

Pitão , 5 bytes

!@-L7

Experimente aqui.

Na verdade , 8 bytes

;∙♂Σ7@cY

Experimente online!(executa todos os casos de teste)

Explicação:

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

Casca , 5 bytes

Ëo≠7+

Experimente online!

Explicação

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

Retina , 21 20 bytes

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

Experimente online! O link inclui casos de teste. Editar: salvou 1 byte graças a @MartinEnder. Explicação:

O`.

Classifique a entrada.

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

Verifique se há um par de lados opostos (3 e 4 ordenados um ao lado do outro). Isso retorna 1 para um dado inválido ou 0 para um dado válido.

0

Negue logicamente o resultado.

Gelatina , 5 bytes

7_f⁸Ṇ

Experimente online!

Resposta do porto de Chas Brown .

Explicação

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

Alice , 18 bytes

/..y1nr@ 
\iReA6o/

Experimente online!

Impressões Jabberwocky para entradas válidas e nada mais.

Explicação

Desdobrando o fluxo de controle em zigue-zague, o programa é realmente apenas:

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.

Pitão , 5 bytes

-7sM*

Suíte de teste.

isaacg salvou um byte!

Ruby , 36 31 24 23 bytes

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

Experimente online!

Era tão simples que eu procurava a solução para o problema errado o tempo todo.

05AB1E , 5 bytes

7αå_P

Experimente online!

Explicação

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

Uma das várias maneiras de fazer isso em 5 bytes em 05AB1E

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

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

Experimente online!

Retina , 20 bytes

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

Experimente online!

Uma alternativa à abordagem de Neil.

Explicação

T`_654`d

Vire 6, 5, 4para 1, 2, 3, respectivamente.

M`(.).*\1

Tente encontrar caracteres repetidos e conte o número de correspondências.

0

Verifique se o resultado foi zero (efetivamente uma negação lógica).

Java (OpenJDK 8) , 43 bytes

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

Experimente online!

GNU sed , 37 22 + 1 = 23 bytes

+1 byte para -rsinalizador. Recebe a entrada como dígitos; imprime a entrada para verdade e 0falsidade.

-10 bytes graças a @MartinEnder.

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

Experimente online!

Explicação

Semelhante à resposta de Alice do @ 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 bytes

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

Experimente online!

1 & 6 | 2 & 5 | 3 & 4é uma junção que consiste nos números 1 e 6, OU nos números 2 e 5, OU nos números 3 e 4. Essa junção é um elemento da ( ∈) lista de entrada *se ela contiver 1 e 6, ou 2 e 5 ou 3 e 4. Esse resultado é negado ( !) para obter o valor booleano necessário.

Haskell, 46 41 37 bytes

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

Leva consigo o produto cartesiano da lista e verifica se todas as listas resultantes não somam 7. (Se alguma delas somava 7, faces opostas seriam visíveis e "nem tudo é" é menor que "não"). any do ".)

J , 12 bytes

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

This is pretty much the same as the first APL solution by Uriel

Try it online!

IBM/Lotus Notes Formula, 7 bytes

!7-i*=i

Takes input from a multi-value number field i.

Recursively subtracts each value of i from 7 and checks to see if it is in the original list. ! changes the 1 if it is to a 0 (faces cannot all be seen).

Test Cases (no TIO available for Notes Formula)

Clean, 49 bytes

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

Try it online!

Swift, 46 bytes

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

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

Short Explanation (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 bytes

-9 bytes because I realized use of reduced is unnecessary

-8 bytes by changing from using reduce to using some

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

I tried writing this without looking at any of the tricks other answers use. I may be able to improve on this later.

Returns true for true cases, false if any sides sum to 7, and nil if the number of sides is illegal.

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