编写程序，确定一个周期为正的整数序列是否具有以下性质：对于n该序列中出现的每个整数，n两次连续出现之间没有比其他整数多的整数了n。

例如，2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...确实具有此属性：的每对连续出现2在它们之间最多具有两个整数（例如2, 3, 5, 2和2, 3, 6, 2；每对的连续出现3在彼此之间最多具有三个整数；对于5和相同6。

但是，2, 3, 5, 2, 3, 4, 2, 3, 5, 2, 3, 4, ...它不具有此属性：的两个连续出现4，即4, 2, 3, 5, 2, 3, 4之间有四个以上的整数。

输入：正整数周期序列的合理表示。例如，诸如的有限列表{2, 3, 5, 2, 3, 6}可以代表2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...上面的第一个无限序列。（为此，对于环绕的有限列表而不是无限的周期性列表，可以提出问题。）

输出：真/假值。

真实的例子：

{1}
{8, 9}
{2, 3, 4}
{5, 5, 3, 3, 6}
{2, 3, 5, 2, 3, 6}
{6, 7, 3, 5, 3, 7}
{9, 4, 6, 7, 4, 5}
{1, 1, 1, 1, 1, 100, 1}
{1, 9, 1, 8, 1, 7, 1, 11}

虚假的例子：

{1, 2, 3}
{2, 3, 9, 5}
{3, 5, 4, 4, 6}
{2, 3, 5, 2, 3, 4}
{3, 5, 7, 5, 9, 3, 7}
{5, 6, 7, 8, 9, 10, 11}
{1, 9, 1, 8, 1, 6, 1, 11}

这是codegolf，所以最短的代码获胜。鼓励以所有语言回答。

哈斯克尔， 60 57 56 55字节

f(a:b)=b==[]||length(fst$span(/=a)b)<=a&&f b
g x=f$x++x

假设输入列表包含至少一个元素。

用法示例：g [1]-> True。在线尝试！

让它a成为列表的开头和b结尾。结果为Trueif b为空或开头b不等于的元素数a不大于a且f b还对is 进行递归调用Trueelse False。从两次输入列表开始。

编辑：@Leo保存3个字节。谢谢！

编辑2：@Laikoni保存了1个字节。谢谢！

Python，57 56字节

得益于Dennis，为-1个字节（替换i+1:i+v+2为i:i-~v，i偏移量为1 enumerate）

lambda a:all(v in(a+a)[i:i-~v]for i,v in enumerate(a,1))

在线尝试！

无名功能服用的列表，a和测试每个值，条件v，出现in在的级联相关片在其右侧a，与本身(a+a)[i:i-~v]，其中的基于1的索引v中a，i是通过提供enumerate(a,1)。

JavaScript（ES6），67 65 55 54 51 49字节

@ETHproductions节省了3B，@ Arnauld节省了2B

a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

说明

这定义了一个将数组a作为输入的函数。然后，该.some方法遍历该数组，对每个元素执行另一个函数。

此内部函数采用两个参数，b和c，当前值及其索引。该函数从index开始查找当前值的索引c + 1。然后，它检查此索引是否大于当前值加上当前索引（两次出现的相同值之间的差大于b）。请注意，这返回与我们想要的完全相反的结果。

如果这些返回值之一是true，该.some函数true也会返回。如果没有任何检查返回true，则.some函数返回false。再次与我们要返回的值相反，因此求反，然后返回。

测试一下

在这里尝试所有测试用例：

let f=
a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

let truthy = [[1], [8, 9], [2, 3, 4], [5, 5, 3, 3, 6], [2, 3, 5, 2, 3, 6], [6, 7, 3, 5, 3, 7], [9, 4, 6, 7, 4, 5], [1, 1, 1, 1, 1, 100, 1], [1, 9, 1, 8, 1, 7, 1, 11]];
let falsy  = [[1, 2, 3], [2, 3, 9, 5], [3, 5, 4, 4, 6], [2, 3, 5, 2, 3, 4], [3, 5, 7, 5, 9, 3, 7], [5, 6, 7, 8, 9, 10, 11], [1, 9, 1, 8, 1, 6, 1, 11]];

console.log("Truthy test cases:");
for (let test of truthy) {
    console.log(`${test}: ${f(test)}`);
}

console.log("Falsy test cases:");
for (let test of falsy) {
    console.log(`${test}: ${f(test)}`);
}

果冻，11字节

ṣZL
;çЀ<‘P

在线尝试！

怎么运行的

;çЀ<‘P  Main link. Argument: A (array)

;        Concatenate A with itself.
 çD€     For each n in A, call the helper with left arg. A + A and right arg. n.
     ‘   Increment all integers in A.
    <    Perform element-wise comparison of the results to both sides.
      P  Take the product of the resulting Booleans.


ṣZL      Helper link. Left argument: A. Right argument: n

ṣ        Split A at all occurrences of n.
 Z       Zip to transpose rows and columns.
  L      Length; yield the number of rows, which is equal to the number of columns
         of the input to Z.

果冻，8字节

ṙJḣ"‘Œpċ

受@JonathanAllan 的Python答案的影响。

在线尝试！

怎么运行的

ṙJḣ"‘Œpċ  Main link. Argument: A (array)

 J        Yield the indicies of A, i.e., [1, ..., len(A)].
ṙ         Rotate; yield A, rotated 1, ..., and len(A) units rotated to the left.
    ‘     Increment; add 1 to all elements of A.
  ḣ"      Head zipwith; truncate the n-th rotation to length A[n]+1.
     Œp   Take the Cartesian product of all resulting truncated rotations.
       ċ  Count the number of times A appears in the result.

SWI-Prolog，83个字节

a(L,[H|R]):-nth0(X,R,H),H>=X,a(L,R);length(R,N),nth0(X,L,H),H>=N+X,a(L,R).
a(_,[]).

该列表应输入两次：

a([1,2,3],[1,2,3]).

如果认为不可接受，则可以添加谓词

a(L):-a(L,L).

这会增加14个字节。

在线尝试

nb：您可以通过用';'分隔查询来一次测试不同的错误情况。（或），并以'，'（和）分隔以测试不同的真实情况

即，使用OP示例：

a([1],[1]),
a([8, 9],[8, 9]),
a([2, 3, 4],[2, 3, 4]),
a([5, 5, 3, 3, 6],[5, 5, 3, 3, 6]),
a([2, 3, 5, 2, 3, 6],[2, 3, 5, 2, 3, 6]),
a([6, 7, 3, 5, 3, 7],[6, 7, 3, 5, 3, 7]),
a([9, 4, 6, 7, 4, 5],[9, 4, 6, 7, 4, 5]),
a([1, 1, 1, 1, 1, 100, 1],[1, 1, 1, 1, 1, 100, 1]),
a([1, 9, 1, 8, 1, 7, 1, 11],[1, 9, 1, 8, 1, 7, 1, 11]).

和

a([1, 2, 3],[1, 2, 3]);
a([2, 3, 9, 5],[2, 3, 9, 5]);
a([3, 5, 4, 4, 6],[3, 5, 4, 4, 6]);
a([2, 3, 5, 2, 3, 4],[2, 3, 5, 2, 3, 4]);
a([3, 5, 7, 5, 9, 3, 7],[3, 5, 7, 5, 9, 3, 7]);
a([5, 6, 7, 8, 9, 10, 11],[5, 6, 7, 8, 9, 10, 11]);
a([1, 9, 1, 8, 1, 6, 1, 11],[1, 9, 1, 8, 1, 6, 1, 11]).

PHP，52字节

for(;$n=$argv[++$i];$$n=$i)!$$n|$i-$$n<$n+2?:die(1);

从命令行参数获取顺序；用代码退出1显示伪造，0真实的。
用运行-nr。

• 循环$n通过参数：
  • 如果以前没有发生过或者最近发生过
    则什么也不做，否则退出并退出代码1
  • 记住以前在$$n（变数）中出现的情况
• 用代码退出0（隐式）

视网膜，50字节

$
,$`
M!&`\b(1+),.*?\b\1\b
+%`(^1*)1,1+
$1
M`1,
^0

输入以逗号分隔的一进制数字列表。

在线尝试！

说明

$
,$`

复制输入，以便我们检查结束的步骤。

M!&`\b(1+),.*?\b\1\b

匹配并返回两个相同值之间的每个（最短）部分，例如11,111,1,11。

+%`(^1*)1,1+
$1

反复从第一个数字中删除一个数字，以及其后的一个整数。如果间隙足够小，则将完全删除第一个数字。否则，将至少保留一位数字。

M`1,

计算1,所有行中出现的频率。如果它出现在任何地方，则步骤之一太宽。

^0

尝试匹配一个以0（即0本身）开头的数字。这实际上是对输出的逻辑取反。

JavaScript（ES6），47个字节

a=>![...a,...a].some((n,i)=>a[-n]-(a[-n]=i)<~n)

怎么运行的

我们重新使用输入数组a将每个整数最后一次遇到的位置存储在中a。我们使用键-n来存储此位置，以便它不会干扰的原始索引a。

如果a[-n]存在，则进行实际测试。当a[-n]不存在时，表达式a[-n] - (a[-n] = i)等于，undefined - i == NaN并且与的比较~n始终为假，这是预期的结果。

测试用例

f=
a=>![...a,...a].some((n,i)=>a[-n]-(a[-n]=i)<~n)

console.log('Truthy cases:');
console.log(f([1]));
console.log(f([8, 9]));
console.log(f([2, 3, 4]));
console.log(f([5, 5, 3, 3, 6]));
console.log(f([2, 3, 5, 2, 3, 6]));
console.log(f([6, 7, 3, 5, 3, 7]));
console.log(f([9, 4, 6, 7, 4, 5]));
console.log(f([1, 1, 1, 1, 1, 100, 1]));
console.log(f([1, 9, 1, 8, 1, 7, 1, 11]));

console.log('Falsy cases:');
console.log(f([1, 2, 3]));
console.log(f([2, 3, 9, 5]));
console.log(f([3, 5, 4, 4, 6]));
console.log(f([2, 3, 5, 2, 3, 4]));
console.log(f([3, 5, 7, 5, 9, 3, 7]));
console.log(f([5, 6, 7, 8, 9, 10, 11]));
console.log(f([1, 9, 1, 8, 1, 6, 1, 11]));

视网膜， 41 39字节

2个字节golfed感谢马丁·安德，它的方式向我介绍了平衡组，他在如此美妙指南

$
,$`,
((1)+,)(?=(?<-2>1+,)*(\1|$))

^$

输入是用逗号分隔的一进制数字列表。输出0为false和1true。

在线尝试！（自动从十进制转换的测试套件）

我最近了解了平衡组，因此想尝试一下。它们不是最容易使用的工具，但是请确保它们功能强大。

说明

$
,$`,

与其他许多提交一样，我们复制了列表以处理包装。我们还在末尾添加了一个逗号，因此每个数字后面都带有一个逗号（这使以后的工作变得容易一些）

((1)+,)(?=(?<-2>1+,)*(\1|$))

这是有趣的地方。这是替换阶段，我们将第一行匹配的所有内容替换为第二行，在这种情况下，我们希望删除所有数字，n然后是n+1其他不同的数字。

为此，我们首先匹配数字，将每个数字都捕获1到一个组中（在这种情况下，捕获组2）。然后使用正向的前瞻性，为了具有零宽度的断言，我们反复尝试在一个平衡组中进行匹配，该匹配-2将不超过group捕获2的次数，后跟逗号的次数。在这个数字序列之后，我们很满意再次到达第一个数字或行尾。

注意：如果无法找到与完整数字匹配的内容，则该表达式可能仅与数字的最后部分匹配。这不是问题，因为数字的第一部分将保留在字符串中，并且我们知道替换未完全成功。

^$

最后，如果我们已从列表中完全删除所有数字，则结果应该是真实的。我们尝试匹配空字符串并返回找到的匹配数。

果冻，11字节

ẋ2ĠṢI_2<"QȦ

在线尝试！

ẋ2ĠṢI_2<"QȦ  Main link. Argument: A (array)

ẋ2           Repeat A twice to account for wrap-around.
  Ġ          Group all indices of A + A by their respective values, sorting the
             index groups by the associated values.
   Ṣ         Sort the groups lexicographically, i.e., by first appearance in A.
    I        Increments; compute the forward differences of adjacent indices in
             each of the groups.
     _2      Subtract 2 from the differences.
         Q   Unique; yield A, deduplicated.
       <"    Compare all differences in the index group corresponding to the n-th
             unique value in A with the n-th unqiue value in A.
          Ȧ  All; yield 1 if and only if none of the comparisons returned 0.

Python 3，101字节

lambda l:all(v>=(l[i+1:].index(v)if v in l[i+1:]else len(l[i+1:])+l.index(v))for i,v in enumerate(l))

在线尝试！

Röda，50个字节

f a{seq 0,#a-1|[indexOf(a[_],a[_1+1:]..a)<=a[_1]]}

在线尝试！

最后！我一直在等待 了这一挑战？

它是一个返回真实值或虚假值的函数。它需要一个参数，即数组。

循环访问索引流，并检查每个索引_1，确保当前索引与下一个索引之间的a[_1]距离不大于a[_1]。

05AB1E，13个字节

Dì©v®¦©yky›_P

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

说明

Dì             # duplicate input and prepend the copy to the original
  ©            # store a copy in the register
   v           # for each element in the list
    ®          # push the list from register
     ¦©        # remove the first element and store a copy in the register
       yk      # get the index of the current element in the list
         y›_   # check if it's less than or equal to the current element
            P  # product of stack