Un dado occidentale tradizionale è un cubo, sul quale gli interi da 1 a 6 sono segnati sulle facce. Le coppie che aggiungono a 7 vengono posizionate su facce opposte.

Dato che è un cubo, possiamo vedere solo tra 1 e 3 facce (incluso) ¹ in qualsiasi momento. I volti opposti non possono mai essere visti contemporaneamente.

Il tuo compito è quello di scrivere un programma o una funzione che, dato un elenco di numeri interi che rappresentano i lati di un dado, determina se è possibile vedere queste facce contemporaneamente.

¹ _{Va bene, forse puoi vedere 4 o 5 facce con un paio di occhi, ma ai fini di questa sfida osserviamo il dado da un unico punto.}

Regole:

• Il tuo invio può assumere l'elenco di input:
  • Non è vuoto
  • Contiene solo valori che soddisfano 1 ≤ n ≤ 6.
  • Non contiene elementi duplicati.
• Si può non supporre che l'ingresso è ordinato.
• La tua presentazione dovrebbe produrre un valore di verità / falsità : la verità è che i volti possono essere visti allo stesso tempo, falsi altrimenti.
• Questo è code-golf , quindi vince la risposta più breve (in byte)!
• Le scappatoie standard sono vietate per impostazione predefinita.

Casi test

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 byte

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

Provalo online!

JavaScript (ES6),  38 34 30 29  28 byte

Accetta input come qualsiasi numero di parametri separati. Restituisce 0o 1.

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

Casi test

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

Come?

Di seguito sono riportate le versioni semplificate dell'espressione principale in base al numero di parametri forniti, le variabili non definite vengono forzate su 0 o 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 : L'ordine di (a, b, c) non importa perché sono sempre XOR messi insieme.

Il caso più difficile è il terzo. Ecco una tabella che mostra tutte le possibili combinazioni:

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. versione # 1, 32 byte

Accetta input come un array. Restituisce un valore booleano.

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

Casi test

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. versione # 2, Chrome / Firefox, 34 byte

Questo abusa dei metodi di ordinamento di Chrome e Firefox. Non funziona con Edge.

Accetta input come un array. Restituisce 0o 1.

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

Casi test

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

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

Provalo online!

Spiegazione

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

Provalo online!

∘.+⍨ - tabella addizioni (ogni elemento con ogni elemento)

7∊ - 7 esiste?

~ - negare

APL (Dyalog) , 7 byte

⍬≡⊢∩7-⊢

Provalo online!

7-⊢ - sottrai ogni elemento da 7

⊢∩ - si intersecano con l'array originale

⍬≡ - vuoto?

R , 27 byte

grazie a Gregor per aver corretto un bug

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

Provalo online!

La risposta di Port of Chas Brown . Avere operazioni vettorizzate aiuta a rendere questo molto più breve in R.

Mathematica, 20 byte

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

Lo è\[Function]

-12 byte da Martin Ender
-7 byte da Misha Lavrov

Provalo online!

Haskell , 26 byte

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

Provalo online!

Pyth , 5 byte

!@-L7

Provalo qui.

In realtà , 8 byte

;∙♂Σ7@cY

Provalo online! (esegue tutti i casi di test)

Spiegazione:

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

Buccia , 5 byte

Ëo≠7+

Provalo online!

Spiegazione

Ë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 byte

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

Provalo online! Il link include casi di test. Modifica: salvato 1 byte grazie a @MartinEnder. Spiegazione:

O`.

Ordina l'ingresso.

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

Verificare la presenza di una coppia di lati opposti (3 e 4 in ordine uno accanto all'altro). Questo restituisce 1 per un dado non valido o 0 per un dado valido.

0

Annullare logicamente il risultato.

Gelatina , 5 byte

7_f⁸Ṇ

Provalo online!

La risposta di Port of Chas Brown .

Spiegazione

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

Alice , 18 byte

/..y1nr@ 
\iReA6o/

Provalo online!

Stampa Jabberwockyper input validi e nient'altro.

Spiegazione

Spiegando il flusso di controllo a zigzag, il programma è davvero solo:

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 byte

-7sM*

Suite di test.

isaacg ha salvato un byte!

Rubino , 36 31 24 23 byte

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

Provalo online!

Era così semplice, cercavo sempre la soluzione al problema sbagliato.

05AB1E , 5 byte

7αå_P

Provalo online!

Spiegazione

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

Uno dei diversi modi per farlo in 5 byte in 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

Provalo online!

Retina , 20 byte

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

Provalo online!

Un'alternativa all'approccio di Neil.

Spiegazione

T`_654`d

Girare 6, 5, 4in 1, 2, 3rispettivamente.

M`(.).*\1

Prova a trovare personaggi ripetuti e conta il numero di corrispondenze.

0

Assicurati che il risultato sia zero (effettivamente una negazione logica).

Java (OpenJDK 8) , 43 byte

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

Provalo online!

GNU sed , 37 22 + 1 = 23 byte

+1 byte per -rflag. Accetta input come cifre; stampa l'input per verità e 0falsità.

-10 byte grazie a @MartinEnder.

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

Provalo online!

Spiegazione

Simile alla risposta Alice di @ 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∈*)

Provalo online!

1 & 6 | 2 & 5 | 3 & 4è una giunzione costituita dai numeri 1 e 6, O dai numeri 2 e 5, O dai numeri 3 e 4. Questa giunzione è un elemento di ( ∈) l'elenco di input *se contiene 1 e 6, oppure 2 e 5, o 3 e 4. Tale risultato viene quindi negato ( !) per ottenere il valore booleano richiesto.

Haskell, 46 41 37 byte

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

Porta il prodotto cartesiano dell'elenco con se stesso, quindi controlla se tutti gli elenchi risultanti non si sommano a 7. (Se qualcuno di loro fosse sommato a 7, le facce opposte sarebbero visibili e "non tutti" è più corto di "no any do ".)

J , 12 byte

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

Questo è praticamente lo stesso della prima soluzione APL di Uriel

Provalo online!

Formula IBM / Lotus Notes, 7 byte

!7-i*=i

Riceve input da un campo numerico a più valori i.

Sottrae ricorsivamente ogni valore di i da 7 e verifica se è nell'elenco originale. ! cambia 1 se è a 0 (non è possibile vedere tutti i volti).

Casi di test (nessun TIO disponibile per la Formula Notes)

Pulito , 49 byte

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

Provalo online!

Rapido , 46 byte

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

Prende l'input come [Int](array intero) e restituisce un Bool(booleano).

Breve spiegazione (non golfizzato)

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 perché ho capito che l'uso di reducednon è necessario

-8 byte cambiando dall'uso reduceall'utilizzosome

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

Ho provato a scrivere questo senza guardare nessuno dei trucchi utilizzati da altre risposte. Potrei essere in grado di migliorare su questo in seguito.

Restituisce trueper casi veri, falsese una delle parti è pari a 7 e nilse il numero di parti è illegale.

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