An Array of Challenges #1: Alternating Arrays

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

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.

Answer 2

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.

Answer 3

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 4

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

Try it online! Or verify all test cases.

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 5

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 6

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.

Answer 7

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 8

Retina, 39 32 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.

Answer 9

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

Thanks to nimi for 1 byte!

Answer 10

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 11

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

Answer 12

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

Answer 13

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 14

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 15

Python 2, 35 bytes

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

Try it online!

Answer 16

Haskell, 33 32 bytes

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

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

Answer 17

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 18

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 19

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 20

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

Answer 21

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 22

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 23

Ruby, 23 bytes

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

Answer 24

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 25

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 26

Japt, 7 6 bytes

eUîU¯2

Try it or run all test cases

           :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 27

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!

Answer 28

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

Answer 29

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.

Answer 30

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

Answer 31

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!

Answer 32

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!

Answer 33

PHP, 52 bytes

Run with -r.

foreach($argv as$i=>$n)$i<3|$n==$argv[$i-2]?:die(1);

loops from 3rd to last argument. Continue while argument equals that two positions earlier, else exit with code 1 (error). Exit with 0 (ok) after loop finishes.

or for 53 bytes:

while(++$i<$argc-3&$f=$argv[$i]==$argv[2+$i]);echo$f;

loops through all arguments but the last two. Continue while current argument equals that two positions later. Print 1 for true, nothing for false (string representations of true and false).

Answer 34

Oracle SQL, 73 Bytes

select count(*)from(select a,lag(a,2)over(order by 1)b from t)where a!=b;

Output:

True  =  0
False != 0

True Example:

create table t (a number);
truncate table t;
insert into t values (10);
insert into t values (5);
insert into t values (10);
insert into t values (5);
insert into t values (10);
commit;

select count(*)from(select a,lag(a,2)over(order by 1)b from t)where a!=b;

  COUNT(*)
----------
         0

False Example:

create table t (a number);
truncate table t;
insert into t values (1);
insert into t values (2);
insert into t values (3);
insert into t values (3);
insert into t values (1);
insert into t values (2);
commit;

select count(*) from(select a,lag(a,2)over(order by 1)b from t)where a!=b;


  COUNT(*)
----------
         4

Answer 35

Perl, 27 bytes

Includes +1 for p

perl -pE '$_=!/\b(\d+) \d+ (?!\1\b)/' <<< "1 2 1 2"

Answer 36

Add++ v5.1, 9 bytes

L~,Ñ+B]B=

Try it online!

Answer 37

Perl 6, 30 bytes

2>*[(0,2...*;1,3...*)].all.Set

Try it online!

Anonymous Whatever lambda that takes a list and returns an all Junction that boolifies to True/False.

Explanation:

  *[(       ;       )]          # Index from the list
     0,2...*                    # The even indexed elements
             1,3...*            # The odd indexed elements
                      .all      # Are both the lists
                          .Set  # When converted to a set
2>                              # The length is smaller than 2?

Answer 38

Common Lisp, 62 bytes

(defun f(l)(or(not #1=(caddr l))(and(=(car l)#1#)(f(cdr l)))))

Try it online!

Answer 39

05AB1E, 5 bytes

2∍s∍Q

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]