甲西方传统模具是立方体，在其上的整数1至6被标记上的面。成对增加到7的对放置在相反的面上。

因为是立方体，所以在任何给定时间我们只能看到1到3个面（包括^1个）。不能同时看到相反的面孔。

您的任务是编写一个程序或函数，该程序或函数给出了表示模具上各边的整数列表，以确定是否有可能同时看到这些面。

¹_{好吧，也许您可以用双眼看到4到5张脸，但是出于这一挑战的目的，我们从一个点观察死角。}

规则：

您的提交可以采用输入列表：
- 是非空的。
- 仅包含满足的值1 ≤ n ≤ 6。
- 不包含重复的元素。
您可能不假定输入已排序。
您的提交应输出一个true / false的值：true是可以同时看到这些面孔的情况，否则为false。
这是代码高尔夫球，因此最短的答案（以字节为单位）获胜！
默认情况下，标准漏洞是禁止的。

测试用例

真相：

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

虚假：

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

code-golf decision-problem

— FlipTack
source

Python 2，35个字节

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

在线尝试！

— 查斯·布朗
source

5

-1字节在Python 3

— notjagan

14

JavaScript（ES6）， 38 34 30 29 28字节

将输入作为任意数量的单独参数。返回0或1。

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

测试用例

显示代码段

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

展开摘要

怎么样？

根据提供的参数数量，以下是主表达式的简化版本，未定义的变量被强制为0或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

注意：（a，b，c）的顺序无关紧要，因为它们总是异或在一起。

最棘手的情况是第三个。下表显示了所有可能的组合：

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。版本＃1，32字节

将输入作为数组。返回一个布尔值。

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

测试用例

显示代码段

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。版本＃2，Chrome / Firefox，34个字节

这滥用了Chrome和Firefox的排序方法。它不适用于Edge。

将输入作为数组。返回0或1。

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

测试用例

显示代码段

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

展开摘要

— Arnauld
source

8

Haskell，24个字节

-3个字节，感谢H.PWiz。

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

在线尝试！

说明

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

— 全人类
source

5

APL（Dyalog），7个字节

~7∊∘.+⍨

在线尝试！

∘.+⍨ -加法表（每个元素和每个元素）

7∊ -7存在吗？

~ -否定

APL（Dyalog），7个字节

⍬≡⊢∩7-⊢

在线尝试！

7-⊢ -从7中减去每个元素

⊢∩ -与原始数组相交

⍬≡ -空吗？

— 乌里尔
source

5

R，27个字节

感谢Gregor修复错误

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

在线尝试！

查斯布朗港的答案。进行向量化运算有助于使R的长度更短。

— 朱塞佩
source

我认为您需要一些旁观者(7-d)，其他d%in%d则优先。

— 格雷戈尔

@格雷戈尔，你是绝对正确的。

— 朱塞佩

4

Mathematica，20个字节

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

的是\[Function]

Martin Ender的-12个
字节Misha Lavrov的-7个字节

在线尝试！

— J42161217
source

3

Haskell，26个字节

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

在线尝试！

— 普维兹
source

3

Pyth，5个字节

!@-L7

在这里尝试。

— 暴民埃里克
source

我可以发誓，我在两分钟前尝试了一下，但没有成功……嗯，我想知道出了什么问题

— Xcoder先生17年

我想到的第一件事？沙地。

— maxathousand

3

实际上，8个字节

;∙♂Σ7@cY

在线尝试！（运行所有测试用例）

说明：

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

— 梅果
source

3

外壳，5个字节

Ëo≠7+

在线尝试！

说明

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

— 马丁·恩德
source

3

视网膜，21 20字节

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

在线尝试！链接包括测试用例。编辑：感谢@MartinEnder，节省了1个字节。说明：

O`.

对输入进行排序。

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

检查一对相对的侧面（3和4彼此相邻排序）。对于无效的骰子，返回1；对于有效的骰子，返回0。

逻辑上否定结果。

— 尼尔
source

2

果冻，5个字节

7_f⁸Ṇ

在线尝试！

查斯布朗港的答案。

说明

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

— 暴民埃里克
source

2

爱丽丝，18字节

/..y1nr@ 
\iReA6o/

在线尝试！

打印Jabberwocky有效输入，否则不打印任何内容。

说明

展开之字形控制流程，该程序实际上只是：

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.

— 马丁·恩德
source

2

Pyth，5个字节

-7sM*

测试套件。

isaacg保存了一个字节！

— Xcoder先生
source

2

红宝石，36 31 24 23字节

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

在线尝试！

如此简单，我一直在寻找解决错误问题的方法。

— 国标
source

1

05AB1E，5个字节

7αå_P

在线尝试！

说明

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

在05AB1E中以5个字节为单位执行此操作的几种方法之一

— 艾米尼亚
source

1

Perl 5，51 +1（`-a`）= 52字节

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

在线尝试！

— Xcali
source

3 1 4给出了真实的信息say 1>grep{$x=$_;grep$_+$x==7,@F}@F

— Nahuel Fouilleul

sed解决方案启发了25 + 1（-p）

— Nahuel Fouilleul

1

视网膜，20字节

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

在线尝试！

Neil方法的替代方法。

说明

T`_654`d

转6，5，4为1，2，3分别。

M`(.).*\1

尝试查找重复的字符并计算匹配数。

确保结果为零（实际上是逻辑否定）。

— 马丁·恩德
source

1

Java（OpenJDK 8），43字节

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

在线尝试！

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source

1

GNU sed的， 37 22 +1 = 23字节

+1个字节 -r标志。以数字作为输入；打印输入是真还是0假。

-10个字节感谢@MartinEnder。

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

在线尝试！

说明

类似于@MartinEnder的Alice答案。

y/123/654/   # Transliterate 1-3 to 6-4
/(.).*\1/c0  # If a digit appears twice, replace the pattern space with 0

— 约旦
source

它并不会完全打印出真实的输入，而是将输入1-3替换为6-4来打印输入。

— 安德鲁说莫妮卡（Monica）恢复职权

1

Perl 6、18个字节

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

在线尝试！

1 & 6 | 2 & 5 | 3 & 4是由数字1和6或数字2和5或数字3和4组成的结点。如果该结点包含1和6或2和5或3，则∈是输入列表（）的元素。*4.然后将结果取反（!），以获得所需的布尔值。

— 肖恩
source

0

Haskell，46 41 37字节

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

取列表本身的笛卡尔积，然后检查所有结果列表的总和是否不等于7。（如果它们的总和等于7，则可以看到相反的面，并且“全部不”比“不”短可以。”）

— 德拉科尼斯
source

0

J，12个字节

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

这几乎与Uriel的第一个APL解决方案相同

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

0

IBM / Lotus Notes公式，7个字节

!7-i*=i

从多值数字字段i中获取输入。

递归地从7中减去i的每个值，并检查它是否在原始列表中。！如果将1更改为0，则将其更改为1（不能全部看到面孔）。

测试用例（Notes Formula没有可用的TIO）

— 埃尔佩德罗
source

0

干净的 49字节

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

在线尝试！

— 巨大
source

1

@StephenLeppik我认为这个答案不一定使用文件名来存储信息。

— Steadybox

@StephenLeppik哦，很公平，这里需要导入，但是不需要在特定模块中声明该函数。谢谢。

— 2009年

0

迅捷，46字节

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

将输入作为[Int]（整数数组）并返回Bool（布尔值）。

简短说明（无酒精饮料）

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

— 赫尔曼·L
source

0

克洛瑞尔，89 80 72字节

-9个字节，因为我意识到使用 reduced不必要使用

从使用reduce改为使用-8个字节some

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

我试着写这篇文章而没有看其他答案使用的任何技巧。我稍后可能会对此进行改进。

如果任何边的总数为7，且边数非法true，false则返回真实情况nil。

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

— 致癌物质
source

可见的骰子脸

规则：

测试用例

Python 2，35个字节

JavaScript（ES6）， 38 34 30 29 28字节

测试用例

怎么样？

Alt。版本＃1，32字节

测试用例

Alt。版本＃2，Chrome / Firefox，34个字节

测试用例

Haskell，24个字节

说明

APL（Dyalog），7个字节

APL（Dyalog），7个字节

R，27个字节

Mathematica，20个字节

Haskell，26个字节

Pyth，5个字节

实际上，8个字节

外壳，5个字节

说明

视网膜，21 20字节

果冻，5个字节

说明

爱丽丝，18字节

说明

Pyth，5个字节

红宝石，36 31 24 23字节

05AB1E，5个字节

Perl 5，51 +1（-a）= 52字节

视网膜，20字节

说明

Java（OpenJDK 8），43字节

GNU sed的， 37 22 +1 = 23字节

说明

Perl 6、18个字节

Haskell，46 41 37字节

J，12个字节

IBM / Lotus Notes公式，7个字节

干净的 49字节

迅捷，46字节

简短说明（无酒精饮料）

克洛瑞尔，89 80 72字节

Perl 5，51 +1（`-a`）= 52字节