差不多六年前，老乡PPCG成员steenslag 发布以下挑战：

在标准骰子（骰子）中，数字的排列方式是使相对的面数增加到七个。用您喜欢的语言编写尽可能最短的程序，该程序输出一个随机抛出，然后输出9个随机小费。翻斗是骰子的四分之一转，例如，如果骰子面向5，则所有可能的翻斗都是1,3,4和6。

所需输出示例：

1532131356

因此，既然每个人都完全忘记了它，并且获胜的答案早已被接受，我们将编写一个程序来验证由提交的解决方案生成的模具翻转序列。（这很有道理。假装确实如此。）

挑战

系统会为您的程序或函数 指定一个序列，例如1532131356。验证每个连续数字为：

• 不等于前一位
• 不等于7减去前一位数字

（您不必验证第一位数字。）

规则

• 如果输入有效，则程序必须返回真实值，否则返回假值。
• 您可以假设输入仅包含1-6位数字，并且至少包含1个字符。序列不会像Steenslag的挑战那样具有固定的长度。
• 您可以将输入作为字符串（"324324"），数组或类似数组的数据结构（[1,3,5]）或多个参数（yourFunction(1,2,4)）。

_{标准I / O和漏洞规则适用。}

测试用例

特鲁西

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

虚假

• 重复数字

  11
  3132124225
  6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
  553141454631
  14265411
  

• 模具的相对面

  16
  42123523545426464236231321
  61362462636351
  62362462636361
  

Python 2，43 45字节

lambda s:reduce(lambda p,n:n*(7-p!=n!=p>0),s)

43个字节（受@Zgarb强烈启发）

lambda s:reduce(lambda p,n:n*(p>0<n^p<7),s)

此函数将我的reduce语句与@Zgarb的答案中的位轻拂逻辑结合在一起，两者的组合要短于两者。

这两个答案都输出以下内容：

• 如果输入不是有效序列，则为0
• 序列的最后一位（如果有效）

Python，44个字节

lambda x:all(0<a^b<7for a,b in zip(x,x[1:]))

按位魔术！这是一个匿名函数，它接收一个整数列表，并检查每两个连续元素的XOR是否在1到6之间（含1和6）。

为什么有效

首先，XOR始终介于0到7之间（包括7和2），因为111我们的数字最多有3个二进制数字。为了平等，a^b == 0当且仅当a == b。同样，我们有7-a == 7^awhen 0 ≤ a ≤ 7，因此a^b == 7只有且仅当a == 7^b == 7-b。

05AB1E，11 9字节

-2字节代表Osable使用产品的明智想法。

¥¹D7-Á+«P

在线尝试！

¥           # Push deltas.
 ¹D7-Á      # Push original array, and 7 - [Array] shifted right once.
      +     # Add original to the 7 - [Array] shifted right.
       «    # Concat both.
        P   # Product, if either contain a zero, results in 0, meaning false.

使用05AB1E的第三种方法不使用pairwise命令：

• 0 如果它违反了Tipsy属性。
• Not 0 如果没有什么阻止它变得棘手。

R，39 37 32 31字节

all(q<-diff(x<-scan()),2*x+q-7)

在线尝试！

接受来自stdin的输入。用于diff查看两个连续的数字是否相同；然后将每个数字与7减去前一个数字进行比较。返回TRUE或FALSE。

感谢Jarko Dubbeldam，节省了5个字节，感谢JayCe，节省了5个字节。

05AB1E，10个字节

$ü+7ʹüÊ*P

使用CP-1252编码。在线尝试！

R，49 44字节

!any(rle(x<-scan())$l-1,ts(x)==7-lag(ts(x)))

从stdin读取输入（以空格分隔）并输出TRUE/FALSE。如果输入的长度为一，但仍然有效，则会发出警告。

编辑：由于@rturnbull而节省了几个字节

05AB1E，15个字节

ü+7å¹ü-0å¹g_~~_

在线尝试！或作为测试套件

JavaScript（ES6），43个 40字节

返回0/ true。

f=([k,...a],n=0)=>!k||k-n&&7-k-n&&f(a,k)

测试用例

f=([k,...a],n=0)=>!k||k-n&&7-k-n&&f(a,k)

console.log('Testing truthy cases ...');
console.log(f('1353531414'));
console.log(f('3132124215'));
console.log(f('4142124136'));
console.log(f('46'));
console.log(f('4264626313135414154'));
console.log(f('6'));
console.log(f('2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323'));
console.log(f('5414142'));

console.log('Testing falsy cases ...');
console.log(f('11'));
console.log(f('3132124225'));
console.log(f('6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245'));
console.log(f('553141454631'));
console.log(f('14265411'));
console.log(f('16'));
console.log(f('42123523545426464236231321'));
console.log(f('61362462636351'));
console.log(f('62362462636361'));

Perl 6，22个字节

使用正则表达式：

{!/(.)<{"$0|"~7-$0}>/}

将输入作为字符串。受GB的Ruby答案启发。
怎么运行的：

• / /：正则表达式。
• (.)：匹配任何字符，并将其捕获为 $0。
• <{ }>：动态生成要在该位置匹配的子正则表达式。
• "$0|" ~ (7 - $0)：我们生成的子正则表达式仅与前一个数字匹配，或者是7减去前一个数字（例如5|2）。
  因此，如果它在任何地方找到无效的连续数字对，则整个正则表达式将匹配。
• {! }：强制转换为布尔值（使regex与进行匹配$_），将其取反，然后将整个内容转换为lambda（具有隐式参数$_）。

Perl 6、38个字节

使用列表处理：

{all ([!=] 7-.[1],|$_ for .[1..*]Z$_)}

将输入作为整数数组。
怎么运行的：

• .[1..*] Z $_：将输入列表与自身的一个偏移量版本压缩在一起，以生成一个由2个元组组成的连续数字的列表。
• [!=] 7 - .[1], |$_：对于每一个，请检查是否(7 - b) != a != b。
• all ( )：根据所有循环迭代是否返回True，返回真实或虚假值。

Python，38个字节

f=lambda h,*t:t==()or 7>h^t[0]>0<f(*t)

带有参数的递归函数f(1,2,3)。

这利用参数解压缩将第一个数字提取h到元组中，并将其余的数字提取到元组中t。如果t为空，则输出True。否则，请使用Zgarb的小技巧来检查前两个压模辊是否不兼容。然后，检查结果是否也保留在尾部的递归调用上。

Ruby，34个字节

->s{!s[/[16]{2}|[25]{2}|[34]{2}/]}

JavaScript 61 43字节

评论提到我在不包含using语句的情况下不能使用C＃linq函数，因此使用标准JS的字节数更少，这是完全相同的...

f=a=>a.reduce((i,j)=>i>6|i==j|i+j==7?9:j)<7

C＃，99 67 65字节

将输入作为int数组 a

// new solution using linq
bool A(int[]a){return a.Aggregate((i,j)=>i>6|i==j|i+j==7?9:j)<7;}

// old solution using for loop
bool A(int[]a){for(int i=1;i<a.Length;)if(a[i]==a[i-1]|a[i-1]+a[i++]==7)return false;return true;}

说明：

// method that returns a boolean taking an integer array as a parameter
bool A(int[] a) 
{
    // aggregate loops over a collection, 
    // returning the output of the lambda 
    // as the first argument of the next iteration
    return a.Aggregate((i, j) => i > 6 // if the first arg (i) > than 6
    | i == j      // or i and j match
    | i + j == 7  // or i + j = 7
    ? 9   // return 9 as the output (and therefore the next i value)
    : j   // otherwise return j as the output (and therefore the next i value)
    ) 
    // if the output is ever set to 9 then it will be carried through to the end
    < 7; // return the output is less than 7 (not 9)
}

> <>（鱼）47字节

0:i:1+?!v\!
   0n;n1< >
!?-{:-"0"/^
!? -{-$7:/^

很简单；

第1行：检查是否输入了数字，如果没有输入数字（EOF），则需要打印其他信息。

第2行：打印结果。

第3行：将输入转换为数字（ASCII 0-输入），然后检查其是否等于先前的输入。

第4行：检查输入是否在芯片的另一侧。

脑筋急躁 128字节

(()){{}(({}<>)<>[({})])}{}([]){{{}}<>}{}([]){{}({}({})<>)<>([][()])}{}(<{}>)<>(([])){{}{}({}[(()()()){}()]){<>}<>([][()])}({}{})

输出0表示错误，或-7表示真实。

在线尝试！（真心）
在线试用！（蓬松）

说明（t代表顶部，s代表顶部第二）：

(())                # push a 1 to get this loop started
{{}                 # loop through all pairs, or until 2 are equal
(({}<>)<>[({})])    # pop t, push t on the other stack, and t - s on this one
}{}                 # end loop and pop one more time
([])                # push the height of the stack
{                   # if the height isn't 0 (there were equal numbers)...
{{}}<>              # pop everything from this stack and switch
}                   # end if
{{}                 # for every pair on the stack: pop the height and...
({}({})<>)<>        # push t + s on the other stack leaving s on this one
([][()])            # push the height - 1
}                   # end loop when there is only 1 number left
{}(<{}>)<>          # pop t, pop s, push 0 and switch stacks
(([]))              # push the height twice
{                   # loop through every pair
{}{}                # pop the height and what was t - 7
({}[(()()()){}()])  # push t - 7
{<>}<>              # if t is not 0 switch stacks and come come back
                    # if t is 0 (ie, there was a pair that added to 7) just switch once
([][()])            # push height - 1
}                   # end loop
({}{})              # push t + s (either 0 + 0 or 0 + -7)

MATLAB，30个字节

@(a)all(diff(a)&movsum(a,2)-7)

PHP，63字节

for($d=$argv[$i=1];$c=$argv[++$i];$d=$c)$d-$c&&$d+$c-7?:die(1);

将输入作为命令参数列表；1如果输入无效，则以（错误）退出；0如果有效，则以（确定）退出。

用运行-nr。

输入为字符串参数，65个字节

for($d=($s=$argv[1])[0];$c=$s[++$i];$d=$c)$d-$c&&$d+$c-7?:die(1);

PowerShell，57 44 41字节

_{（划掉的44仍然是常规的44）}

0-notin($args|%{7-$_-$l-and$l-ne($l=$_)})

在线尝试！

（OP明确指出，将输入作为单独的参数是可以的-保存13个字节...通过消除来保存另外3个字节$b）

我们一次循环输入$args一个数字。每个数字，我们都验证$last数字等于当前数字-not ，并且它是除零以外的某个数字（这是事实）。这些布尔结果封装在parens中，并馈入运算符的右侧操作数，并对照进行检查。换句话说，如果循环中任何地方都有任何值，则也会为。该布尔值保留在管道上，并且输出是隐式的。e$_7-$_-$l-notin0False-notinFalse

由于$需要变量名，-ne -and因此冗长，并且在PowerShell 中布尔命令是冗长的。那好吧。

加工，93 92 90字节

更改 || 为 | ：感谢@ClaytonRamsey，节省了1个字节

开始倒数：感谢@IsmaelMiguel，节省了2个字节

int b(int[]s){for(int i=s.length;--i>0;)if(s[i-1]==s[i]|s[i-1]==7-s[i])return 0;return 1;}

将输入作为一个整数数组，将输出1作为true或0 false进行。

不打高尔夫球

int Q104044(int[]s){
  for(int i=s.length;--i>0;)
    if(s[i-1]==s[i]|s[i-1]==7-s[i])
      return 0;
  return 1;
}

C 47 44字节

F(char*s){return!s[1]||(*s^s[1])%7&&F(s+1);}

接受一串数字（或零终止的字节数组）

说明

F(char*s){

根据标准int返回类型是隐含的。（节省4个字节）

return 无条件返回，因为这是递归函数

使用快捷方式评估：

!s[1]||如果第二个字符为nul，则返回true

((*s^s[1])%7&& 如果前两个字符不是合法错误

F(s+1)) 以相同的方式检查字符串的其余部分

令人困惑的表情

*s是第一个字符s[1]是第二个字符

*s^s[1] 如果它们相同，则将它们“异或”在一起，如果将它们加到7，则结果为0，结果是7；（如果它们不同并且不加到7，则结果在1到6之间（包括两者））

所以(*s^s[1])%7对于错误的输入为零，否则为非零，因此如果这两个字符不好则为false，否则为true

注释： 由于此函数调用仅使用结束递归（只有最后一条语句是递归调用），因此优化程序可以将递归转换为循环，这是一个令人鼓舞的信心，显然不值得任何高尔夫成绩，但实际上使处理任何长度的字符串而不会耗尽堆栈成为可能。

Python，71个字节

f=lambda s:len(s)<2or(s[0]!=s[1]and int(s[0])!=7-int(s[1]))and f(s[1:])

使用递归方法。

说明：

f=lambda s:                                                              # Define a function which takes an argument, s
           len(s)<2 or                                                   # Return True if s is just one character
                      (s[0]!=s[1]                                        # If the first two characters matches or...
                                 and int(s[0])!=7-int(s[1])              # the first character is 7 - the next character, then return False
                                                           )and f(s[1:]) # Else, recurse with s without the first character

视网膜，28字节

M`(.)\1|16|25|34|43|52|61
^0

在线尝试！

或者：

M`[16]{2}|[25]{2}|[34]{2}
^0

在线尝试！

MATL，9个字节

dG2YCs7-h

输入是代表数字的数字数组。

输出是一个非空数组，如果其所有条目都不为零，则为true，否则为false（在此处阅读有关MATL的true和falsy标准的更多信息）。

在线尝试！或验证所有测试用例。

说明

d     % Take input implicitly. Consecutive differences
G     % Push input again
2YC   % Overlapping blocks of length 2, arranged as columns of a matrix
s     % Sum of each column
7-    % Subtract 7, element-wise
h     % Concatenate horizontally. Implicitly display

C＃（使用Linq）90 81 73 71 69 68字节

using System.Linq;n=>n.Aggregate((p,c)=>p<9|c==p|c==103-p?'\b':c)>9;

说明：

using System.Linq;           //Obligatory import
n=>n.Aggregate((p,c)=>       //p serves as both previous character in chain and error flag
    p<9                      //8 is the error flag, if true input is already invalid            
        |c==p            
            |c==103-p        //103 comes from 55(7) + 48(0)
                ?'\b'       //'\b' because it has a single digit code (8)
                    :c)      //valid so set previous character, this catches the first digit case as well
                        >8;  //as long as the output char is not a backspace input is valid

C，81字节，是85字节

int F(int *A,int L){int s=1;while(--L)s&=A[L]!=A[L-1]&A[L]!=(7-A[L-1]);return s;}

输入是长度为L的整数A的数组。返回1表示true，0表示false。使用输入长度L作为数组索引，从头到尾检查输入。

Haskell，37个字节

f(a:b:c)=a+b/=7&&a/=b&&f(b:c)
f _=1<2

用法示例：f [1,5,2]-> False。

简单递归。基本情况：单元素列表，返回True。递归的情况：让a和b成为输入列表的前两个元素，c其余两个元素。必须满足以下所有条件：和a+b/=7，a/=b并且递归调用已a删除。

JavaScript，40个字节

f=i=>i.reduce((a,b)=>a&&a-b&&a+b-7&&b,9)

利用JavaScript功能，该功能&&将返回已解析的最后一个值（错误项或最后一项）。0如果不符合条件，则传递，否则传递前一个术语。9确保它以真实值开头。

Groovy，61个字节

{i=0;!(true in it.tail().collect{x->x in [7-it[i],it[i++]]})}

Python 2，58字节

lambda x:all(x[i]!=x[i+1]!=7-x[i]for i in range(len(x)-1))

> <>，39个字节

0>i'0'-::&0)?v1n;>&!
?=0+=7+@=}:{:<;n0^

在线尝试！

批处理，102字节

@set s=%1
@set/an=0%s:~0,2%,r=n%%9*(n%%7)
@if %r%==0 exit/b
@if %n% gtr 6 %0 %s:~1%
@echo 1

取消高尔夫：

@echo off
rem grab the input string
set s=%1
:loop
rem convert the first two digits as octal
set /a n = 0%s:~0,2%
rem check for divisibility by 9 (011...066)
set /a r = n %% 9
rem exit with no (falsy) output if no remainder
if %r% == 0 exit/b
rem check for divisibility by 7 (016...061)
set /a r = n %% 7
rem exit with no (falsy) output if no remainder
if %r% == 0 exit/b
rem remove first digit
set s=%s:~1%
rem loop back if there were at least two digits
if %n% gtr 6 goto loop
rem truthy output
echo 1