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 , 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

• What are the possible values of the elements of the array? – Robert Hickman Dec 19 '16 at 21:06
• @RobertHickman a list of positive integers, within your language's standard int size – FlipTack Dec 19 '16 at 21:12
• oh I see that in the question now. Oops and thanks. – Robert Hickman Dec 19 '16 at 21:12

Jelly, 4 bytes

ḣ2ṁ⁼


Try it online!

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.

• Damn. And changing the 2 to other numbers immediately generalizes the challenge! – Greg Martin Dec 18 '16 at 19:27
• 3 bytes, but Ɲ didn't exist when the challenge was posted. – caird coinheringaahing Apr 14 '18 at 19:54

brainfuck, 34 bytes

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


Takes the array as byte values in a string, and outputs \x00 for false and \x01 for true.

Try it online.

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.

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

• you can save yourself a byte with all((a=scan())==a[1:2]) – MickyT Dec 18 '16 at 20:36
• How do you input the data, as vector, list or just single numbers? I've tried typing single numbers on the console but I get the warning: "Warning message: In scan() == a[1:2] : longer object length is not a multiple of shorter object length". Though it works. – skan Dec 19 '16 at 0:43
• By typing single numbers indeed. It will throw a warning if the input length is odd, but it will still give the correct output. – JAD Dec 19 '16 at 8:37

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).

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]

• Nice algorithm! This would make a mean Jelly answer. – Dennis Dec 18 '16 at 20:11
• @Dennis Thanks! It was partly inspired by your Jelly approach – Luis Mendo Dec 18 '16 at 20:53

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

Retina, 25 bytes

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


Try it online!

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.

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.

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 Trues. Try it online!

Thanks to nimi for 1 byte!

• @Flp.Tkc It just needs a type hint – Zgarb Dec 18 '16 at 21:24
• Nice. and.(zipWith(==)=<<drop 2) saves a byte. – nimi Dec 18 '16 at 21:39

Retina, 3932 28 bytes

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


Try it online!

Saved 7 bytes thanks to Martin! Saved another 3 thanks to Kobi! And to Kritixi 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.

• Another ^(\d+)?(.\d+)?(.\1\2)*(.\1)?$ 29 byte alternative. This does not match ,1,,1. – Kritixi Lithos Dec 19 '16 at 11:51 • @Kobi Great idea, thanks! I used some of Kritixi's answer (the addition of the comma to the second capture group) to save another 1! – FryAmTheEggman Dec 19 '16 at 18:52 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  • you might want to update the code in the explanation (it's different atm) – FlipTack Dec 19 '16 at 22:07 • @Flp.Tkc Pyth implicitly adds Qs to the code. I added them in the explanation to make it clearer what was going on, but they aren't really in the code. – Mnemonic Dec 19 '16 at 22:09 Brachylog, 15 bytes :{~c#Tbh#Co}f#=  Try it online! 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  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  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 Perl 6, 49 43 42 bytes {!grep {![==] @_},roundrobin |.rotor: 2,:partial}  Try it {!.grep: ->\a,\b=$_[1] {sum .[0,1]Z!==a,b}}


Try it

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


Try it

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.
}
}

$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| +-+-+-+-+-+  • You should be able to replace {. Take with $ Shape. – Adám Nov 7 '17 at 10:59

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


Try it online! or Verify the testcases. -1 byte thanks to Zgarb.

• @Dennis The function works for [], but for some reason ghc cannot infer the correct type for []. It works if tested together with the other test case, see Verify the testcases. – Laikoni Dec 18 '16 at 20:34
• Right, I don't know Haskell that well. – Dennis Dec 18 '16 at 20:37
• Save a byte with f(a:x@(_:b:_))=a==b&&f x – Zgarb Dec 18 '16 at 21:05

bash, 5654 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.

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

• I'd call this a duplicate of this answer. – mbomb007 Dec 19 '16 at 17:27

Pyke, 6 bytes, noncompeting

2<Ql{q


Try it here!

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


Allow reshape node to take a list as well as a string

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

• Welcome to PPCG! – FlipTack Dec 20 '16 at 19:01

Ruby, 23 bytes

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


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


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]));
}


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.

Japt, 7 6 bytes

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 bytes

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


Anonymous function which receives an integer array and returns 1 if array is alternating and 0 otherwise.

Full program with ungolfed function and test cases:

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
}
}


Octave, 51 bytes

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


Input is a cell array of positive integers.

Try it online!

Clojure, 70 bytes

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


Checks that the distinct count of every 2nd item is 1, and handles empty collections as a special case. Also tried many approaches based on reduce and group-by but not much luck there.

Another option with R: 36 bytes.

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


And I think I've found a much shorter version: 15 bytes

all(!diff(x,2))
`