[Question]
  [
# Alternating Arrays
An *alternating array* is a list of any length in which two (not necessarily different) values are alternating. That is to say, all even-indexed items are equal, and all odd-indexed items are equal.
Your task is to write a program or function which, when given a list of positive integers, outputs/returns `truthy` if it is alternating and `falsy` otherwise.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code (in bytes) wins!
**Edge Cases:**
```
[]      ->  True
[1]     ->  True
[1,1]   ->  True
[1,2,1] ->  True
```
**Other Test Cases:**
```
[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
```
# Example
Here is an example you can test your solution against, written in Python 3 (not golfed):
```
def is_alternating(array):
    for i in range(len(array)):
        if array[i] != array[i%2]:
            return False
    return True
```
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
ḣ2ṁ⁼
```
[Try it online!](https://tio.run/nexus/jelly#@/9wx2KjhzsbHzXu@X@4/VHTGiBy//8/moszWiE6Vkch2hBM6EApIySGjhGYaaBjqgMloHxDsBpLHSiMVYjVARtnqmOiY6wDJkEKjCGGwA2Cc6ECRkCOMUQpmAEUVYjligUA "Jelly – TIO Nexus")
### How it works
```
ḣ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.
```
[Answer]
## brainfuck, 34 bytes
```
,>,>+>,
[
  [<+<<->>>-]
  +<[-<<]
  >[>]
  ,
]
<.
```
Takes the array as byte values in a string, and outputs `\x00` for false and `\x01` for true.
[Try it online.](http://brainfuck.tryitonline.net/#code=LD4sPis-LFtbPCs8PC0-Pj4tXSs8Wy08PF0-Wz5dLF08Lg&input=MTIxMg&debug=on)
This maintains the structure
`a b 1 c`
on the tape, where `c` is the current character, `b` is the previous character, and `a` is the previous previous character, as long as the array is alternating. If a mismatch is found, the pointer is moved to the left such that `a`, `b`, and the `1` flag all become zero, and this situation will continue until all the input is consumed.
[Answer]
# R, ~~24~~ 23 bytes
```
all((a=scan())==a[1:2])
```
Reads a vector into STDIN, takes the first two elements of that vector, and checks equality. If the lengths of `a[1:2]` and a don't match, R will loop through `a[1:2]` to match the length of a. It will give a warning about doing so, but it will work.
Surprisingly this even works for empty input, not sure why, but I'll roll with it.
Saved 1 byte thanks to @MickyT
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~7~~ 6 bytes
```
2YCs&=
```
For alternating arrays this outputs a non-empty matrix of ones, which is truthy. For non-alternating arrays the matrix contains at least one zero, and is thus falsy (see [here](https://codegolf.stackexchange.com/a/95057/36398)).
[Try it online!](https://tio.run/nexus/matl#@28U6VysZvv/f7ShjpEOEMcCAA) Or [verify all test cases](https://tio.run/nexus/matl#S/hvFOlcrGb73yXkf3QsV7QhCOtASCMErWMEYhnomOpACQjXEKTAUgcKgWxTHRMdYx0wCeQZQ7TCtMN5EL4RkG0MVgemgWIA).
### Explanation
Let's take `[1 2 1 2]` as example input.
```
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]
```
[Answer]
## JavaScript (ES6), 27 bytes
```
a=>!a.some((v,i)=>a[i&1]-v)
```
### Test cases
```
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
```
[Answer]
## [Retina](https://github.com/m-ender/retina), 25 bytes
```
M`\b(\d+),\d+,(?!\1\b)
^0
```
[Try it online!](https://tio.run/nexus/retina#U9VwT/jvmxCTpBGToq2pAyR0NOwVYwxjkjS54gz@/@cy5DLUAWEjGKljxGVooGOqAyVAHENDLksdKOQy1THRMdYBk1zGEA0QTXA2iGcEZBkDVYBJHSMA "Retina – TIO Nexus")
Instead of matching an input with alternating values (which leads to some annoying edge effects in a regex), I'm matching inputs that *aren't* valid and then negate the result afterwards.
The benefit of matching an invalid input is that this is a property can be checked locally, and it doesn't need to treat empty or short input specially: any input is invalid if it contains two distinct values that are one position apart.
So the first stage counts the number of matches of `\b(\d+),\d+,(?!\1\b)` which matches and captures one value, then matches the next value, and then asserts that the third value in sequence is different. This gives zero for valid inputs and something positive for invalid values.
The second stage simply counts the number of matches of `^0` which is `1` if the first stage returned `0` and `1` otherwise.
[Answer]
# Mathematica, 29 bytes
```
#=={}||Equal@@(Most@#+Rest@#)&
```
A port of Luis Mendo's MATL algorithm. Unnamed function taking a list of numbers (or even more general objects) and returning `True` or `False`. Tests whether sums of consecutive elements are all equal. Unfortunately `Most` and `Rest` choke on the empty list, so that has to be tested separately.
# Mathematica, 33 bytes
```
Differences[#,1,2]~MatchQ~{0...}&
```
Unnamed function taking a list of numbers (or even more general objects) and returning `True` or `False`. The function `Differences[#,1,2]` takes the differences, not of *consecutive* pairs of integers, but pairs of integers at distance two apart. Then we just check whether the resulting list has nothing other than zeros in it.
As a bonus, for one more byte (change the `2` to `#2`), we get a function that inputs a list of integers and another positive integer `#2`, and checks whether the input list is the result of interleaving `#2` constant sequences periodically with one another. For example,
```
Differences[#,1,#2]~MatchQ~{0...}&[{1,2,3,4,5,1,2,3,4,5,1,2},5]
```
evaluates to `True`.
[Answer]
## Haskell, ~~27~~ 26 bytes
```
and.(zipWith(==)=<<drop 2)
```
This evaluates to an anonymous function that solves the challenge.
The idea is to drop the first two numbers from the list, zip with the original list using equality, and check that the result only contains `True`s.
[Try it online!](https://tio.run/nexus/haskell#y03MzLMtKC0JLinSK87IL9dLU4k21DHSMdQxjP2fZpuYl6KnUZVZEJ5ZkqFha6tpa2OTUpRfoGCk@f8/AA "Haskell – TIO Nexus")
Thanks to nimi for 1 byte!
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~39~~ ~~32~~ 28 bytes
```
^(\d*)((,\d+)(,\1(\3|$))*)?$
```
[Try it online!](https://tio.run/nexus/retina#PYs7DoAwDEP3nKNISfFAUhiYGLlEhRh6DO5e@gNZfrIle@LzzhfH5IUZMc1SqBzD40S8HC5nUlJU20cY6YINA7Wo0o4h2rAioJFCP/TTn2uzkkJZNMJe "Retina – TIO Nexus")
Saved 7 bytes thanks to [Martin](https://codegolf.stackexchange.com/users/8478/martin-ender)! Saved another 3 thanks to [Kobi](https://codegolf.stackexchange.com/users/7762/kobi)! And to [Kritixi](https://codegolf.stackexchange.com/users/41805/kritixi-lithos) for an idea for another 1.
We optionally match a number that occupies the entire input, any pair of numbers, or any pair of numbers followed by the same pair any number of times and optionally not including the second number at the very end. Could save 2 bytes if the input was in unary.
[Answer]
# Pyth, 9 bytes
```
q<*<Q2lQl
```
### Explanation
```
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
```
[Answer]
# Java 8, 63 bytes
```
i->{int r=0,x=1;for(;++x<i.length;)r|=i[x]-i[x-2];return r==0;}
```
This is a lambda expression for a `Predicate< int[ ] >`
Explanation: initialize the result to 0. For each element, Biteise OR the result with the difference between the current element and the element 2 indicies earlier. return `true` if the result equals 0. Otherwise return `false`
[Answer]
# [Perl 6](https://perl6.org), ~~49 43~~ 42 bytes
```
{!grep {![==] @_},roundrobin |.rotor: 2,:partial}
```
[Try it](https://tio.run/nexus/perl6#bZJLa4NAFIX3/ooTGorSW6naFKoYhEK33WQXJFidplKrMjOGButvt76iUToDw3C@@zjzKATD6UkPHaVodjsmpKMo32fchlnE4Nbl6shZjnK1d10f3qEinhVpxLP3OMWvzjOZcRsm2XnAZRwkVd0ke7KpI@BCVYC9j264W2DHC0atZvj/aNSpC81s1WvtBm/yk/HOK14CwYStjKFkTt2mIg@0oWHxl8QYrCxynmmY/oy0aEOPZFG3Dn5fg0T0aVZv4mJkxoyRdXTGzEa3@npY5nVkPNgV05qnypMgxV1/4Y7ykfHL5d9vsT5Ahf3FzqoXp3khNYJ9CpKCqWv2k7NQskiDhrJpEgu0Dz4FjhEE/Ri3v6Kq/wA "Perl 6 – TIO Nexus")
```
{!.grep: ->\a,\b=$_[1] {sum .[0,1]Z!==a,b}}
```
[Try it](https://tio.run/nexus/perl6#bZJLa4NAFIX3/ooTKkXpjURtClWUQKHbbrKqkWDMNJWaRBwNDeJvt@MjGqUzMAznu48zj5wzXF600JZysVszntmSdLziMTzvGZyqmGmHlCUW5u4moM3Okbee7qPg@RGatyDd/5w5TkC7sqxE2ioTFTgcKBLg@WiG4wLrNGdUa7r/j0aNOtGMWr3XHvCRfbO0cYm3gDNuSX0oGUO3ociCltQt/pTonZVJzit10x@RGi3pmUxq1s7vexDzNs1sTdyMjJjes4aOmCF0s62HaV5D@oPdMVU8UhIHJzy1F25LX@f0dvlzF/IWCqwfdlVW0SnJM5VgXYI4Z4rMfhMWZmyvQkUhmkQc9VMPgX0EQTtE9X8oqz8 "Perl 6 – TIO Nexus")
```
{!.grep: ->\a,\b=.[1] {sum .[0,1]Z!==a,b}}
```
[Try it](https://tio.run/nexus/perl6#bZJLa4NAFIX3/ooTGorSG4naFKqMBArddpNVEwkTM02lJhFHQ4P4262vaJTOwDCc7z7OPFIpcHnRfUdJy91KyMRRlOMVj/55L8CKbKIfYhHZmLkbTpsd09eGh0ymR@jrORne54QxTrs8L8qsZVIWkGBQFWDtoR7MBVZxKqjSDO8fjWp1pJmVeq894CP5FnFtEm9cCmkrXSiZfbe@yJwW1C7emBitlVHOK7XTG5AKLeiZLKrX1u87D2WTZjUmbkYGzOhYTQfMLHWrqYdxXk26g90xrXyjKOQnPDUX7ihf5/h2@TMX0y1U2D/iqi6DU5QmGsG@8DAV6lT8RsJPxF6DhqxsEkhUL90HdhEE/RBU3yEv/gA "Perl 6 – TIO Nexus")
## Expanded:
```
{
  !              # 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.
  }
}
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 15 bytes
```
:{~c#Tbh#Co}f#=
```
[Try it online!](https://tio.run/nexus/brachylog#@29VXZesHJKUoeycX5umbPv/f7ShgZWpFZSIBQA "Brachylog – TIO Nexus")
### Explanation
```
:{         }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
```
[Answer]
# APL, 7 bytes
```
⊢≡⍴⍴2⍴⊢
```
Explanation:
* `2⍴⊢`: reshape the input array by 2
* `⍴⍴`: reshape the result by the original size of the input, repeating elements
* `⊢≡`: see if the result of that is equal to the original input
Test cases:
```
      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
```
[Answer]
# [Python 2](https://docs.python.org/2/), 35 bytes
```
lambda x:(x[:2]*len(x))[:len(x)]==x
```
[Try it online!](https://tio.run/nexus/python2#TYzLCsMgEEXX8StmqWUWUZtFBb/ESklpBSG1ISTg31tfhDJw594zDwca7mmZP8/XDFHRaJSwl@UdaGTMqGas1jG57wYP8AHoiJwpMhQQC/BhPXZa0LBuPuzg8g2SFpKxCIZXwd7En0FR7YgTdumZ150b9rLETHhFiVXLSLbz88UZOxA5yLZaTaY/ "Python 2 – TIO Nexus")
[Answer]
# [Haskell](https://www.haskell.org/), ~~33~~ 32 bytes
```
f(a:x@(_:b:_))=a==b&&f x
f a=1<3
```
[Try it online!](https://tio.run/nexus/haskell#y03MzLMtKC0JLinSK87IL9dLU4k21DHSMYz9n6aRaJVklWxVpGmbaGubrKaWpgHhcqUpJNoa2hj//w8A "Haskell – TIO Nexus") or [Verify the testcases.](https://tio.run/nexus/haskell#y03MzLMtKC0JLinSK87IL1fJTSxQSIuOjtWJNgRhHSMIqWMIoyEiBjqmOlACwjUEKbDUgUIg21THRMdYB0wCecYQrTpIBoIxhG8EZBuD1YFpoFjs/zSNRKskq2SrIk3bRFvbZDW1NA0I1zpNIdHW0Mb4/38A "Haskell – TIO Nexus") -1 byte thanks to Zgarb.
[Answer]
## bash, ~~56~~ ~~54~~ 38 bytes
```
[ -z $3 ]||((($1==$3))&&(shift;$0 $*))
```
Save this as a script, and pass the list of numbers as arguments (for an n-element list, you'll pass n arguments). The output is the exit code: 0 (for true) if the list is alternating, and 1 (for false) otherwise. 
(Returning output in the exit code is allowed in the PPCG standard I/O methods.)
This works recursively:
* If the list has fewer than 3 elements, then exit with return code 0;
* else if the 1st element != the 3rd element, then exit with return code 1;
* else run the program recursively on the list with the first element removed.
[Answer]
# J, 8 bytes
```
-:$$2&{.
```
## Explanation
```
-:$$2&{.  input: (y)
    2&{.  the first two elements of y
   $      shaped like
  $       the shape of y
-:        and check if they match
```
## Test cases
```
   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|
+-+-+-+-+-+
```
[Answer]
**Python 2.7, 38 bytes**
```
>> i=lambda a:(a[:2]*len(a))[0:len(a)]==a
```
**Test Cases:**
```
>> 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
```
[Answer]
# Jelly, 6 bytes
My first Jelly program! I know I'll never beat Dennis, but I'm awfully proud of this regardless.
```
s2ZE€Ạ // Main link: Argument A (array)
s2     // Split A into chunks of 2 
       // [1,2,1,2] -> [[1,2],[1,2]]
  Z    // Transpose A   
       // [[1,2],[1,2]] -> [[1,1],[2,2]]
   E€  // Map an equality check to each sublist of A
       // [[1,1],[2,2]] -> [1,1]
     Ạ // Any: return 0 if A contains any falsy values, else return 1
       // [1,1] -> 1
```
[Try it here!](http://jelly.tryitonline.net/#code=czJaReKCrOG6oA&input=&args=WzEsMiwxLDIsMSwyXQ)
[Answer]
## Pyke, 6 bytes, noncompeting
```
2<Ql{q
```
[Try it here!](http://pyke.catbus.co.uk/?code=2%3CQl%7Bq&input=%5B1%2C2%2C1%2C2%2C1%2C2%5D)
```
2<     -   inp[:2]
    {  -  reshape(^, v)
  Ql   -   len(inp)
     q - ^ == inp
```
Allow reshape node to take a list as well as a string
[Answer]
# **Shenzen IO (Assembler) ,~~83~~ 76 bytes, noncompeting**
Shenzen io is a puzzle game where you can code you code in a special assembler-ish language. 
Unfortunately, you can only use integers between -999 and 999 as inputs or outputs, and there is no way to tell if an array has ended. So i assumed that the array was written on a ROM that wraps around after reading the last cell. This means that only even arrays can be used, which is the reason for it being noncompeting.
Code:
```
@mov x0 dat
@mov x0 acc
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b
```
Explanation:
```
  # 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)
```
Sorry if any of this is confusing, this is my first code-golf answer.
EDIT: removed 7 bytes by replacing loops by run-once code
[Answer]
## Ruby, 23 bytes
```
->a{a[2..-1]==a[0..-3]}
```
[Answer]
# Ruby, ~~131~~ 119 bytes
```
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` expects an array `x` and returns true if there are 0 or 1 unique values for the odd indexed elements and 0 or 1 unique values for the even indexed elements in the array.
**Notable byte-safers**
* use of lambda over `def`
* `!arr[1]` vs. `arr.length < 2`
* `&` vs `&&`
Test cases
```
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
```
[Answer]
## Dart, 46 bytes
```
(l){var i=0;return l.every((x)=>x==l[i++%2]);}
```
Run with:
```
void main() {
  var f = (l){var i=0;return l.every((x)=>x==l[i++%2]);};
  print(f([1,2,1,2,1]));
}
```
[Answer]
# C#, 54 bytes
```
using System.Linq;p=>!p.Where((v,i)=>v!=p[i%2]).Any();
```
Filter array to show values that do not match the first value for evens and the 2nd value for odds. If there are not any results, return true.
[Answer]
# Common Lisp, 62 bytes
```
(defun f(l)(or(not #1=(caddr l))(and(=(car l)#1#)(f(cdr l)))))
```
[Try it online!](https://tio.run/##RU7LCsMgEPyVIaF0vNXYHHpI/0VihYDVkKbX/Lpdo1AXd2dmH8wcls@aM93LfyM8g2LaGNOOXk@crXMbglK00bHwwnrdK3rOtSUvM6S0wicRsERcSQXq8lHz8K8YBBncYYpyw4iWKtVl8IEWgscyirEtmHqinRkEmVM/q2gKLoHi5G137OgOi@mJwx6XTrzRn47zDw)
[Answer]
# Japt, ~~7~~ 6 bytes
```
eUîU¯2
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=ZVXuVa8y&input=WzEsMiwxLDJd) or [run all test cases](https://ethproductions.github.io/japt/?v=1.4.6&code=ZVXuVa8y&input=WwpbMSwyLDEsMl0gICAgICAgLT4gVHJ1ZQpbMyw0LDNdICAgICAgICAgLT4gVHJ1ZQpbMTAsNSwxMCw1LDEwXSAgLT4gVHJ1ZQpbMTAsMTFdICAgICAgICAgLT4gVHJ1ZQpbOSw5LDksOSw5XSAgICAgLT4gVHJ1ZQpbNSw0LDMsNSw0LDNdICAgLT4gRmFsc2UKWzMsMiwxLDIsMSwyXSAgIC0+IEZhbHNlClsxLDIsMSwyLDEsMSwyXSAtPiBGYWxzZQpbMiwyLDMsM10gICAgICAgLT4gRmFsc2UKWzIsMywzLDJdICAgICAgIC0+IEZhbHNlCl0KLW1S)
```
           :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
```
[Answer]
# C, ~~52~~ ~~50~~ ~~49~~ 47 bytes
*Thanks to @ceilingcat for golfing two bytes!*
```
f(i,l)int*i;{return--l<2?1:*i-i[2]?0:f(++i,l);}
```
Outputs 1 if the array alternates, 0 otherwise.
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1MnRzMzr0Qr07q6KLWktChPVzfHxsje0EorUzcz2ijW3sAqTUNbG6TMuvY/UKVCbmJmnoYmVzWXAhCABDKjzWNtqw11jHTguNYaLFtQBJRP01BSTVHSUQDZZa6pac1V@x8A)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
2∍s∍Q
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f6FFHbzEQB/7/H21ooGOqAyViAQ "05AB1E – Try It Online")
Explanation:
```
2∍s∍Q   //Full Program
2∍      //extend/shorten input to length 2       e.g. [1,2,1,2,2] -> [1,2]
  s∍    //extend/shorten to length of input      e.g. [1,2] -> [1,2,1,2,1]
    Q   //is equal to input                      e.g. [1,2,1,2,1] != [1,2,1,2,2]
```
]