Array Bergantian

Array bolak - balik adalah daftar panjang berapa pun di mana dua (tidak harus berbeda) nilai berganti-ganti. Dengan kata lain, semua item yang diindeks sama adalah sama, dan semua item yang diindeks sama adalah sama.

Tugas Anda adalah menulis sebuah program atau fungsi yang, ketika diberi daftar bilangan bulat positif, menghasilkan / mengembalikan truthyjika bolak-balik dan falsysebaliknya.

Ini adalah kode-golf , jadi kode terpendek (dalam byte) menang!

Kasus tepi:

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

Kasus Uji lainnya:

[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

Contoh

Berikut ini adalah contoh yang dapat Anda uji terhadap solusi Anda, yang ditulis dengan Python 3 (bukan golf):

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

Jelly , 4 byte

ḣ2ṁ⁼

Cobalah online!

Bagaimana itu bekerja

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

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

Mengambil array sebagai nilai byte dalam sebuah string, dan output \x00untuk false dan \x01true.

Cobalah online.

Ini mempertahankan struktur

a b 1 c

pada kaset, di mana ckarakter saat ini, badalah karakter sebelumnya, dan amerupakan karakter sebelumnya sebelumnya, selama array berganti-ganti. Jika ketidakcocokan ditemukan, pointer tersebut akan dipindahkan ke sebelah kiri sehingga a, b, dan 1bendera semua menjadi nol, dan situasi ini akan berlanjut sampai semua masukan yang dikonsumsi.

R, 24 23 byte

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

Membaca vektor ke dalam STDIN, mengambil dua elemen pertama dari vektor itu, dan memeriksa kesetaraan. Jika panjang a[1:2]dan tidak cocok, R akan mengulang a[1:2]untuk mencocokkan panjang a. Ini akan memberi peringatan tentang hal itu, tetapi itu akan berhasil.

Anehnya ini bahkan berfungsi untuk input kosong, tidak yakin mengapa, tapi saya akan menggulungnya.

Disimpan 1 byte berkat @MickyT

MATL , 7 6 byte

2YCs&=

Untuk array bolak-balik ini menghasilkan matriks yang tidak kosong, yang benar. Untuk array non-bolak-balik, matriks berisi setidaknya satu nol, dan karenanya palsu (lihat di sini ).

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

Mari kita ambil [1 2 1 2]contoh input.

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)

Uji kasus

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 byte

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

Cobalah online!

Alih-alih mencocokkan input dengan nilai bolak-balik (yang mengarah ke beberapa efek tepi yang mengganggu dalam regex), saya mencocokkan input yang tidak valid dan kemudian meniadakan hasilnya setelah itu.

Manfaat dari mencocokkan input yang tidak valid adalah bahwa ini adalah properti yang dapat diperiksa secara lokal, dan tidak perlu memperlakukan input kosong atau pendek secara khusus: input apa pun tidak valid jika berisi dua nilai berbeda yang terpisah satu posisi.

Jadi tahap pertama menghitung jumlah kecocokan \b(\d+),\d+,(?!\1\b)yang cocok dan menangkap satu nilai, kemudian cocok dengan nilai berikutnya, dan kemudian menegaskan bahwa nilai ketiga secara berurutan berbeda. Ini memberikan nol untuk input yang valid dan sesuatu yang positif untuk nilai yang tidak valid.

Tahap kedua hanya menghitung jumlah pertandingan ^0yang 1jika tahap pertama kembali 0dan 1sebaliknya.

Mathematica, 29 byte

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

Sebuah pelabuhan dari algoritma MATL Luis Mendo. Fungsi yang tidak disebutkan namanya mengambil daftar angka (atau bahkan objek yang lebih umum) dan mengembalikan Trueatau False. Menguji apakah jumlah elemen berurutan semuanya sama. Sayangnya Mostdan Resttersedak daftar kosong, sehingga harus diuji secara terpisah.

Mathematica, 33 byte

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

Fungsi yang tidak disebutkan namanya mengambil daftar angka (atau bahkan objek yang lebih umum) dan mengembalikan Trueatau False. Fungsi Differences[#,1,2]mengambil perbedaan, bukan dari pasangan integer yang berurutan , tetapi pasangan integer pada jarak dua terpisah. Kemudian kami hanya memeriksa apakah daftar yang dihasilkan tidak memiliki apa pun selain nol di dalamnya.

Sebagai bonus, untuk satu byte lagi (ubah 2ke #2), kita mendapatkan fungsi yang memasukkan daftar bilangan bulat dan bilangan bulat positif lainnya #2, dan memeriksa apakah daftar input adalah hasil dari #2urutan konstan interleaving secara berkala satu sama lain. Sebagai contoh,

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

mengevaluasi ke True .

Haskell, 27 26 byte

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

Ini mengevaluasi ke fungsi anonim yang memecahkan tantangan. Idenya adalah untuk menjatuhkan dua angka pertama dari daftar, zip dengan daftar asli menggunakan kesetaraan, dan periksa bahwa hasilnya hanya berisiTrue s. Cobalah online!

Terima kasih kepada nimi untuk 1 byte!

Retina ,39 32 28 byte

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

Cobalah online!

Disimpan 7 byte berkat Martin ! Menyelamatkan 3 lainnya berkat Kobi ! Dan untuk Kritixi untuk ide 1 lainnya.

Kami secara opsional mencocokkan angka yang menempati seluruh input, pasangan angka apa pun, atau pasangan angka apa pun yang diikuti oleh pasangan yang sama beberapa kali dan secara opsional tidak termasuk angka kedua di bagian paling akhir. Bisa menghemat 2 byte jika inputnya di unary.

Pyth, 9 byte

q<*<Q2lQl

Penjelasan

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 byte

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

Cobalah online!

Penjelasan

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

⊢≡⍴⍴2⍴⊢

Penjelasan:

• 2⍴⊢: membentuk kembali array input dengan 2
• ⍴⍴: membentuk kembali hasil dengan ukuran asli input, elemen berulang
• ⊢≡: lihat apakah hasil yang sama dengan input asli

Kasus uji:

      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 byte

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

Ini adalah ungkapan lambda untuk a Predicate< int[ ] >

Penjelasan: inisialisasi hasil ke 0. Untuk setiap elemen, Gigit ATAU hasilnya dengan perbedaan antara elemen saat ini dan indeks elemen 2 sebelumnya. kembali truejika hasilnya sama dengan 0. Kalau tidak kembalifalse

Perl 6 ,  49 43  42 byte

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

Cobalah

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

Cobalah

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

Cobalah

Diperluas:

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

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

Cobalah online!

J, 8 byte

-:$$2&{.

Penjelasan

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

Uji kasus

   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 byte

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

Cobalah online! atau Verifikasi testcases. -1 byte terima kasih kepada Zgarb.

bash, 56 54 38 byte

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

Simpan ini sebagai skrip, dan berikan daftar angka sebagai argumen (untuk daftar n-elemen, Anda akan melewatkan n argumen). Outputnya adalah kode keluar: 0 (untuk true) jika daftar berganti-ganti, dan 1 (untuk false) sebaliknya.

(Mengembalikan output dalam kode keluar diperbolehkan dalam metode I / O standar PPCG.)

Ini bekerja secara rekursif:

• Jika daftar memiliki kurang dari 3 elemen, maka keluar dengan kode pengembalian 0;
• lain jika elemen 1! = elemen ke-3, lalu keluar dengan kode pengembalian 1;
• lain menjalankan program secara rekursif pada daftar dengan elemen pertama dihapus.

Python 2.7, 38 byte

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

Kasus uji:

>> 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 byte, tidak bersaing

2<Ql{q

Coba di sini!

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

Izinkan membentuk kembali simpul untuk mengambil daftar serta string

Shenzen IO (Assembler), 83 76 byte, tidak bersaing

Shenzen io adalah game puzzle tempat Anda dapat membuat kode dengan kode dalam bahasa assembler-ish khusus.

Sayangnya, Anda hanya dapat menggunakan bilangan bulat antara -999 dan 999 sebagai input atau output, dan tidak ada cara untuk mengetahui apakah array telah berakhir. Jadi saya berasumsi bahwa array ditulis pada ROM yang membungkus setelah membaca sel terakhir. Ini berarti bahwa hanya array yang dapat digunakan, yang merupakan alasan untuk tidak bersaing.

Kode:

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

Penjelasan:

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

Maaf jika semua ini membingungkan, ini adalah jawaban kode-golf pertama saya.

EDIT: dihapus 7 byte dengan mengganti loop dengan kode run-once

Ruby, 23 byte

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

Ruby, 131 119 byte

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 amengharapkan array xdan mengembalikan true jika ada 0 atau 1 nilai unik untuk elemen indeks aneh dan 0 atau 1 nilai unik untuk elemen diindeks bahkan dalam array.

Pengaman byte yang penting

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

Uji kasus

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 byte

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

Jalankan dengan:

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 byte

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

Filter array untuk menunjukkan nilai-nilai yang tidak cocok dengan nilai pertama untuk rata dan nilai 2 untuk peluang. Jika tidak ada hasil, kembalikan benar.

Japt, 7 6 byte

eUîU¯2

Cobalah atau jalankan semua test case

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

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

Fungsi anonim yang menerima array integer dan mengembalikan 1 jika array bergantian dan 0 sebaliknya.

Program lengkap dengan fungsi dan uji kasus yang tidak dikoleksi:

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

Oktaf, 51 byte

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

Input adalah array sel bilangan bulat positif.

Cobalah online!

Clojure, 70 byte

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

Periksa bahwa hitungan berbeda dari setiap item ke-2 adalah 1, dan menangani koleksi kosong sebagai kasing khusus. Juga mencoba banyak pendekatan berdasarkan reducedan group-bytetapi tidak banyak keberuntungan di sana.

Pilihan lain dengan R: 36 byte.

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

Dan saya pikir saya telah menemukan versi yang jauh lebih pendek: 15 byte

all(!diff(x,2))