교대 배열

교대 배열 두 (반드시 다르지 않은) 값이 교번하는 길이의리스트이다. 즉, 모든 짝수 색인 항목이 같고 모든 홀수 색인 항목이 동일합니다.

당신의 임무는 양의 정수 목록이 주어 truthy지면 그것이 번갈아 가거나 falsy그렇지 않으면 출력 / 반환하는 프로그램이나 함수를 작성하는 것입니다 .

이것은 code-golf 이므로 가장 짧은 코드 (바이트)가 이깁니다!

가장자리 케이스 :

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

젤리 , 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.

brainfuck, 34 바이트

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

배열을 문자열의 바이트 값으로 사용하여 \x00false 및 \x01true로 출력 합니다.

온라인으로 사용해보십시오.

이것은 구조를 유지

a b 1 c

테이프에 c현재 문자, b이전 문자이며, a한 어레이가 교대로 한, 이전 이전 문자이다. 불일치가 발견되면, 포인터는 왼쪽 등으로 이동 a, b및 1플래그가 모두 0이되고, 모든 입력이 소모 될 때까지이 상황이 계속됩니다.

R, 24 23 바이트

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

STDIN으로 벡터를 읽고 해당 벡터의 처음 두 요소를 가져와 동등성을 확인합니다. 길이 a[1:2]와 길이가 일치하지 않으면 R은 a[1:2]a의 길이와 일치하도록 반복됩니다 . 그렇게하는 것에 대한 경고를 주지만 작동합니다.

놀랍게도 이것은 빈 입력에도 작동하지만 이유는 확실하지 않지만 그와 함께 굴릴 것입니다.

@MickyT 덕분에 1 바이트 절약

MATL , 7 6 바이트

2YCs&=

교대 배열의 경우 비어 있지 않은 행렬을 출력합니다. 비 대체 배열의 경우 행렬에 적어도 하나의 0이 포함되므로 거짓입니다 ( 여기 참조 ).

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

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

자바 스크립트 (ES6), 27 바이트

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

테스트 사례

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

망막 , 25 바이트

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

온라인으로 사용해보십시오!

입력 값을 교대하는 값과 일치시키는 대신 (정규식에서 성가신 가장자리 효과를 유발 함) 유효 하지 않은 입력을 일치시킨 다음 결과를 무효화합니다.

유효하지 않은 입력을 일치시키는 이점은 속성을 로컬에서 확인할 수 있으며 비어 있거나 짧은 입력을 특수하게 처리 할 필요가 없다는 것입니다. 입력이 한 위치 떨어져있는 두 개의 고유 한 값을 포함하는 경우 입력이 유효하지 않습니다.

따라서 첫 번째 단계는 일치하는 수를 계산하여 \b(\d+),\d+,(?!\1\b)하나의 값을 캡처 한 후 다음 값을 일치시킨 다음 순서대로 세 번째 값이 다르다고 주장합니다. 이것은 유효한 입력에 대해 0을 제공하고 유효하지 않은 값에 긍정적 인 것을 제공합니다.

두 번째 단계는 단순히의 일치의 수를 계산 ^0하는 것입니다 1첫 번째 단계가 반환하는 경우 0와 1그렇지 않은 경우.

매스 매 티카, 29 바이트

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

Luis Mendo의 MATL 알고리즘 포트. 이름이없는 함수 (숫자 또는 더 일반적인 개체) 목록을 가져 와서 반환 True또는 False. 연속 요소의 합이 모두 같은지 테스트합니다. 불행하게도 Most과 Rest그 개별적으로 테스트해야하므로, 빈리스트에 질식.

수학, 33 바이트

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

이름이없는 함수 (숫자 또는 더 일반적인 개체) 목록을 가져 와서 반환 True또는 False. 이 함수 Differences[#,1,2]는 연속적인 정수 쌍이 아니라 거리가 2 인 정수 쌍의 차이를 취합니다 . 그런 다음 결과 목록에 0 이외의 것이 없는지 확인합니다.

보너스로서, 하나 이상의 바이트에 대해 (변화 2로를 #2), 우리는 함수를 얻을 입력 정수 다른 양의 정수 목록 #2입력리스트가 인터리빙의 결과인지 여부를 체크 #2주기적으로 서로 일정한 시퀀스. 예를 들어

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

로 평가됩니다 True.

하스켈, 27 26 바이트

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

이것은 문제를 해결하는 익명 함수로 평가됩니다. 아이디어는 목록에서 처음 두 숫자를 삭제하고, 동일성을 사용하여 원래 목록으로 압축하고 결과에 Trues 만 포함되어 있는지 확인하는 것 입니다. 온라인으로 사용해보십시오!

1 바이트의 nimi 덕분에!

망막 ,39 32 28 바이트

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

온라인으로 사용해보십시오!

Martin 덕분에 7 바이트가 절약되었습니다 ! Kobi 덕분에 3을 더 절약했습니다 ! 그리고 Kritixi 에게 또 다른 아이디어 1.

우리는 선택적으로 전체 입력, 임의의 숫자 쌍 또는 임의의 숫자 쌍을 뒤 따르는 숫자와 일치하는 숫자를 여러 번 일치시키고 선택적으로 맨 끝에 두 번째 숫자를 포함하지 않습니다. 입력이 단항 인 경우 2 바이트를 절약 할 수 있습니다.

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

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

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

자바 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 OR 현재 요소와 요소 2의 차이가 이전 인 결과. true결과가 0이면 리턴. 그렇지 않으면 리턴false

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

시도 해봐

넓히는:

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

파이썬 2 , 35 바이트

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

온라인으로 사용해보십시오!

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

하스켈 , 33 32 바이트

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

온라인으로 사용해보십시오! 또는 테스트 케이스를 확인하십시오. Zgarb 덕분에 -1 바이트.

bash, 56 54 38 바이트

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

이것을 스크립트로 저장하고 숫자 목록을 인수로 전달하십시오 (n 요소 목록의 경우 n 인수를 전달합니다). 출력은 종료 코드입니다. 목록이 번갈아 가면 0 (참의 경우), 그렇지 않으면 1 (거짓의 경우)입니다.

(종료 코드의 리턴 출력은 PPCG 표준 I / O 메소드에서 허용됩니다.)

이것은 재귀 적으로 작동합니다.

• 리스트의 요소가 3보다 작 으면 리턴 코드 0으로 종료하십시오.
• 그렇지 않으면 첫 번째 요소! = 세 번째 요소이면 리턴 코드 1로 종료하십시오.
• 그렇지 않으면 첫 번째 요소가 제거 된 목록에서 프로그램을 재귀 적으로 실행하십시오.

파이썬 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

파이크, 6 바이트, 비경쟁

2<Ql{q

여기 사용해보십시오!

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

변형 노드가 문자열뿐만 아니라 목록을 가져 오도록 허용

Shenzen IO (어셈블러), 83 76 바이트, 비경쟁

Shenzen io는 특별한 어셈블러 언어로 코딩 할 수있는 퍼즐 게임입니다.

불행히도 입력 또는 출력으로 -999에서 999 사이의 정수만 사용할 수 있으며 배열이 종료되었는지 알 수있는 방법이 없습니다. 그래서 마지막 셀을 읽은 후 랩핑되는 ROM에 배열이 작성되었다고 가정했습니다. 즉, 심지어 짝수 배열 만 사용할 수 있으며 이는 경쟁이되지 않는 이유입니다.

암호:

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

혼란스러운 점이 있으면 이것이 첫 번째 코드 골프 답변입니다.

편집 : 1 회 실행 코드로 루프를 교체하여 7 바이트 제거

루비, 23 바이트

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

루비, 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])}

Lambda a는 배열을 예상 x하고 홀수 인덱스 요소에 대해 0 또는 1 개의 고유 값이 있고 배열 에 짝수 인덱스 요소에 대해 0 또는 1 개의 고유 값이 있으면 true를 반환합니다.

주목할만한 바이트 안전

• 람다 사용 def
• !arr[1] vs. arr.length < 2
• & vs &&

테스트 사례

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

다트, 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]));
}

C #, 54 바이트

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

짝수의 첫 번째 값과 승산의 두 번째 값과 일치하지 않는 값을 표시하도록 필터 배열을 필터링하십시오. 결과가 없으면 true를 리턴하십시오.

apt, 7 6 바이트

eUîU¯2

사용해 보거나 모든 테스트 사례를 실행하십시오.

           :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 바이트

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

옥타브, 51 바이트

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

입력은 양의 정수로 구성된 셀형 배열입니다.

온라인으로 사용해보십시오!

클로저, 70 바이트

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

모든 두 번째 항목의 고유 수가 1인지 확인하고 빈 컬렉션을 특수한 경우로 처리합니다. 또한 기반으로 다양한 접근을 시도 reduce하고 group-by있지만 많은 행운이.

R의 다른 옵션 : 36 바이트

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

그리고 나는 훨씬 짧은 버전을 발견했다고 생각합니다 : 15 바이트

all(!diff(x,2))