Ein traditioneller westlicher Würfel ist ein Würfel, bei dem die ganzen Zahlen 1 bis 6 auf den Flächen markiert sind. Paare, die zu 7 addieren, werden auf gegenüberliegenden Seiten platziert.

Da es sich um einen Würfel handelt, können wir jeweils nur zwischen 1 und 3 Flächen (einschließlich) ^{1 sehen} . Gegenüberliegende Gesichter sind niemals gleichzeitig zu sehen.

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die anhand einer Liste von Ganzzahlen, die Seiten auf einem Würfel darstellen, bestimmt, ob es möglich ist, diese Gesichter gleichzeitig zu sehen.

¹ _{Okay, vielleicht können Sie 4 oder 5 Gesichter mit zwei Augen sehen, aber zum Zweck dieser Herausforderung beobachten wir den Würfel von einem einzigen Punkt aus.}

Regeln:

• Ihr Beitrag kann die Eingabeliste annehmen:
  • Ist nicht leer.
  • Enthält nur Werte, die erfüllen 1 ≤ n ≤ 6.
  • Enthält keine doppelten Elemente.
• Sie können nicht davon ausgehen, dass die Eingabe sortiert ist.
• Ihr Beitrag sollte einen Wahrheits- / Falschwert ausgeben : Wahr ist, dass die Gesichter gleichzeitig zu sehen sind, ansonsten falsch.
• Das ist Code-Golf , also gewinnt die kürzeste Antwort (in Bytes)!
• Standardlücken sind standardmäßig verboten.

Testfälle

Wahrheit:

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

Falsch:

[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

Probieren Sie es online!

JavaScript (ES6),  38 34 30 29  28 Byte

Übernimmt die Eingabe als eine beliebige Anzahl separater Parameter. Rückgabe 0oder 1.

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

Testfälle

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

Wie?

Nachfolgend finden Sie vereinfachte Versionen des Hauptausdrucks gemäß der Anzahl der angegebenen Parameter, wobei undefinierte Variablen entweder auf 0 oder auf false erzwungen werden :

# 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 : Die Reihenfolge von (a, b, c) spielt keine Rolle, da sie immer zusammen XOR-verknüpft sind.

Der schwierigste Fall ist der dritte. Hier ist eine Tabelle mit allen möglichen Kombinationen:

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 Bytes

Übernimmt die Eingabe als Array. Gibt einen Booleschen Wert zurück.

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

Testfälle

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 Byte

Dieser missbraucht die Sortiermethoden von Chrome und Firefox. Bei Edge funktioniert das nicht.

Übernimmt die Eingabe als Array. Rückgabe 0oder 1.

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

Testfälle

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 dank H.PWiz.

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

∘.+⍨ - Additionstabelle (jedes Element mit jedem Element)

7∊ - 7 existiert?

~ - negieren

APL (Dyalog) , 7 Bytes

⍬≡⊢∩7-⊢

Probieren Sie es online!

7-⊢ - subtrahiere jedes Element von 7

⊢∩ - schneide mit dem ursprünglichen Array

⍬≡ - leer?

R , 27 Bytes

Vielen Dank an Gregor für die Fehlerbehebung

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

Probieren Sie es online!

Antwort von Port of Chas Brown . Vektorisierte Operationen helfen, dies in R viel kürzer zu machen.

Mathematica, 20 Bytes

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

Das ist\[Function]

-12 Bytes von Martin Ender
-7 Bytes von Misha Lavrov

Probieren Sie es online!

Haskell , 26 Bytes

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

Probieren Sie es online!

Pyth , 5 Bytes

!@-L7

Probieren Sie es hier aus.

Eigentlich 8 Bytes

;∙♂Σ7@cY

Probieren Sie es online! (führt alle Testfälle aus)

Erläuterung:

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

Schale , 5 Bytes

Ëo≠7+

Probieren Sie es online!

Erläuterung

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

Netzhaut , 21 bis 20 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Bearbeiten: 1 Byte dank @MartinEnder gespeichert. Erläuterung:

O`.

Sortieren Sie die Eingabe.

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

Suchen Sie nach zwei gegenüberliegenden Seiten (3 und 4 nebeneinander). Dies gibt 1 für einen ungültigen Würfel oder 0 für einen gültigen zurück.

0

Negieren Sie das Ergebnis logisch.

Gelee , 5 Bytes

7_f⁸Ṇ

Probieren Sie es online!

Antwort von Port of Chas Brown .

Erläuterung

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

Alice , 18 Bytes

/..y1nr@ 
\iReA6o/

Probieren Sie es online!

Druckt Jabberwockyfür gültige Eingaben und sonst nichts.

Erläuterung

Das Programm entfaltet den Zick-Zack-Kontrollfluss und ist wirklich einfach:

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*

Testsuite.

isaacg hat ein Byte gespeichert!

Ruby , 36 31 24 23 Bytes

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

Probieren Sie es online!

Es war so einfach, dass ich die ganze Zeit nach einer Lösung für das falsche Problem suchte.

05AB1E , 5 Bytes

7αå_P

Probieren Sie es online!

Erläuterung

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

Eine von mehreren Möglichkeiten, dies in 5 Bytes in 05AB1E zu tun

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

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

Probieren Sie es online!

Netzhaut , 20 Bytes

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

Probieren Sie es online!

Eine Alternative zu Neils Ansatz.

Erläuterung

T`_654`d

Drehen 6, 5, 4in 1, 2, 3, respectively.

M`(.).*\1

Versuchen Sie, wiederholte Zeichen zu finden und die Anzahl der Übereinstimmungen zu zählen.

0

Stellen Sie sicher, dass das Ergebnis Null ist (praktisch eine logische Negation).

Java (OpenJDK 8) , 43 Byte

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

Probieren Sie es online!

GNU sed , 37 22 + 1 = 23 Bytes

+1 Byte für -rFlag. Übernimmt die Eingabe als Ziffern; Gibt die Eingabe für wahr und 0falsch aus.

-10 Bytes dank @MartinEnder.

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

Probieren Sie es online!

Erläuterung

Ähnlich wie bei @ MartinEnder Alice Antwort .

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

Probieren Sie es online!

1 & 6 | 2 & 5 | 3 & 4ist eine Junction bestehend aus den Nummern 1 und 6 ODER den Nummern 2 und 5 ODER den Nummern 3 und 4. Diese Junction ist ein Element von ( ∈) der Eingabeliste, *wenn sie 1 und 6 oder 2 und 5 oder 3 enthält und 4. Dieses Ergebnis wird dann negiert ( !), um den erforderlichen Booleschen Wert zu erhalten.

Haskell, 46 41 37 Bytes

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

Nimmt das kartesische Produkt der Liste mit sich und prüft, ob alle resultierenden Listen nicht 7 ergeben irgendwelche tun ".)

J , 12 Bytes

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

Dies ist so ziemlich das Gleiche wie die erste APL-Lösung von Uriel

Probieren Sie es online!

IBM / Lotus Notes-Formel, 7 Byte

!7-i*=i

Übernimmt die Eingabe von einem mehrwertigen Zahlenfeld i.

Subtrahiert rekursiv jeden Wert von i von 7 und prüft, ob er in der ursprünglichen Liste enthalten ist. ! Ändert die 1, wenn sie eine 0 ist (Gesichter können nicht alle gesehen werden).

Testfälle (kein TIO für Notes Formula verfügbar)

Sauber , 49 Bytes

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

Probieren Sie es online!

Schnell , 46 Bytes

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

Übernimmt die Eingabe als [Int](Integer-Array) und gibt einen Bool(Booleschen Wert) zurück.

Kurze Erklärung (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, weil mir klar wurde, dass die Verwendung von reducedunnötig ist

-8 Bytes durch Ändern von using reducezu usingsome

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

Ich habe versucht, dies zu schreiben, ohne auf die Tricks zu achten, die andere Antworten verwenden. Vielleicht kann ich das später verbessern.

Gibt truefür echte Fälle zurück, falsewenn eine Seite 7 nilergibt und die Anzahl der Seiten ungültig ist.

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