Wechselnde Arrays

Ein alternierendes Array ist eine Liste beliebiger Länge, in der sich zwei (nicht unbedingt unterschiedliche) Werte abwechseln. Das heißt, alle geradzahligen Elemente sind gleich und alle ungeradzahligen Elemente sind gleich.

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die bei Angabe einer Liste positiver Ganzzahlen truthyabwechselnd oder auf falsyandere Weise ausgegeben / zurückgegeben wird .

Das ist Code-Golf , also gewinnt der kürzeste Code (in Bytes)!

Edge Cases:

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

Andere Testfälle:

[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

Beispiel

Hier ist ein Beispiel, gegen das Sie Ihre Lösung testen können, geschrieben in Python 3 (nicht Golf):

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

Gelee , 4 Bytes

ḣ2ṁ⁼

Probieren Sie es online!

Wie es funktioniert

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

Brainfuck, 34 Bytes

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

Nimmt das Array als Byte-Werte in eine Zeichenfolge und gibt \x00für false und \x01für true aus.

Probieren Sie es online aus.

Dadurch bleibt die Struktur erhalten

a b 1 c

Auf dem Band cist das aktuelle Zeichen bdas vorherige Zeichen und adas vorherige vorherige Zeichen, solange sich das Array abwechselt. Wenn eine Nichtübereinstimmung festgestellt wird, wird der Zeiger nach links verschoben, sodass a, bund das 1Flag alle Null werden. Diese Situation wird fortgesetzt, bis alle Eingaben verbraucht sind.

R, 24 23 Bytes

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

Liest einen Vektor in STDIN, nimmt die ersten beiden Elemente dieses Vektors und überprüft die Gleichheit. Wenn die Längen von a[1:2]und a nicht übereinstimmen, durchläuft R die Schleife a[1:2], um der Länge von a zu entsprechen. Es wird eine Warnung dazu geben, aber es wird funktionieren.

Überraschenderweise funktioniert dies sogar für leere Eingaben, ich weiß nicht warum, aber ich werde damit rollen.

1 Byte dank @MickyT gespeichert

MATL , 7 6 Bytes

2YCs&=

Für alternierende Arrays gibt dies eine nicht leere Matrix von Einsen aus, was wahr ist. Bei nicht alternierenden Arrays enthält die Matrix mindestens eine Null und ist daher falsch (siehe hier ).

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Nehmen wir [1 2 1 2]als Beispiel die Eingabe.

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 Byte

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

Testfälle

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

Retina , 25 Bytes

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

Probieren Sie es online!

Anstatt eine Eingabe mit abwechselnden Werten abzugleichen (was in einem regulären Ausdruck zu störenden Kanteneffekten führt), stimme ich Eingaben zu, die nicht gültig sind, und negiere das Ergebnis anschließend.

Der Vorteil des Abgleichs einer ungültigen Eingabe besteht darin, dass diese Eigenschaft lokal überprüft werden kann und leere oder kurze Eingaben nicht speziell behandelt werden müssen: Jede Eingabe ist ungültig, wenn sie zwei unterschiedliche Werte enthält, die um eine Position voneinander entfernt sind.

Die erste Stufe zählt also die Anzahl der Übereinstimmungen, von \b(\d+),\d+,(?!\1\b)denen ein Wert übereinstimmt und erfasst wird, und stellt dann fest, dass der dritte Wert in Folge unterschiedlich ist. Dies ergibt Null für gültige Eingaben und etwas Positives für ungültige Werte.

Die zweite Stufe zählt einfach die Anzahl der Spiele von ^0denen ist , 1wenn die erste Stufe zurückgeführt 0und auf 1andere Weise.

Mathematica, 29 Bytes

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

Ein Port des MATL-Algorithmus von Luis Mendo. Unbenannte Funktion, die eine Liste von Zahlen (oder sogar allgemeineren Objekten) aufnimmt und Trueoder zurückgibt False. Prüft, ob die Summen aufeinanderfolgender Elemente alle gleich sind. Leider Mostund Restersticken auf der leeren Liste, so dass das separat getestet werden muss.

Mathematica, 33 Bytes

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

Unbenannte Funktion, die eine Liste von Zahlen (oder sogar allgemeineren Objekten) aufnimmt und Trueoder zurückgibt False. Die Funktion Differences[#,1,2]nimmt die Differenzen nicht aufeinanderfolgender Paare von ganzen Zahlen, sondern Paare von ganzen Zahlen im Abstand von zwei voneinander. Dann prüfen wir nur, ob die resultierende Liste nichts anderes als Nullen enthält.

Als Bonus erhalten wir für ein weiteres Byte (ändern Sie das 2in #2) eine Funktion, die eine Liste von ganzen Zahlen und eine andere positive ganze Zahl eingibt #2und prüft, ob die Eingabeliste das Ergebnis der #2periodischen Verschachtelung konstanter Sequenzen miteinander ist. Zum Beispiel,

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

bewertet zu True.

Haskell, 27 26 Bytes

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

Dies wird zu einer anonymen Funktion ausgewertet, die die Herausforderung löst. Die Idee ist, die ersten beiden Zahlen aus der Liste zu entfernen, mit der ursprünglichen Liste mit Gleichheit zu zippen und zu überprüfen, ob das Ergebnis nur Trues enthält . Probieren Sie es online!

Danke an nimi für 1 Byte!

Netzhaut ,39 32 28 Bytes

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

Probieren Sie es online!

7 Bytes gespart dank Martin ! 3 weitere dank Kobi gerettet ! Und zu Kritixi für eine Idee für eine andere 1.

Optional passen wir eine Zahl an, die die gesamte Eingabe belegt, ein beliebiges Zahlenpaar oder ein beliebiges Zahlenpaar, gefolgt von demselben Zahlenpaar, und optional wird die zweite Zahl ganz am Ende nicht eingeschlossen. Konnte 2 Bytes speichern, wenn die Eingabe unär war.

Pyth, 9 Bytes

q<*<Q2lQl

Erläuterung

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 Bytes

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

Probieren Sie es online!

Erläuterung

:{         }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 Bytes

⊢≡⍴⍴2⍴⊢

Erläuterung:

• 2⍴⊢: Verändern Sie das Eingabearray um 2
• ⍴⍴: Verändern Sie das Ergebnis um die ursprüngliche Größe der Eingabe, indem Sie Elemente wiederholen
• ⊢≡: Überprüfen Sie, ob das Ergebnis der ursprünglichen Eingabe entspricht

Testfälle:

      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 Bytes

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

Dies ist ein Lambda-Ausdruck für a Predicate< int[ ] >

Erläuterung: Initialisieren Sie das Ergebnis auf 0. Für jedes Element gibt Biteise ODER das Ergebnis mit der Differenz zwischen dem aktuellen Element und dem Element 2 früher an. return truewenn das Ergebnis gleich 0 ist. Andernfalls returnfalse

Perl 6 ,  49 43  42 Bytes

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

Versuch es

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

Versuch es

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

Versuch es

Erweitert:

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

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

Probieren Sie es online!

J, 8 Bytes

-:$$2&{.

Erläuterung

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

Testfälle

   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 Bytes

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

Probieren Sie es online! oder Überprüfen Sie die Testfälle. -1 Byte dank Zgarb.

Bash, 56 54 38 Bytes

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

Speichern Sie dies als Skript und übergeben Sie die Liste der Zahlen als Argumente (bei einer Liste mit n Elementen übergeben Sie n Argumente). Die Ausgabe ist der Exit-Code: 0 (für true), wenn sich die Liste abwechselt, und 1 (für false), wenn sich die Liste abwechselt.

(Die Rückgabe von Ausgaben im Exit-Code ist in den PPCG-Standard-E / A-Methoden zulässig.)

Das funktioniert rekursiv:

• Wenn die Liste weniger als 3 Elemente enthält, beenden Sie sie mit dem Rückkehrcode 0.
• sonst wenn das 1. Element! = das 3. Element, dann mit Returncode 1 beenden;
• Führen Sie das Programm ansonsten rekursiv in der Liste aus, wobei das erste Element entfernt wird.

Python 2.7, 38 Bytes

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

Testfälle:

>> 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 Bytes, nicht konkurrierend

2<Ql{q

Probieren Sie es hier aus!

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

Ermöglichen Sie dem Umformknoten, eine Liste sowie eine Zeichenfolge aufzunehmen

Shenzen IO (Assembler), 83 76 Bytes, nicht konkurrierend

Shenzen io ist ein Puzzlespiel, bei dem Sie Ihren Code in einer speziellen Assemblersprache codieren können.

Leider können Sie nur Ganzzahlen zwischen -999 und 999 als Ein- oder Ausgänge verwenden, und Sie können nicht feststellen, ob ein Array beendet wurde. Also nahm ich an, dass das Array auf einem ROM geschrieben wurde, der sich nach dem Lesen der letzten Zelle umläuft. Dies bedeutet, dass nur gerade Arrays verwendet werden können, weshalb keine Konkurrenz besteht.

Code:

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

Erläuterung:

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

Tut mir leid, wenn dies verwirrend ist, ist dies meine erste Code-Golf-Antwort.

BEARBEITEN: 7 Bytes wurden entfernt, indem Schleifen durch einmaligen Code ersetzt wurden

Ruby, 23 Bytes

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

Rubin, 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 aerwartet ein Array xund gibt true zurück, wenn 0 oder 1 eindeutige Werte für die ungeraden indizierten Elemente und 0 oder 1 eindeutige Werte für die geraden indizierten Elemente im Array vorhanden sind.

Bemerkenswerte Byte-Safer

• Verwendung von Lambda über def
• !arr[1] gegen arr.length < 2
• & vs &&

Testfälle

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 Bytes

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

Laufen mit:

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 Bytes

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

Filterarray, um Werte anzuzeigen, die nicht mit dem ersten Wert für "Evens" und dem zweiten Wert für "Odds" übereinstimmen. Wenn keine Ergebnisse vorliegen, geben Sie true zurück.

Japt, 7 6 Bytes

eUîU¯2

Probieren Sie es aus oder führen Sie alle Testfälle aus

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

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

Anonyme Funktion, die ein ganzzahliges Array empfängt und 1 zurückgibt, wenn sich das Array abwechselt, andernfalls 0.

Volles Programm mit ungolfed Funktion und Testfällen:

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

Oktave, 51 Bytes

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

Die Eingabe ist ein Zellenarray positiver Ganzzahlen.

Probieren Sie es online!

Clojure, 70 Bytes

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

Überprüft, ob die eindeutige Anzahl jedes zweiten Elements 1 beträgt, und behandelt leere Sammlungen als Sonderfall. Habe auch viele Ansätze ausprobiert reduceund da group-byaber nicht viel Glück gehabt.

Eine weitere Option mit R: 36 Bytes.

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

Und ich denke, ich habe eine viel kürzere Version gefunden: 15 Bytes

all(!diff(x,2))