交互配列

交互配列は、2つ（必ずしも異なる）の値が交互にされた任意の長さのリストです。つまり、すべての偶数インデックスのアイテムは等しく、すべての奇数インデックスのアイテムは等しくなります。

あなたの仕事は、正の整数のリストが与えられたときに、truthy交互になっているfalsy場合とそうでない場合に出力/返すプログラムまたは関数を書くことです。

これはcode-golfなので、最短のコード（バイト単位）が勝ちです！

エッジケース：

[]      ->  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に読み込み、そのベクトルの最初の2つの要素を取得して、等しいかどうかをチェックします。とaの長さがa[1:2]一致しない場合、Rはループしa[1:2]てaの長さに一致します。そうすることについて警告を発しますが、動作します。

驚いたことに、これは空の入力でも機能しますが、理由はわかりませんが、私はそれでロールバックします。

@MickyTのおかげで1バイト節約

MATL、7 6バイト

2YCs&=

交互配列の場合、これは1の空でない行列を出力しますが、これは真実です。非交互配列の場合、行列には​​少なくとも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

オンラインでお試しください！

入力を交互の値と一致させるのではなく（正規表現で厄介なエッジ効果が生じる）、有効ではない入力を一致させ、その後結果を否定します。

無効な入力と一致する利点は、これがローカルでチェックできるプロパティであり、空の入力や短い入力を特別に扱う必要がないことです。1つの位置が離れた2つの異なる値が含まれる入力は無効です。

そのため、最初の段階では、\b(\d+),\d+,(?!\1\b)1つの値に一致してキャプチャする一致の数をカウントし、次の値に一致してから、シーケンスの3番目の値が異なることをアサートします。これにより、有効な入力にはゼロが、無効な値には正の値が与えられます。

2番目のステージ^0では1、最初のステージが返さ0れた1場合とそうでない場合の一致の数を単純にカウントします。

Mathematica、29バイト

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

ルイスメンドーのMATLアルゴリズムの移植版。名前の関数の番号（またはそれ以上の一般的なオブジェクト）のリストを取り、返しますTrueかFalse。連続する要素の合計がすべて等しいかどうかをテストします。残念ながら、MostかつRestそれが個別にテストする必要があるので、空のリストにチョーク。

Mathematica、33バイト

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

名前の関数の番号（またはそれ以上の一般的なオブジェクト）のリストを取り、返しますTrueかFalse。この関数Differences[#,1,2]は、整数の連続したペアではなく、距離2離れた整数のペアの差を取ります。次に、結果のリストにゼロ以外が含まれていないかどうかを確認します。

ボーナスとして、1以上のバイト（変更のため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)

これにより、課題を解決する匿名関数が評価されます。アイデアは、リストから最初の2つの数値を削除し、等式を使用して元のリストを圧縮し、結果にTrues のみが含まれていることを確認することです。 オンラインでお試しください！

1バイトのnimiに感謝します！

網膜、39 32 28バイト

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

オンラインでお試しください！

Martinのおかげで7バイト節約されました！コビのおかげでさらに3つ節約できました！そして、別の1のアイデアのためにKritixiに。

必要に応じて、入力全体を占める数字、数字のペア、または数字のペアとそれに続く同じペアを何度でも一致させ、オプションで最後に2番目の数字を含めません。入力が単項の場合、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 OR結果に含めます。返す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

オンラインでお試しください！またはテストケースを確認します。Zgarbのおかげで-1バイト。

bash、56 54 38バイト

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

これをスクリプトとして保存し、数値のリストを引数として渡します（n要素のリストの場合、n個の引数を渡します）。出力は終了コードです。リストが交互の場合は0（true）、そうでない場合は1（false）です。

（終了コードで出力を返すことは、PPCG標準I / Oメソッドで許可されています。）

これは再帰的に機能します：

• リストの要素が3つ未満の場合、戻りコード0で終了します。
• それ以外の場合、1番目の要素が！= 3番目の要素の場合、戻りコード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

形状変更ノードがリストと文字列を取得できるようにする

Shenzen IO（アセンブラー）、83 76バイト、非競合

Shenzen ioは、特別なアセンブラー言語でコードをコーディングできるパズルゲームです。

残念ながら、入力または出力として使用できるのは-999〜999の整数のみであり、配列が終了したかどうかを判断する方法はありません。だから私は、最後のセルを読んだ後にラップアラウンドする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)

これが混乱を招く場合は申し訳ありませんが、これは私の最初のコードゴルフの答えです。

編集：ループを1回実行コードで置き換えることにより7バイトを削除

ルビー、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の一意の値がある場合にtrueを返します。

注目すべきバイトセーフ

• ラムダオーバーの使用 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

ダーツ、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();

配列をフィルター処理して、偶数の最初の値と奇数の2番目の値に一致しない値を表示します。結果がない場合は、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))))

2番目のアイテムごとの個別のカウントが1であることを確認し、特別なケースとして空のコレクションを処理します。また、に基づいて多くのアプローチを試してみましたreduceし、group-byそこに多くの幸運をではなく。

Rの別のオプション：36バイト。

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

そして、私ははるかに短いバージョンを見つけたと思う：15バイト

all(!diff(x,2))