Naprzemienne tablice

Tablica przemiennego jest listą o dowolnej długości, w których dwa (nie koniecznie) inne wartości są przemienne. Oznacza to, że wszystkie pozycje o indeksie nieparzystym są równe, a wszystkie elementy o indeksie nieparzystym są równe.

Twoim zadaniem jest napisanie programu lub funkcji, która, gdy otrzyma listę dodatnich liczb całkowitych, wyprowadza / zwraca, truthyjeśli jest na przemian i falsyinaczej.

To jest golf golfowy , więc wygrywa najkrótszy kod (w bajtach)!

Edge Cases:

[]      ->  True
[1]     ->  True
[1,1]   ->  True
[1,2,1] ->  True

Inne przypadki testowe:

[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

Przykład

Oto przykład, na którym możesz przetestować swoje rozwiązanie, napisany w Pythonie 3 (bez gry w golfa):

def is_alternating(array):
    for i in range(len(array)):
        if array[i] != array[i%2]:
            return False
    return True

Galaretka , 4 bajty

ḣ2ṁ⁼

Wypróbuj online!

Jak to działa

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

pieprzenie mózgu, 34 bajty

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

Pobiera tablicę jako wartości bajtów w łańcuchu i zwraca wartości \x00false i \x01true.

Wypróbuj online.

Utrzymuje to strukturę

a b 1 c

na taśmie, gdzie cjest bieżący znak, bpoprzedni znak i apoprzedni poprzedni znak, o ile tablica jest na przemian. Jeśli zostanie znalezione niedopasowanie, wskaźnik zostanie przesunięty w lewo tak, że a, ba 1flaga stanie się zero, i ta sytuacja będzie trwać, dopóki wszystkie dane wejściowe nie zostaną wykorzystane.

R 24 24 bajty

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

Wczytuje wektor do STDIN, bierze pierwsze dwa elementy tego wektora i sprawdza równość. Jeśli długości a[1:2]i a nie pasują, R zapętli się, a[1:2]aby dopasować długość a. Ostrzeże o tym, ale zadziała.

Zaskakujące, że to działa nawet dla pustych danych wejściowych, nie jestem pewien, dlaczego, ale będę z tym korzystać.

Zapisano 1 bajt dzięki @MickyT

MATL , 7 6 bajtów

2YCs&=

W przypadku tablic naprzemiennych generuje niepustą macierz jednych, co jest prawdą. W przypadku tablic nieprzemiennych matryca zawiera co najmniej jedno zero, a zatem jest fałszem (patrz tutaj ).

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

Weźmy [1 2 1 2]jako przykładowe dane wejściowe.

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 bajtów

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

Przypadki testowe

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

Siatkówka , 25 bajtów

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

Wypróbuj online!

Zamiast dopasowywać dane wejściowe naprzemiennymi wartościami (co prowadzi do denerwujących efektów krawędziowych w wyrażeniu regularnym), dopasowuję dane wejściowe, które nie są prawidłowe, a następnie neguję wynik.

Zaletą dopasowania niepoprawnego wejścia jest to, że jest to właściwość, którą można sprawdzić lokalnie, i nie trzeba specjalnie traktować pustych lub krótkich danych wejściowych: każde wejście jest nieprawidłowe, jeśli zawiera dwie różne wartości, które są od siebie oddzielone.

Tak więc pierwszy etap liczy liczbę dopasowań, \b(\d+),\d+,(?!\1\b)które pasują i przechwytuje jedną wartość, a następnie dopasowuje następną wartość, a następnie stwierdza, że ​​trzecia wartość w sekwencji jest inna. To daje zero dla prawidłowych danych wejściowych i coś pozytywnego dla nieprawidłowych wartości.

Drugi etap po prostu zlicza liczbę meczów z ^0co 1jeśli pierwszy etap wrócił 0i 1inaczej.

Mathematica, 29 bajtów

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

Port algorytmu MATL Luisa Mendo. Nienazwana funkcja pobierająca listę liczb (lub nawet bardziej ogólnych obiektów) i zwracająca Truelub False. Sprawdza, czy sumy kolejnych elementów są równe. Niestety Mosti Restdusić się na pustej liście, więc trzeba to przetestować osobno.

Mathematica, 33 bajty

Differences[#,1,2]~MatchQ~{0...}&

Nienazwana funkcja pobierająca listę liczb (lub nawet bardziej ogólnych obiektów) i zwracająca Truelub False. Funkcja Differences[#,1,2]przyjmuje różnice, a nie kolejne pary liczb całkowitych, ale pary liczb całkowitych w odległości dwóch od siebie. Następnie sprawdzamy, czy na wynikowej liście nie ma nic poza zerami.

Jako bonus, dla jeszcze jednego bajta (zmienić 2na #2), otrzymujemy funkcję wejścia listę liczb całkowitych i innej liczby całkowitej dodatniej #2i sprawdza, czy lista wejściowa jest wynikiem przeplatania #2stałe sekwencje okresowo ze sobą. Na przykład,

Differences[#,1,#2]~MatchQ~{0...}&[{1,2,3,4,5,1,2,3,4,5,1,2},5]

ocenia na True.

Haskell, 27 26 bajtów

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

To prowadzi do anonimowej funkcji, która rozwiązuje wyzwanie. Pomysł polega na usunięciu pierwszych dwóch liczb z listy, skompresowaniu do oryginalnej listy przy użyciu równości i sprawdzeniu, czy wynik zawiera tylko Trues. Wypróbuj online!

Dzięki nim za 1 bajt!

Siatkówka ,39 32 28 bajtów

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

Wypróbuj online!

Zaoszczędź 7 bajtów dzięki Martinowi ! Oszczędź kolejne 3 dzięki Kobi ! I Kritixi za pomysł na kolejny 1.

Opcjonalnie dopasowujemy liczbę, która zajmuje całe wejście, dowolną parę liczb lub dowolną parę liczb, po której następuje ta sama para dowolna liczba razy i opcjonalnie nie włączając drugiej liczby na samym końcu. Można zapisać 2 bajty, jeśli dane wejściowe były jednoargumentowe.

Pyth, 9 bajtów

q<*<Q2lQl

Wyjaśnienie

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

Brachylog , 15 bajtów

:{~c#Tbh#Co}f#=

Wypróbuj online!

Wyjaśnienie

:{         }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 bajtów

⊢≡⍴⍴2⍴⊢

Wyjaśnienie:

• 2⍴⊢: przekształć tablicę wejściową o 2
• ⍴⍴: przekształć wynik według pierwotnego rozmiaru danych wejściowych, powtarzając elementy
• ⊢≡: sprawdź, czy wynik tego jest równy pierwotnemu wejściu

Przypadki testowe:

      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 bajty

i->{int r=0,x=1;for(;++x<i.length;)r|=i[x]-i[x-2];return r==0;}

To jest wyrażenie lambda dla Predicate< int[ ] >

Objaśnienie: Zainicjuj wynik na 0. Dla każdego elementu Biteise LUB wynik z różnicą między bieżącym elementem a elementem 2 wskazuje wcześniej. zwróć, truejeśli wynik jest równy 0. W przeciwnym razie zwróćfalse

Perl 6 ,  49 43  42 bajtów

{!grep {![==] @_},roundrobin |.rotor: 2,:partial}

Spróbuj

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

Spróbuj

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

Spróbuj

Rozszerzony:

{
  !              # 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 bajtów

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

Wypróbuj online!

J, 8 bajtów

-:$$2&{.

Wyjaśnienie

-:$$2&{.  input: (y)
    2&{.  the first two elements of y
   $      shaped like
  $       the shape of y
-:        and check if they match

Przypadki testowe

   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 bajty

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

Wypróbuj online! lub Zweryfikuj przypadki testowe. -1 bajt dzięki Zgarb.

bash, 56 54 38 bajtów

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

Zapisz to jako skrypt i przekaż listę liczb jako argumenty (dla listy n-elementowej przekażesz n argumentów). Dane wyjściowe to kod wyjścia: 0 (dla wartości true), jeśli lista jest na przemian, i 1 (dla wartości false) w przeciwnym razie.

(Zwracanie danych wyjściowych w kodzie wyjścia jest dozwolone w standardowych metodach We / Wy PPCG.)

Działa to rekurencyjnie:

• Jeśli lista zawiera mniej niż 3 elementy, zakończ z kodem powrotu 0;
• w przeciwnym razie, jeśli pierwszy element! = trzeci element, następnie wyjdź z kodem powrotu 1;
• w przeciwnym razie uruchom program rekurencyjnie na liście z usuniętym pierwszym elementem.

Python 2.7, 38 bajtów

>> i=lambda a:(a[:2]*len(a))[0:len(a)]==a

Przypadki testowe:

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

Pyke, 6 bajtów, niekonkurujące

2<Ql{q

Wypróbuj tutaj!

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

Zezwól węzłu przekształcania na pobranie zarówno listy, jak i łańcucha

Shenzen IO (asembler), 83 76 bajtów, niekonkurujące

Shenzen io to gra logiczna, w której możesz zakodować swój kod specjalnym językiem asemblera.

Niestety, możesz używać liczb całkowitych od -999 do 999 jako danych wejściowych lub wyjściowych i nie ma sposobu, aby stwierdzić, czy tablica się zakończyła. Więc założyłem, że tablica została zapisana na ROM-ie, który zawija się po odczytaniu ostatniej komórki. Oznacza to, że można stosować tylko tablice, co jest przyczyną braku konkurencji.

Kod:

@mov x0 dat
@mov x0 acc
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b

Wyjaśnienie:

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

Przepraszam, jeśli którekolwiek z nich jest mylące, to moja pierwsza odpowiedź na golfa.

EDYCJA: usunięto 7 bajtów, zastępując pętle kodem jednokrotnego uruchomienia

Rubinowy, 23 bajty

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

Rubin, 131 119 bajtów

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 aoczekuje tablicy xi zwraca true, jeśli w tablicy znajduje się 0 lub 1 unikalnych wartości dla nieparzystych elementów indeksowanych i 0 lub 1 unikalnych wartości dla parzystych elementów indeksowanych w tablicy.

Znaczące zabezpieczenia bajtów

• wykorzystanie lambda ponad def
• !arr[1] vs. arr.length < 2
• & vs &&

Przypadki testowe

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 bajtów

(l){var i=0;return l.every((x)=>x==l[i++%2]);}

Biegnij z:

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 bajty

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

Filtruj tablicę, aby pokazać wartości, które nie pasują do pierwszej wartości dla wyrównania i drugiej wartości dla szans. Jeśli nie ma żadnych wyników, zwróć wartość true.

Japt, 7 6 bajtów

eUîU¯2

Wypróbuj lub uruchom wszystkie przypadki testowe

           :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 bajtów

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

Anonimowa funkcja, która odbiera tablicę liczb całkowitych i zwraca 1, jeśli tablica jest na przemian, a 0 w przeciwnym razie.

Pełny program z funkcją niepolowania i przypadków testowych:

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

Oktawa, 51 bajtów

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

Dane wejściowe to tablica komórek dodatnich liczb całkowitych.

Wypróbuj online!

Clojure, 70 bajtów

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

Sprawdza, czy odrębna liczba co 2 pozycji wynosi 1, i traktuje puste kolekcje jako specjalny przypadek. Próbowałem też wiele rozwiązań opartych na reducea group-by, ale nie dużo szczęścia tam.

Inna opcja z R: 36 bajtów.

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

I myślę, że znalazłem znacznie krótszą wersję: 15 bajtów

all(!diff(x,2))