Чередующиеся массивы

Переменный массив представляет собой список любой длины , в которых два (не обязательно различные) значения переменные. То есть все элементы с четным индексом равны, а все элементы с нечетным индексом равны.

Ваша задача - написать программу или функцию, которая при наличии списка натуральных чисел выводит / возвращает, 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.

мозговой трах, 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]и a не совпадают, R будет проходить циклически, a[1:2]чтобы соответствовать длине a. Это даст предупреждение об этом, но это будет работать.

Удивительно, но это работает даже при пустом вводе, не знаю почему, но я с этим справлюсь.

Сохранено 1 байт благодаря @MickyT

MATL , 7 6 байт

2YCs&=

Для чередующихся массивов это выводит непустую матрицу единиц, которая является правдой. Для не чередующихся массивов матрица содержит по крайней мере один ноль и, таким образом, является ложной (см. Здесь ).

Попробуйте онлайн! Или проверьте все тестовые случаи .

объяснение

Давайте возьмем в [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@#)&

Порт алгоритма MATL Луиса Мендо. Безымянная функция, принимающая список чисел (или даже более общие объекты) и возвращающая Trueили False. Проверяет, равны ли суммы последовательных элементов. К сожалению Mostи Restзадохнуться в пустом списке, так что это должно быть проверено отдельно.

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. Попробуйте онлайн!

Спасибо Ними за 1 байт!

Сетчатка ,39 32 28 байт

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

Попробуйте онлайн!

Сэкономили 7 байтов благодаря Мартину ! Сохранено еще 3 благодаря Коби ! И Критикси за идею для другого 1.

При желании мы можем сопоставить число, которое занимает весь ввод, любую пару чисел или любую пару чисел, за которыми следует одна и та же пара любое количество раз и, необязательно, не включая второе число в самом конце. Может сохранить 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

Брахилог , 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. Для каждого элемента Biteise ИЛИ результат с разницей между текущим элементом и элементом 2 указывает раньше. вернуть, 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}}

Попытайся

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

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 байт благодаря Згарбу.

bash, 56 54 38 байт

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

Сохраните это как скрипт и передайте список чисел в качестве аргументов (для списка из n элементов вы передадите n аргументов). Вывод является кодом выхода: 0 (для истины), если список чередуется, и 1 (для ложи) в противном случае.

(Возвращение вывода в коде выхода разрешено в стандартных методах ввода / вывода PPCG.)

Это работает рекурсивно:

• Если список содержит менее 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

Пайк, 6 байт, неконкурентный

2<Ql{q

Попробуй это здесь!

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

Разрешить узлу изменения формы принимать список, а также строку

Шензен И.О. (Ассемблер), 83 76 байт, неконкурентоспособен

Shenzen io - игра-головоломка, в которой вы можете кодировать свой код на специальном языке ассемблера.

К сожалению, вы можете использовать только целые числа от -999 до 999 в качестве входов или выходов, и нет никакого способа узнать, закончился ли массив. Поэтому я предположил, что массив был написан на ПЗУ, которое оборачивается после чтения последней ячейки. Это означает, что могут использоваться только четные массивы, что является причиной его неконкурентоспособности.

Код:

@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 байтов, заменив циклы на один раз выполнения кода

Рубин, 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])}

Лямбда aожидает массив xи возвращает истину, если для нечетных индексированных элементов есть 0 или 1 уникальных значений и для четных индексированных элементов в массиве 0 или 1.

Известные байты

• использование лямбды над 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 в противном случае.

Полная программа с функцией ungolfed и контрольными примерами:

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