Un dado occidental tradicional es un cubo, en el cual los enteros 1 a 6 están marcados en las caras. Los pares que suman 7 se colocan en caras opuestas.

Como es un cubo, solo podemos ver entre 1 y 3 caras (inclusive) ¹ en un momento dado. Las caras opuestas nunca se pueden ver al mismo tiempo.

Su tarea es escribir un programa o función que, dada una lista de enteros que representan lados en un dado, determina si es posible ver estas caras al mismo tiempo.

¹ _{Bien, tal vez puedas ver 4 o 5 caras con un par de ojos, pero a los efectos de este desafío, observamos el dado desde un solo punto.}

Reglas:

• Su envío puede asumir la lista de entrada:
  • No está vacío
  • Solo contiene valores que satisfacen 1 ≤ n ≤ 6.
  • No contiene elementos duplicados.
• Es posible que no asumir que la entrada está ordenada.
• Su presentación debe generar un valor de verdad / falsedad : la verdad es que las caras se pueden ver al mismo tiempo, de lo contrario, la falsedad se puede ver.
• Este es el código de golf , por lo que gana la respuesta más corta (en bytes).
• Las lagunas estándar están prohibidas por defecto.

Casos de prueba

Verdad:

[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

Pruébalo en línea!

JavaScript (ES6),  38 34 30 29  28 bytes

Toma datos como cualquier número de parámetros separados. Devoluciones 0o 1.

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

Casos de prueba

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

¿Cómo?

A continuación se muestran versiones simplificadas de la expresión principal de acuerdo con el número de parámetros proporcionados, las variables indefinidas se convierten en 0 o falsas :

# 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 : El orden de (a, b, c) no importa porque siempre están XOR'd juntos.

El caso más complicado es el tercero. Aquí hay una tabla que muestra todas las combinaciones posibles:

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. versión # 1, 32 bytes

Toma la entrada como una matriz. Devuelve un booleano.

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

Casos de prueba

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. versión # 2, Chrome / Firefox, 34 bytes

Éste abusa de los métodos de clasificación de Chrome y Firefox. No funciona con Edge.

Toma la entrada como una matriz. Devoluciones 0o 1.

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

Casos de prueba

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 gracias a H.PWiz.

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

Pruébalo en línea!

Explicación

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∊∘.+⍨

Pruébalo en línea!

∘.+⍨ - tabla de suma (cada elemento con cada elemento)

7∊ - 7 existe?

~ - negar

APL (Dyalog) , 7 bytes

⍬≡⊢∩7-⊢

Pruébalo en línea!

7-⊢ - restar cada elemento de 7

⊢∩ - se cruza con la matriz original

⍬≡ - vacio?

R , 27 bytes

gracias a Gregor por arreglar un error

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

Pruébalo en línea!

La respuesta del puerto de Chas Brown . Tener operaciones vectorizadas ayuda a hacer esto mucho más corto en R.

Mathematica, 20 bytes

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

El es\[Function]

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

Pruébalo en línea!

Haskell , 26 bytes

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

Pruébalo en línea!

Pyth , 5 bytes

!@-L7

Pruébalo aquí

En realidad , 8 bytes

;∙♂Σ7@cY

Pruébalo en línea! (ejecuta todos los casos de prueba)

Explicación:

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

Casco , 5 bytes

Ëo≠7+

Pruébalo en línea!

Explicación

Ë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

Pruébalo en línea! El enlace incluye casos de prueba. Editar: Guardado 1 byte gracias a @MartinEnder. Explicación:

O`.

Ordenar la entrada.

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

Verifique un par de lados opuestos (3 y 4 ordenados uno al lado del otro) Esto devuelve 1 para un dado no válido o 0 para uno válido.

0

Negar lógicamente el resultado.

Jalea , 5 bytes

7_f⁸Ṇ

Pruébalo en línea!

La respuesta del puerto de Chas Brown .

Explicación

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

Alice , 18 bytes

/..y1nr@ 
\iReA6o/

Pruébalo en línea!

Imprime Jabberwockyentradas válidas y nada más.

Explicación

Al desplegar el flujo de control en zigzag, el programa es realmente justo:

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 bytes

-7sM*

Banco de pruebas.

isaacg guardó un byte!

Ruby , 36 31 24 23 bytes

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

Pruébalo en línea!

Era tan simple que buscaba la solución al problema incorrecto todo el tiempo.

05AB1E , 5 bytes

7αå_P

Pruébalo en línea!

Explicación

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

Una de varias formas de hacer esto en 5 bytes en 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

Pruébalo en línea!

Retina , 20 bytes

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

Pruébalo en línea!

Una alternativa al enfoque de Neil.

Explicación

T`_654`d

Girar 6, 5, 4en 1, 2, 3, respectivamente.

M`(.).*\1

Intenta encontrar personajes repetidos y cuenta el número de coincidencias.

0

Asegúrese de que el resultado sea cero (efectivamente, una negación lógica).

Java (OpenJDK 8) , 43 bytes

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

Pruébalo en línea!

GNU sed , 37 22 + 1 = 23 bytes

+1 byte para -rbandera. Toma la entrada como dígitos; imprime la entrada para verdad y 0para falsedad.

-10 bytes gracias a @MartinEnder.

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

Pruébalo en línea!

Explicación

Similar a la respuesta de Alice de @ 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∈*)

Pruébalo en línea!

1 & 6 | 2 & 5 | 3 & 4es una unión que consta de los números 1 y 6, O los números 2 y 5, O los números 3 y 4. Esta unión es un elemento de ( ∈) la lista de entrada *si contiene 1 y 6, o 2 y 5, o 3 y 4. Ese resultado se niega ( !) para obtener el valor booleano requerido.

Haskell, 46 41 37 bytes

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

Toma el producto cartesiano de la lista consigo mismo, luego verifica si todas las listas resultantes no suman 7. (Si alguna sumara 7, las caras opuestas serían visibles y "no todos" es más corto que "no cualquiera hacer ".)

J , 12 bytes

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

Esto es más o menos lo mismo que la primera solución APL de Uriel

Pruébalo en línea!

Fórmula IBM / Lotus Notes, 7 bytes

!7-i*=i

Toma datos de un campo de número de valores múltiples i.

Resta recursivamente cada valor de i de 7 y verifica si está en la lista original. ! cambia el 1 si está en 0 (no se pueden ver todas las caras).

Casos de prueba (no hay TIO disponible para Notes Formula)

Limpio , 49 bytes

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

Pruébalo en línea!

Rápido , 46 bytes

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

Toma la entrada como [Int](matriz entera) y devuelve un Bool(booleano).

Explicación corta (sin golf)

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 porque me di cuenta de que el uso de reducedes innecesario

-8 bytes cambiando de usar reducea usarsome

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

Traté de escribir esto sin mirar ninguno de los trucos que usan otras respuestas. Tal vez pueda mejorar esto más adelante.

Devuelve truepara casos verdaderos, falsesi alguno de los lados suma 7, y nilsi el número de lados es ilegal.

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