Mảng xen kẽ

Một mảng xen kẽ là một danh sách của bất kỳ chiều dài, trong đó hai giá trị (không nhất thiết phải khác nhau) là xen kẽ. Điều đó có nghĩa là, tất cả các mục được lập chỉ mục chẵn đều bằng nhau và tất cả các mục được lập chỉ mục lẻ đều bằng nhau.

Nhiệm vụ của bạn là viết một chương trình hoặc hàm, khi được đưa ra một danh sách các số nguyên dương, đầu ra / trả về truthynếu nó xen kẽ và falsyngược lại.

Đây là mã golf , vì vậy mã ngắn nhất (tính bằng byte) sẽ thắng!

Vỏ cạnh:

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

Các trường hợp thử nghiệm khác:

[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

Thí dụ

Dưới đây là một ví dụ bạn có thể kiểm tra giải pháp của mình, được viết bằng Python 3 (không được đánh gôn):

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

Thạch , 4 byte

ḣ2ṁ⁼

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ḣ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

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

Lấy mảng dưới dạng các giá trị byte trong một chuỗi và xuất ra \x00sai và \x01đúng.

Hãy thử trực tuyến.

Điều này duy trì cấu trúc

a b 1 c

trên băng, cký tự hiện tại blà ký tự trước và alà ký tự trước đó, miễn là mảng đó xen kẽ. Nếu không phù hợp được tìm thấy, con trỏ được chuyển đến như trái mà a, bvà 1cờ tất cả trở thành số không, và tình trạng này sẽ tiếp tục cho đến khi tất cả các đầu vào được tiêu thụ.

R, 24 23 byte

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

Đọc một vectơ vào STDIN, lấy hai phần tử đầu tiên của vectơ đó và kiểm tra sự bằng nhau. Nếu độ dài a[1:2]và không khớp, R sẽ lặp a[1:2]lại để khớp với độ dài của a. Nó sẽ đưa ra một cảnh báo về việc làm như vậy, nhưng nó sẽ hoạt động.

Đáng ngạc nhiên là điều này thậm chí hoạt động cho đầu vào trống, không biết tại sao, nhưng tôi sẽ lăn với nó.

Đã lưu 1 byte nhờ @MickyT

MATL , 7 6 byte

2YCs&=

Đối với các mảng xen kẽ, điều này tạo ra một ma trận không trống, đó là sự thật. Đối với các mảng không xen kẽ, ma trận chứa ít nhất một số 0 và do đó là sai lệch (xem tại đây ).

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Hãy lấy [1 2 1 2]ví dụ đầu vào.

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)

Các trường hợp thử nghiệm

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

Võng mạc , 25 byte

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

Hãy thử trực tuyến!

Thay vì khớp đầu vào với các giá trị xen kẽ (dẫn đến một số hiệu ứng cạnh khó chịu trong regex), tôi khớp các đầu vào không hợp lệ và sau đó phủ nhận kết quả sau đó.

Lợi ích của việc khớp đầu vào không hợp lệ là đây là một thuộc tính có thể được kiểm tra cục bộ và không cần xử lý đặc biệt đầu vào trống hoặc ngắn: bất kỳ đầu vào nào không hợp lệ nếu nó chứa hai giá trị riêng biệt cách nhau một vị trí.

Vì vậy, giai đoạn đầu tiên đếm số lượng các trận đấu \b(\d+),\d+,(?!\1\b)khớp và bắt một giá trị, sau đó khớp với giá trị tiếp theo và sau đó khẳng định rằng giá trị thứ ba trong chuỗi là khác nhau. Điều này cho không cho các đầu vào hợp lệ và một cái gì đó tích cực cho các giá trị không hợp lệ.

Giai đoạn thứ hai chỉ đơn giản là đếm số trận đấu trong ^0đó 1nếu giai đoạn đầu tiên trở lại 0và 1ngược lại.

Toán học, 29 byte

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

Một cổng của thuật toán MATL của Luis Mendo. Hàm không tên lấy danh sách các số (hoặc thậm chí nhiều đối tượng tổng quát hơn) và trả về Truehoặc False. Kiểm tra xem tổng các phần tử liên tiếp có bằng nhau không. Thật không may Mostvà Restbị sặc trong danh sách trống, do đó phải được kiểm tra riêng.

Toán học, 33 byte

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

Hàm không tên lấy danh sách các số (hoặc thậm chí nhiều đối tượng tổng quát hơn) và trả về Truehoặc False. Hàm Differences[#,1,2]lấy sự khác biệt, không phải của các cặp số nguyên liên tiếp , mà là các cặp số nguyên cách nhau hai khoảng cách. Sau đó, chúng tôi chỉ kiểm tra xem danh sách kết quả có gì khác ngoài số không trong đó không.

Như một phần thưởng, để có thêm một byte (thay đổi 2thành #2), chúng ta có một hàm nhập danh sách các số nguyên và một số nguyên dương khác #2, và kiểm tra xem danh sách đầu vào có phải là kết quả của các #2chuỗi liên tục xen kẽ với nhau không. Ví dụ,

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

đánh giá để True.

Haskell, 27 26 byte

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

Điều này đánh giá một chức năng ẩn danh để giải quyết thách thức. Ý tưởng là bỏ hai số đầu tiên khỏi danh sách, zip với danh sách ban đầu bằng cách sử dụng đẳng thức và kiểm tra xem kết quả chỉ chứa Trues. Hãy thử trực tuyến!

Cảm ơn nimi cho 1 byte!

Võng mạc ,39 32 28 byte

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

Hãy thử trực tuyến!

Đã lưu 7 byte nhờ Martin ! Cứu 3 người nữa nhờ Kobi ! Và đến Kritixi cho một ý tưởng cho 1.

Chúng tôi tùy ý khớp một số chiếm toàn bộ đầu vào, bất kỳ cặp số nào hoặc bất kỳ cặp số nào theo sau cùng một cặp bất kỳ số lần nào và tùy chọn không bao gồm số thứ hai ở cuối. Có thể lưu 2 byte nếu đầu vào là unary.

Bình thường, 9 byte

q<*<Q2lQl

Giải trình

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

Hãy thử trực tuyến!

Giải trình

:{         }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⍴⊢

Giải trình:

• 2⍴⊢: định hình lại mảng đầu vào bằng 2
• ⍴⍴: định hình lại kết quả theo kích thước ban đầu của các yếu tố đầu vào, lặp lại
• ⊢≡: xem kết quả của nó có bằng với đầu vào ban đầu không

Các trường hợp thử nghiệm:

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

Đây là một biểu thức lambda cho một Predicate< int[ ] >

Giải thích: khởi tạo kết quả thành 0. Đối với mỗi phần tử, Biteise HOẶC kết quả có sự khác biệt giữa phần tử hiện tại và phần tử 2 chỉ ra trước đó. trả về truenếu kết quả bằng 0. Nếu không trả vềfalse

Perl 6 ,  49 43  42 byte

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

Thử nó

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

Thử nó

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

Thử nó

Mở rộng:

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

Hãy thử trực tuyến!

J, 8 byte

-:$$2&{.

Giải trình

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

Các trường hợp thử nghiệm

   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

Hãy thử trực tuyến! hoặc Xác nhận các testcase. -1 byte nhờ Zgarb.

bash, 56 54 38 byte

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

Lưu phần này dưới dạng tập lệnh và chuyển danh sách các số làm đối số (đối với danh sách phần tử n, bạn sẽ chuyển n đối số). Đầu ra là mã thoát: 0 (cho đúng) nếu danh sách xen kẽ và 1 (cho sai) nếu không.

(Cho phép trả lại đầu ra trong mã thoát được cho phép trong các phương thức I / O tiêu chuẩn PPCG.)

Điều này hoạt động đệ quy:

• Nếu danh sách có ít hơn 3 phần tử, thì thoát với mã trả về 0;
• khác nếu phần tử thứ 1! = phần tử thứ 3, sau đó thoát với mã trả về 1;
• khác chạy chương trình đệ quy trong danh sách với phần tử đầu tiên bị loại bỏ.

Python 2.7, 38 byte

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

Các trường hợp thử nghiệm:

>> 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, không biên dịch

2<Ql{q

Hãy thử nó ở đây!

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

Cho phép định hình lại nút để lấy danh sách cũng như chuỗi

Shenzen IO (Trình biên dịch), 83 76 byte, không lọc

Shenzen io là một trò chơi giải đố trong đó bạn có thể viết mã cho mình bằng một ngôn ngữ lắp ráp đặc biệt.

Thật không may, bạn chỉ có thể sử dụng các số nguyên trong khoảng từ -999 đến 999 làm đầu vào hoặc đầu ra và không có cách nào để biết liệu một mảng đã kết thúc hay chưa. Vì vậy, tôi giả sử rằng mảng được ghi trên ROM bao quanh sau khi đọc ô cuối cùng. Điều này có nghĩa là chỉ các mảng thậm chí có thể được sử dụng, đó là lý do cho việc nó không được lọc.

Mã số:

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

Giải trình:

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

Xin lỗi nếu bất kỳ điều này là khó hiểu, đây là câu trả lời golf-code đầu tiên của tôi.

EDIT: loại bỏ 7 byte bằng cách thay thế các vòng lặp bằng mã 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 among đợi một mảng xvà trả về true nếu có 0 hoặc 1 giá trị duy nhất cho các phần tử được lập chỉ mục lẻ và 0 hoặc 1 giá trị duy nhất cho các phần tử được lập chỉ mục chẵn trong mảng.

Bộ bảo vệ byte đáng chú ý

• sử dụng lambda hơn def
• !arr[1] so với arr.length < 2
• & đấu với &&

Các trường hợp thử nghiệm

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

Phi tiêu, 46 byte

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

Chạy với:

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

Mảng lọc để hiển thị các giá trị không khớp với giá trị đầu tiên cho evens và giá trị thứ 2 cho tỷ lệ cược. Nếu không có kết quả, trả về đúng.

Japt, 7 6 byte

eUîU¯2

Hãy thử nó hoặc chạy tất cả các trường hợp thử nghiệm

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

Hàm ẩn danh nhận một mảng nguyên và trả về 1 nếu mảng xen kẽ và 0 khác.

Chương trình đầy đủ với chức năng vô căn cứ và các trường hợp thử nghiệm:

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

Octave, 51 byte

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

Đầu vào là một mảng các số nguyên dương.

Hãy thử trực tuyến!

Clojure, 70 byte

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

Kiểm tra xem số lượng riêng biệt của mỗi mục thứ 2 là 1 và xử lý các bộ sưu tập trống dưới dạng trường hợp đặc biệt. Cũng đã thử nhiều cách tiếp cận dựa trên reducevà group-bykhông có nhiều may mắn ở đó.

Một tùy chọn khác với R: 36 byte.

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

Và tôi nghĩ rằng tôi đã tìm thấy một phiên bản ngắn hơn nhiều: 15 byte

all(!diff(x,2))