交替阵列

一个交替阵列是其中两个（不一定不同）值交替的任何长度的列表。也就是说，所有偶数索引项都相等，所有奇数索引项都相等。

您的任务是编写一个程序或函数，当给出正整数列表时，如果该程序或函数truthy是交替的，falsy则输出/返回。

这是代码高尔夫球，因此最短的代码（以字节为单位）获胜！

边缘案例：

[]      ->  True
[1]     ->  True
[1,1]   ->  True
[1,2,1] ->  True

其他测试用例：

[1,2,1,2]      -> True
[3,4,3]        -> True
[10,5,10,5,10] -> True
[10,11]        -> True
[9,9,9,9,9]    -> True

[5,4,3,5,4,3]   -> False
[3,2,1,2,1,2]   -> False
[1,2,1,2,1,1,2] -> False
[2,2,3,3]       -> False
[2,3,3,2]       -> False

例

这是一个示例，您可以使用Python 3（非高尔夫版）编写的代码来测试您的解决方案：

def is_alternating(array):
    for i in range(len(array)):
        if array[i] != array[i%2]:
            return False
    return True

果冻，4字节

ḣ2ṁ⁼

在线尝试！

这个怎么运作

ḣ2ṁ⁼  Main link. Argument: A (array)

ḣ2    Head 2; truncate A after its second element. If A has two or less elements,
      this returns A itself.
  ṁ   Mold; cyclically repeat the elements of the previous result to create an
      array that has the same shape/length as A.
   ⁼  Test the result for equality with A.

Brainfuck，34个字节

,>,>+>,
[
  [<+<<->>>-]
  +<[-<<]
  >[>]
  ,
]
<.

将数组作为字符串中的字节值，并输出\x00false和\x01true。

在线尝试。

这样可以保持结构

a b 1 c

在磁带上，只要数组是交替的c，当前字符在哪里，b它是前一个字符，a也是前一个前一个字符。如果发现不匹配，指针移动到左边，从而a，b和1标志全部变为零，而这种情况将一直持续到所有输入被消耗。

R，24 23字节

all((a=scan())==a[1:2])

将向量读入STDIN，获取该向量的前两个元素，然后检查相等性。如果和的长度a[1:2]不匹配，R将循环通过a[1:2]以匹配a的长度。这样做会发出警告，但是会起作用。

令人惊讶的是，这甚至适用于空输入，不确定为什么，但是我会继续讲下去。

@MickyT节省了1个字节

MATL，7 6字节

2YCs&=

对于交替数组，这会输出一个非空的1矩阵，这是事实。对于非交替数组，矩阵至少包含一个零，因此是虚假的（请参见此处）。

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

说明

让我们以[1 2 1 2]输入为例。

2YC   % Implicit input. Build matrix whose columns are overlapping blocks of 
      % length 2. If input has size less than 2 this gives an empty array
      % STACK: [1 2 1;
                2 1 2]
s     % Sum of each column. For an empty array this gives 0
      % STACK: [3 3 3]
&=    % Matrix of all pairwise equality comparisons. Implicit display
      % STACK: [1 1 1;
                1 1 1;
                1 1 1]

JavaScript（ES6），27个字节

a=>!a.some((v,i)=>a[i&1]-v)

测试用例

let f =

a=>!a.some((v,i)=>a[i&1]-v)

console.log(f([]));              // -> True
console.log(f([1]));             // -> True
console.log(f([1,1]));           // -> True
console.log(f([1,2,1]));         // -> True
console.log(f([1,2,1,2]));       // -> True
console.log(f([10,5,10,5,10]));  // -> True
console.log(f([10,11]));         // -> True
console.log(f([9,9,9,9,9]));     // -> True
console.log(f([5,4,3,5,4,3]));   // -> False
console.log(f([3,2,1,2,1,2]));   // -> False
console.log(f([1,2,1,2,1,1,2])); // -> False
console.log(f([2,2,3,3]));       // -> False
console.log(f([2,3,3,2]));       // -> False

视网膜，25字节

M`\b(\d+),\d+,(?!\1\b)
^0

在线尝试！

代替具有交替的值相匹配的输入的（这会导致在一个正则表达式的一些烦人的边缘效应），我匹配输入不是有效的，则事后否定的结果。

匹配无效输入的好处在于，这是一个属性，可以在本地检查，并且不需要专门处理空输入或短输入：如果任何输入包含两个相距一个位置的不同值，则该输入无效。

因此，第一阶段对匹配的数目进行计数，\b(\d+),\d+,(?!\1\b)并捕获一个值，然后匹配下一个值，然后断言顺序中的第三个值是不同的。对于有效输入，此值为零；对于无效值，其值为正。

第二阶段只计算匹配的数量的^0是1，如果第一阶段的恢复0和1其他。

Mathematica，29个字节

#=={}||Equal@@(Most@#+Rest@#)&

Luis Mendo的MATL算法的端口。未命名函数采用数字（或什至是更通用的对象）列表并返回True或False。测试连续元素的总和是否相等。不幸的是Most，Rest在空列表上cho了一下，因此必须单独进行测试。

Mathematica，33个字节

Differences[#,1,2]~MatchQ~{0...}&

未命名函数采用数字（或什至是更通用的对象）列表并返回True或False。该函数Differences[#,1,2]获取的差值不是连续的整数对，而是相距两个距离的整数对。然后我们只检查结果列表中是否只有零。

另外，再增加一个字节（将更2改为#2），我们得到了一个函数，该函数输入一个整数列表和另一个正整数#2，并检查输入列表是否是#2周期性地对常数序列进行交错的结果。例如，

Differences[#,1,#2]~MatchQ~{0...}&[{1,2,3,4,5,1,2,3,4,5,1,2},5]

评估为True。

Haskell，27 26字节

and.(zipWith(==)=<<drop 2)

这将评估为可解决挑战的匿名函数。想法是从列表中删除前两个数字，使用相等性压缩原始列表，然后检查结果是否仅包含Trues。 在线尝试！

感谢nimi 1个字节！

视网膜，39 32 28字节

^(\d*)((,\d+)(,\1(\3|$))*)?$

在线尝试！

感谢Martin，节省了7个字节！多亏Kobi保存了3个！然后向Kritixi提出另一个想法。

我们可以选择匹配一个占用整个输入的数字，任意一对数字或任意一对数字，然后在同一对数字之后匹配任意次，并且可以选择不包含第二个数字。如果输入为一元，则可以节省2个字节。

Pyth，9个字节

q<*<Q2lQl

说明

q<*<Q2lQlQQ   Implicitly add enough Qs to make the code run

   <Q2        Take the first two elements of the input
  *   lQ      Repeat those len(input) times
 <      lQ    Take the first len(input) elements
q         Q   Check if those are equal to the input

Brachylog，15个字节

:{~c#Tbh#Co}f#=

在线尝试！

说明

:{         }f       Find all results of the predicate below
             #=     They must all be equal

  ~c#T              Deconcatenate the input into three lists
      bh#C          The middle list has two elements
        #Co         Order that couple of elements as the output

APL，7个字节

⊢≡⍴⍴2⍴⊢

说明：

• 2⍴⊢：将输入数组重塑2
• ⍴⍴：按照输入的原始大小重塑结果，并重复元素
• ⊢≡：查看结果是否等于原始输入

测试用例：

      true←(1 2 1 2)(10 5 10 5 10)(10 11)(9 9 9 9 9)
      false←(5 4 3 5 4 3)(3 2 1 2 1 2)(1 2 1 2 1 1 2)(2 2 3 3)(2 3 3 2)
      ( ⊢≡⍴⍴2⍴⊢ ) ¨ true
1 1 1 1
      ( ⊢≡⍴⍴2⍴⊢ ) ¨ false
0 0 0 0 0

Java 8，63字节

i->{int r=0,x=1;for(;++x<i.length;)r|=i[x]-i[x-2];return r==0;}

这是一个 Predicate< int[ ] >

说明：将结果初始化为0。对于每个元素，将结果与当前元素和较早的元素2标记之间的差异进行Biteise或。返回true如果结果等于0。否则返回false

Perl 6的， 49个43  42字节

{!grep {![==] @_},roundrobin |.rotor: 2,:partial}

试试吧

{!.grep: ->\a,\b=$_[1] {sum .[0,1]Z!==a,b}}

试试吧

{!.grep: ->\a,\b=.[1] {sum .[0,1]Z!==a,b}}

试试吧

展开：

{
  !              # invert

  .grep:         # find any mismatches

  ->
    \a,
    \b = .[1]   # optional second parameter with default of second value from input
  {
    sum          # count up the values that don't match

    .[ 0, 1 ]    # the first two values from the input
    Z[![==]]     # zip not equal
    a, b         # the current two values under test.
  }
}

Python 2，35个字节

lambda x:(x[:2]*len(x))[:len(x)]==x

在线尝试！

J，8个字节

-:$$2&{.

说明

-:$$2&{.  input: (y)
    2&{.  the first two elements of y
   $      shaped like
  $       the shape of y
-:        and check if they match

测试用例

   f =: -:$$2&{.
   ]true =: '' ; 1 ; 1 1 ; 1 2 1 ; 1 2 1 2 ; 10 5 10 5 10 ; 10 11 ; 9 9 9 9 9
++-+---+-----+-------+------------+-----+---------+
||1|1 1|1 2 1|1 2 1 2|10 5 10 5 10|10 11|9 9 9 9 9|
++-+---+-----+-------+------------+-----+---------+
   f each true
+-+-+-+-+-+-+-+-+
|1|1|1|1|1|1|1|1|
+-+-+-+-+-+-+-+-+
   ]false =: 5 4 3 5 4 3 ; 3 2 1 2 1 2 ; 1 2 1 2 1 1 2 ; 2 2 3 3 ; 2 3 3 2
+-----------+-----------+-------------+-------+-------+
|5 4 3 5 4 3|3 2 1 2 1 2|1 2 1 2 1 1 2|2 2 3 3|2 3 3 2|
+-----------+-----------+-------------+-------+-------+
   f each false
+-+-+-+-+-+
|0|0|0|0|0|
+-+-+-+-+-+

Haskell，33 32字节

f(a:x@(_:b:_))=a==b&&f x
f a=1<3

在线尝试！或验证测试用例。-1个字节感谢Zgarb。

bash，56 54 38字节

[ -z $3 ]||((($1==$3))&&(shift;$0 $*))

将其保存为脚本，然后将数字列表作为参数传递（对于n元素列表，将传递n个参数）。输出为退出​​代码：如果列表是交替的，则为0（代表true），否则为1（代表false）。

（PPCG标准I / O方法允许以退出代码返回输出。）

这是递归的：

• 如果列表中的元素少于3个，则以返回代码0退出；否则，返回0。
• 否则，如果第一个元素！=第三个元素，则返回返回码1；
• 否则，在删除第一个元素的情况下在列表上递归运行程序。

Python 2.7，38个字节

>> i=lambda a:(a[:2]*len(a))[0:len(a)]==a

测试用例：

>> print i([1,2,1,2])
>> True
>> print i([10,5,10,5,10]
>> True
>> print i([5,4,3,5,4,3])
>> False
>> print i([3,2,1,2,1,2])
>> False

Pyke，6字节，无竞争

2<Ql{q

在这里尝试！

2<     -   inp[:2]
    {  -  reshape(^, v)
  Ql   -   len(inp)
     q - ^ == inp

允许重塑节点获取列表以及字符串

深圳IO（汇编程序），83 76字节，无竞争

Shenio io是一款益智游戏，您可以在其中使用特殊的汇编语言编写代码。

不幸的是，您只能使用-999到999之间的整数作为输入或输出，并且无法判断数组是否已结束。因此，我认为该阵列写在一个ROM上，该ROM在读取最后一个单元格后便回绕了。这意味着只能使用偶数数组，这就是它无法竞争的原因。

码：

@mov x0 dat
@mov x0 acc
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b

说明：

  # calling for x0 will cause rom to move 1 cell forward

 @ mov x0 dat # Moves value to variable dat (only run once)
 @ mov x0 acc # Moves rom position forward and moves x0 to acc           
  teq x0 dat  # See if dat equals x0  
+ teq x0 acc  # If last expression was true, see x0 equals acc
b:            # Label for jumps (GOTO)
+ mov 1 p1    # Set output (p1) to 1 (same case as previous line)
- mov 0 p1    # if any expression was false, set output to 0 
- jmp b       # jump to b: (same case as prev line)

抱歉，如果有任何混淆，这是我的第一个代码高尔夫球答案。

编辑：通过一次运行的代码替换循环删除了7个字节

Ruby，23个字节

->a{a[2..-1]==a[0..-3]}

红宝石，131个 119字节

a=->x{!(x.values_at(*x.each_index.select{|i|i.even?}).uniq)[1]&!(x.values_at(*x.each_index.select{|i|i.odd?}).uniq[1])}

Lambda a需要一个数组x，如果数组中的奇数索引元素有0或1个唯一值，而偶数索引元素有0或1个唯一值，则Lambda会返回true。

值得注意的字节安全

• 使用lambda def
• !arr[1] 与 arr.length < 2
• & 与 &&

测试用例

p a[[]]
p a[[1]]
p a[[1,1]]
p a[[1,2,1]]
p a[[1,2,1,2]]
p a[[3,4,3]]
p a[[10,5,10,5,10]]
p a[[10,11]]
p a[[9,9,9,9,9]]

#false
p a[[5,4,3,5,4,3]]==false
p a[[3,2,1,2,1,2]]==false
p a[[1,2,1,2,1,1,2]]==false
p a[[2,2,3,3]]==false
p a[[2,3,3,2]]==false

Dart，46个字节

(l){var i=0;return l.every((x)=>x==l[i++%2]);}

运行：

void main() {
  var f = (l){var i=0;return l.every((x)=>x==l[i++%2]);};
  print(f([1,2,1,2,1]));
}

C＃，54个字节

using System.Linq;p=>!p.Where((v,i)=>v!=p[i%2]).Any();

过滤数组以显示与偶数的第一个值和赔率的第二个值不匹配的值。如果没有任何结果，则返回true。

Japt，7个 6字节

eUîU¯2

尝试或运行所有测试用例

           :Implicit input of array U
   U¯2     :Get the first 2 elements of U
 Uî        :Repeat that array to the length of U
e          :Test for equality with the original U

C＃，66个字节

a=>{int r=1,i=0;for(;i<a.Length;)if(a[i]!=a[i++%2])r=0;return r;};

匿名函数，它接收一个整数数组，如果数组是交替的，则返回1，否则返回0。

具有完整功能和测试用例的完整程序：

using System;

public class Program
{
    public static void Main()
    {
        Func<int[], int> f =
        a =>
        {
            int r = 1,  // return value. 1 is true, by default
                i = 0;  // iterator
            for ( ; i<a.Length ; )  // for each array element
                if ( a[i] != a[i++%2] ) // if the even (or odd) elements are not the same
                    r = 0;      // a falsy (0) value will be assigned to the return element
            return r;       // returning if the array is alternating or not
        };

        // test cases:
        Console.WriteLine("Edge cases (all TRUE):");
        Console.WriteLine(f(new int[]{}));      //  True
        Console.WriteLine(f(new int[]{1}));     //  True
        Console.WriteLine(f(new int[]{1,1}));   //  True
        Console.WriteLine(f(new int[]{1,2,1})); //  True

        Console.WriteLine("Some other TRUE test cases:");
        Console.WriteLine(f(new int[]{1,2,1,2}));      // True
        Console.WriteLine(f(new int[]{10,5,10,5,10})); // True
        Console.WriteLine(f(new int[]{10,11}));        // True
        Console.WriteLine(f(new int[]{9,9,9,9,9}));    // True

        Console.WriteLine("Some FALSE test cases:");
        Console.WriteLine(f(new int[]{5,4,3,5,4,3}));   // False
        Console.WriteLine(f(new int[]{3,2,1,2,1,2}));   // False
        Console.WriteLine(f(new int[]{1,2,1,2,1,1,2})); // False
        Console.WriteLine(f(new int[]{2,2,3,3}));       // False
        Console.WriteLine(f(new int[]{2,3,3,2}));       // False
    }
}

八度，51字节

@(L)numel(L)<3||(f=@(n)isequal(L{n:2:end}))(1)&f(2)

输入是一个正整数的单元格数组。

在线尝试！

Clojure，70个字节

(fn[c](let[n #(max(count(set(take-nth 2 %)))1)](=(n c)(n(rest c))1))))

检查第二个项目的不重复计数是否为1，并处理空集合作为特殊情况。还尝试了许多方法reduce，group-by但没有很多运气。

R的另一种选择：36个字节。

all(rep_len(head(x,2),length(x))==x)

我想我找到了一个简短得多的版本：15个字节

all(!diff(x,2))