Массив вызовов № 1: Чередующиеся массивы

41

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

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

Ваша задача - написать программу или функцию, которая при наличии списка натуральных чисел выводит / возвращает, 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
FlipTack
источник
Каковы возможные значения элементов массива?
Роберт Хикман
@RobertHickman - список целых положительных чисел, в пределах стандартного размера int вашего языка
FlipTack
о, я вижу это в вопросе сейчас. Ой и спасибо.
Роберт Хикман

Ответы:

27

Желе , 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.
Деннис
источник
7
Черт. А замена на 2другие номера сразу обобщает вызов!
Грег Мартин
3 байта , но Ɲне было на момент публикации запроса.
Кэрд coinheringaahing
14

мозговой трах, 34 байта

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

Принимает массив как байтовые значения в строке и выводит значения \x00false и \x01true.

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

Это поддерживает структуру

a b 1 c

на ленте, где cтекущий символ, bпредыдущий символ и aпредыдущий предыдущий символ, пока массив чередуется. Если обнаружено несоответствие, указатель перемещается влево так, что a, bи 1флаг становятся равными нулю, и эта ситуация будет продолжаться до тех пор, пока не будут использованы все входные данные.

Митч Шварц
источник
13

R, 24 23 байта

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

Считывает вектор в STDIN, берет первые два элемента этого вектора и проверяет равенство. Если длины a[1:2]и a не совпадают, R будет проходить циклически, a[1:2]чтобы соответствовать длине a. Это даст предупреждение об этом, но это будет работать.

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

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

JAD
источник
Вы можете сэкономить байт с помощьюall((a=scan())==a[1:2])
MickyT
Как вы вводите данные, как вектор, список или просто отдельные числа? Я попытался набрать на консоли отдельные числа, но получаю предупреждение: «Предупреждение: в scan () == a [1: 2]: большая длина объекта не кратна короткой длине объекта». Хотя это работает.
Скан
Вводя отдельные числа действительно. Он выдаст предупреждение, если длина ввода будет нечетной, но все равно выдаст правильный вывод.
JAD
10

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]
Луис Мендо
источник
2
Хороший алгоритм! Это сделало бы средний ответ желе.
Деннис
@ Деннис Спасибо! Это было частично вдохновлено вашим подходом к желе
Луис Мендо
9

JavaScript (ES6), 27 байт

a=>!a.some((v,i)=>a[i&1]-v)

Контрольные примеры

Arnauld
источник
8

Сетчатка , 25 байт

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

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

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

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

Таким образом, первая ступень подсчитывает количество совпадений, из \b(\d+),\d+,(?!\1\b)которых совпадает и захватывает одно значение, затем сопоставляет следующее значение, а затем утверждает, что третье значение в последовательности отличается. Это дает ноль для правильных входных данных и что-то положительное для недопустимых значений.

Второй этап просто подсчитывает количество совпадений ^0, 1если первый этап возвращен, 0и в 1противном случае.

Мартин Эндер
источник
7

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.

Грег Мартин
источник
7

Haskell, 27 26 байтов

and.(zipWith(==)=<<drop 2)

Это оценивает анонимную функцию, которая решает проблему. Идея состоит в том, чтобы убрать первые два числа из списка, заархивировать исходный список, используя равенство, и проверить, что результат содержит только Trues. Попробуйте онлайн!

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

Zgarb
источник
1
Ницца. and.(zipWith(==)=<<drop 2)сохраняет байт.
Ними
7

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

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

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

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

При желании мы можем сопоставить число, которое занимает весь ввод, любую пару чисел или любую пару чисел, за которыми следует одна и та же пара любое количество раз и, необязательно, не включая второе число в самом конце. Может сохранить 2 байта, если вход был в унарном.

FryAmTheEggman
источник
1
Еще одна ^(\d+)?(.\d+)?(.\1\2)*(.\1)?$29-байтовая альтернатива. Это не соответствует ,1,,1.
Kritixi Lithos
1
@ Коби Отличная идея, спасибо! Я использовал ответ Критиси (добавление запятой ко второй группе захвата), чтобы сохранить еще 1!
FryAmTheEggman
6

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
мнемонический
источник
Возможно, вы захотите обновить код в объяснении (он другой)
FlipTack
@ Flp.Tkc Pyth неявно добавляет Qs в код. Я добавил их в объяснение, чтобы было яснее, что происходит, но на самом деле их нет в коде.
Мнемоника
5

Брахилог , 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
Fatalize
источник
5

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
Мэринус
источник
5

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

Джек Боеприпасы
источник
5

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.
  }
}
Брэд Гилберт b2gills
источник
$_[1]может быть на один байт короче .[1]. Тело внутренней лямбды может быть на один байт короче {.[0]!=a||.[1]!=b}.
Smls
1
@ Smls Я понятия не имею, почему я не видел .[1]. Кроме того, !=кажется, не работать , если она не сопровождается пробелом. Я думаю, что-то вроде $_!=3разбирается, как если бы это было написано как!( $_ = 3 )
Брэд Гилберт b2gills
Ах. Похоже, это ошибка Rakudo .
Smls
3

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|
+-+-+-+-+-+
Конор О'Брайен
источник
Вы должны быть в состоянии заменить {.Take с $Shape.
Адам
3

Haskell , 33 32 байта

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

Попробуйте онлайн! или Проверьте тестовые случаи. -1 байт благодаря Згарбу.

Laikoni
источник
@Dennis Функция работает для [], но по какой-то причине ghc не может определить правильный тип для []. Он работает, если тестируется вместе с другим тестовым примером, см. Проверка
Лайкони
Да, я не очень хорошо знаю Хаскелл.
Деннис
Сохранить байт сf(a:x@(_:b:_))=a==b&&f x
Zgarb
3

bash, 56 54 38 байт

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

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

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

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

  • Если список содержит менее 3 элементов, завершите работу с кодом возврата 0;
  • иначе, если 1-й элемент! = 3-й элемент, выйдите с кодом возврата 1;
  • иначе запустить программу рекурсивно в списке с удаленным первым элементом.
Митчелл Спектор
источник
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
сокол
источник
2
Я бы назвал это дубликатом этого ответа .
mbomb007
1

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

2<Ql{q

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

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

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

синий
источник
1

Шензен И.О. (Ассемблер), 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 байтов, заменив циклы на один раз выполнения кода

Anamne
источник
Добро пожаловать в PPCG!
FlipTack
1

Рубин, 23 байта

->a{a[2..-1]==a[0..-3]}
гигабайт
источник
1

Рубин, 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
manonthemat
источник
1

Дротик, 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]));
}
Дуэйн Слейтер
источник
1

C #, 54 байта

using System.Linq;p=>!p.Where((v,i)=>v!=p[i%2]).Any();

Фильтруйте массив, чтобы показать значения, которые не соответствуют первому значению для четных значений и 2-му значению для вероятностей. Если результатов нет, верните true.

Grax32
источник
0

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
    }
}
adrianmp
источник
0

Clojure, 70 байт

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

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

NikoNyrh
источник
0

Другой вариант с R: 36 байтов.

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

И я думаю, что я нашел гораздо более короткую версию: 15 байтов

all(!diff(x,2))
скан
источник