Un dé occidental traditionnel est un cube, sur lequel les entiers 1 à 6 sont marqués sur les faces. Les paires qui s'ajoutent à 7 sont placées sur des faces opposées.

Comme il s'agit d'un cube, nous ne pouvons voir qu'entre 1 et 3 faces (inclus) ¹ à un moment donné. Les visages opposés ne peuvent jamais être vus en même temps.

Votre tâche consiste à écrire un programme ou une fonction qui, à partir d'une liste d'entiers représentant les côtés d'un dé, détermine s'il est possible de voir ces faces en même temps.

¹ _{D'accord, vous pouvez peut-être voir 4 ou 5 visages avec une paire d'yeux, mais dans le cadre de ce défi, nous observons le dé à partir d'un seul point.}

Règles:

• Votre soumission peut supposer la liste d'entrée:
  • N'est pas vide.
  • Ne contient que des valeurs satisfaisantes 1 ≤ n ≤ 6.
  • Ne contient aucun élément en double.
• Vous ne pouvez pas supposer que l'entrée est triée.
• Votre soumission doit produire une valeur de vérité / fausse : la vérité est que les visages peuvent être vus en même temps, la fausse sinon.
• Il s'agit de code-golf , donc la réponse la plus courte (en octets) l'emporte!
• Les failles standard sont interdites par défaut.

Cas de test

Vérité:

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

Faux:

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

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

Essayez-le en ligne!

JavaScript (ES6),  38 34 30 29  28 octets

Prend l'entrée comme n'importe quel nombre de paramètres distincts. Renvoie 0ou 1.

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

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

Comment?

Vous trouverez ci-dessous des versions simplifiées de l'expression principale en fonction du nombre de paramètres fournis, les variables non définies étant contraintes à 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 : L'ordre de (a, b, c) n'a pas d'importance car ils sont toujours XOR ensemble.

Le cas le plus délicat est le 3ème. Voici un tableau montrant toutes les combinaisons possibles:

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. version # 1, 32 octets

Prend l'entrée comme un tableau. Renvoie un booléen.

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

Cas de 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. version # 2, Chrome / Firefox, 34 octets

Celui-ci abuse des méthodes de tri de Chrome et Firefox. Cela ne fonctionne pas avec Edge.

Prend l'entrée comme un tableau. Renvoie 0ou 1.

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

Cas de 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 octets

-3 octets grâce à H.PWiz.

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

Essayez-le en ligne!

Explication

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 octets

~7∊∘.+⍨

Essayez-le en ligne!

∘.+⍨ - table d'addition (chaque élément avec chaque élément)

7∊ - 7 existe?

~ - nier

APL (Dyalog) , 7 octets

⍬≡⊢∩7-⊢

Essayez-le en ligne!

7-⊢ - soustrayez chaque élément de 7

⊢∩ - intersecte avec le tableau d'origine

⍬≡ - vide?

R , 27 octets

merci à Gregor pour avoir corrigé un bug

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

Essayez-le en ligne!

Port de la réponse de Chas Brown . Le fait d'avoir des opérations vectorisées permet de raccourcir ce délai en R.

Mathematica, 20 octets

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

Le est\[Function]

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

Essayez-le en ligne!

Haskell , 26 octets

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

Essayez-le en ligne!

Pyth , 5 octets

!@-L7

Essayez-le ici.

En fait , 8 octets

;∙♂Σ7@cY

Essayez-le en ligne! (exécute tous les cas de test)

Explication:

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

Husk , 5 octets

Ëo≠7+

Essayez-le en ligne!

Explication

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

Rétine , 21 20 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Edit: 1 octet enregistré grâce à @MartinEnder. Explication:

O`.

Triez l'entrée.

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

Recherchez une paire de côtés opposés (tri 3 et 4 côte à côte). Cela renvoie 1 pour un dé invalide ou 0 pour un dé valide.

0

Niez logiquement le résultat.

Gelée , 5 octets

7_f⁸Ṇ

Essayez-le en ligne!

Port de la réponse de Chas Brown .

Explication

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

Alice , 18 octets

/..y1nr@ 
\iReA6o/

Essayez-le en ligne!

Imprime Jabberwockypour des entrées valides et rien d'autre.

Explication

Dépliant le flux de contrôle en zigzag, le programme est vraiment juste:

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 octets

-7sM*

Suite de tests.

isaacg a enregistré un octet!

Rubis , 36 31 24 23 octets

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

Essayez-le en ligne!

C'était si simple que je cherchais constamment la solution au mauvais problème.

05AB1E , 5 octets

7αå_P

Essayez-le en ligne!

Explication

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

Une des nombreuses façons de le faire en 5 octets dans 05AB1E

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

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

Essayez-le en ligne!

Rétine , 20 octets

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

Essayez-le en ligne!

Une alternative à l'approche de Neil.

Explication

T`_654`d

Tourner 6, 5, 4en 1, 2, 3respectivement.

M`(.).*\1

Essayez de trouver des caractères répétés et comptez le nombre de correspondances.

0

Assurez-vous que le résultat était nul (en fait une négation logique).

Java (OpenJDK 8) , 43 octets

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

Essayez-le en ligne!

GNU sed , 37 22 + 1 = 23 octets

+1 octet pour le -rdrapeau. Prend la saisie sous forme de chiffres; imprime l'entrée pour véridique et 0pour fausse.

-10 octets grâce à @MartinEnder.

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

Essayez-le en ligne!

Explication

Similaire à la réponse 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 octets

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

Essayez-le en ligne!

1 & 6 | 2 & 5 | 3 & 4est une jonction composée des nombres 1 et 6, OU des nombres 2 et 5, OU des nombres 3 et 4. Cette jonction est un élément de ( ∈) la liste d'entrée *si elle contient 1 et 6, ou 2 et 5, ou 3 et 4. Ce résultat est ensuite nié ( !) pour obtenir la valeur booléenne requise.

Haskell, 46 41 37 octets

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

Prend le produit cartésien de la liste avec lui-même, puis vérifie si toutes les listes résultantes ne totalisent pas 7. (Si l'une d'elles est additionnée à 7, les faces opposées seraient visibles et "toutes ne sont pas" est plus courte que "non tout faire ".)

J , 12 octets

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

C'est à peu près la même chose que la première solution APL d'Uriel

Essayez-le en ligne!

Formule IBM / Lotus Notes, 7 octets

!7-i*=i

Prend l'entrée d'un champ numérique à valeurs multiples i.

Soustrait récursivement chaque valeur de i de 7 et vérifie si elle se trouve dans la liste d'origine. ! change le 1 s'il est à 0 (les visages ne peuvent pas tous être vus).

Cas de test (pas de TIO disponible pour la formule Notes)

Nettoyer , 49 octets

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

Essayez-le en ligne!

Swift , 46 octets

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

Prend l'entrée comme [Int] (tableau d'entiers) et renvoie un Bool(booléen).

Brève explication (non golfée)

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 octets

-9 octets car j'ai réalisé que l'utilisation de reducedest inutile

-8 octets en passant de l'utilisation reduceà l'utilisationsome

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

J'ai essayé d'écrire ceci sans regarder les astuces utilisées par les autres réponses. Je pourrai peut-être améliorer cela plus tard.

Renvoie trueles cas réels, falsesi l'un nildes côtés est égal à 7 et si le nombre de côtés est illégal.

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