Чергуючі масиви

Черговий масив - це список будь-якої довжини, в якому чергуються два (не обов'язково різні) значення. Тобто, усі парно-індексовані елементи рівні, а всі непарноіндексовані елементи рівні.

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

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

Приймає масив як значення байтів у рядку та виводить \x00для false та \x01for true.

Спробуйте в Інтернеті.

Це підтримує структуру

a b 1 c

на стрічці, де cпоточний символ, bє попередній символ, і aце попередній попередній символ, доки масив чергується. Якщо виявлено невідповідність, вказівник переміщується вліво таким чином, що a, bі 1прапор усіх стає нульовим, і ця ситуація триватиме до тих пір, поки весь вхід не буде використаний.

R, 24 23 байти

all((a=scan())==a[1:2])

Читає вектор у STDIN, бере перші два елементи цього вектора і перевіряє рівність. Якщо довжини a[1:2]та не збігаються, R буде проходити цикл, a[1:2]щоб відповідати довжині а. Це дасть попередження про це, але це спрацює.

Дивно, але це працює навіть для порожнього вводу, не впевнений, чому, але я пройдуся з ним.

Збережено 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іншому випадку.

Математика, 29 байт

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

Порт алгоритму MATL Луїса Мендо. Безіменна функція: перелік номерів (або навіть більш загальних об'єктів) та повернення Trueабо False. Тестує, чи всі суми послідовних елементів рівні. На жаль, Mostі Restзадихається у порожньому списку, так що це потрібно перевірити окремо.

Математика, 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 завдяки Кобі ! І до Kritixi для ідеї ще 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;}

Це лямбда-вираз для a 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}}

Спробуй це

Розширено:

{
  !              # 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)

Вибачте, якщо щось із цього бентежить, це моя перша відповідь з кодом на гольф.

EDIT: видалено 7 байтів, замінивши цикли кодом run-Once

Рубін, 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] vs. 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();

Фільтр масиву відображає значення, які не відповідають першому значенню для рівнів та другому значенню для коефіцієнтів. Якщо результатів немає, поверніть справжнє.

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

Перевіряє, що кількість кожного другого елемента дорівнює 1, і обробляє порожні колекції як особливий випадок. Також перепробував безліч підходів , заснованих на reduceі , group-byале не так багато удачі там.

Ще один варіант з R: 36 байт.

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

І я думаю, я знайшов набагато більш коротку версію: 15 байт

all(!diff(x,2))