소개

0 에서 r-1 사이의 숫자를 가진 눈금자가 있다고 가정하십시오 . 두 숫자 사이에 개미를 놓으면 눈금자에서 이상하게 기어 가기 시작합니다. 통치자는 너무 좁아서 개미가 사이의 모든 숫자를 걷지 않고 한 위치에서 다른 위치로 걸을 수 없습니다. 개미가 처음으로 숫자를 걸을 때 기록하면 r 숫자 의 순열이 나타납니다. 우리는 순열이라고 말할 불안해 가 이런 식으로 개미에 의해 생성 될 수있는 경우. 대안 적으로, 첫 번째 항목을 제외한 모든 항목 p [i] 가 이전 항목과의 거리 1 내에 있으면 순열 p 는 anty 입니다.

예

길이 -6 순열

4, 3, 5, 2, 1, 0

때문에 불안해 인 3 거리 (1) 내에 도 4 , 도 5 의 거리 (1) 내에 4 , (2) 으로부터의 거리 (1) 내 (3) , (1) 로부터의 거리 (1) 내에 2 , 및 0 으로부터의 거리 (1) 내에 1 . 순열

3, 2, 5, 4, 1, 0

5 는 3 또는 2 의 거리 1 내에 있지 않기 때문에 개미 가 아니며 ; 개미는 4 를 통과 해야 5 에 도달합니다 .

작업

에서 숫자의 치환을 감안 0 에 R-1 일부 1 개 ≤ R ≤ 100 어떤 적당한 형식으로 출력 순열 불안해 인 경우 truthy 값 및 falsy 값 아니라면.

테스트 사례

[0] -> True
[0, 1] -> True
[1, 0] -> True
[0, 1, 2] -> True
[0, 2, 1] -> False
[2, 1, 3, 0] -> True
[3, 1, 0, 2] -> False
[1, 2, 0, 3] -> True
[2, 3, 1, 4, 0] -> True
[2, 3, 0, 4, 1] -> False
[0, 5, 1, 3, 2, 4] -> False
[6, 5, 4, 7, 3, 8, 9, 2, 1, 0] -> True
[4, 3, 5, 6, 7, 2, 9, 1, 0, 8] -> False
[5, 2, 7, 9, 6, 8, 0, 4, 1, 3] -> False
[20, 13, 7, 0, 14, 16, 10, 24, 21, 1, 8, 23, 17, 18, 11, 2, 6, 22, 4, 5, 9, 12, 3, 15, 19] -> False
[34, 36, 99, 94, 77, 93, 31, 90, 21, 88, 30, 66, 92, 83, 42, 5, 86, 11, 15, 78, 40, 48, 22, 29, 95, 64, 97, 43, 14, 33, 69, 49, 50, 35, 74, 46, 26, 51, 75, 87, 23, 85, 41, 98, 82, 79, 59, 56, 37, 96, 45, 17, 32, 91, 62, 20, 4, 9, 2, 18, 27, 60, 63, 25, 61, 76, 1, 55, 16, 8, 6, 38, 54, 47, 73, 67, 53, 57, 7, 72, 84, 39, 52, 58, 0, 89, 12, 68, 70, 24, 80, 3, 44, 13, 28, 10, 71, 65, 81, 19] -> False
[47, 48, 46, 45, 44, 49, 43, 42, 41, 50, 40, 39, 38, 51, 37, 36, 52, 35, 34, 33, 32, 53, 54, 31, 30, 55, 56, 29, 28, 57, 58, 59, 60, 27, 26, 61, 25, 62, 63, 64, 65, 66, 67, 24, 23, 22, 21, 68, 69, 20, 19, 18, 17, 70, 71, 16, 15, 72, 73, 74, 75, 76, 14, 13, 12, 77, 11, 10, 9, 8, 78, 7, 79, 80, 6, 81, 5, 4, 3, 82, 2, 83, 84, 1, 85, 86, 87, 0, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99] -> True

재미있는 사실 : r ≥ 1 의 경우 길이 r 의 정확히 2 개의 ^r-1 개미 순열이 있습니다.

Pyth, 7 바이트

/y+_QQS

온라인으로 사용해보십시오. (지수 적 런타임으로 인해 작은 테스트 사례 만 포함됩니다.) Truthy의 경우 출력 2, Falsey의 경우 0.

/          Count the number of occurences of
      S     the sorted input (implicit Q)
 y          in the order-preserved power set
  +_QQ       of the input prepended by its reverse

다시 말해,

lambda l: subseq(sorted(l), concat(reverse(l), l))

여기서 subseq첫 번째 목록의 요소가 반드시 두 번째 목록에 순서대로 표시되는지 여부 를 출력합니다. 이것은 subseqPyth에서 요소의 순서를 유지하고 첫 번째 목록의 발생 횟수를 세는 두 번째 목록의 모든 하위 세트를 가져 와서 수행됩니다. 기하 급수적으로 시간이 걸립니다.

왜 이것이 작동합니까? 순열이 개미가 되려면 0에서 n-1까지의 단계는 왼쪽으로 만 이동 한 다음 오른쪽으로 만 구성해야합니다. 첫 번째 요소보다 큰 요소는 왼쪽에서 오른쪽으로 증가해야하고 그보다 작은 요소는 왼쪽에서 오른쪽으로 감소해야하기 때문입니다.

[2, 3, 1, 4, 0]
             ^
       ^     0
 ^     1      
 2  ^        
    3     ^
          4

반전 된 사본을 왼쪽에 놓아서 목록을 미러링하면이 보행은 이제 제대로 진행됩니다.

[0, 4, 1, 3, 2, 2, 3, 1, 4, 0]
 ^            |             
 0     ^      |             
       1      | ^           
              | 2  ^        
              |    3     ^  
              |          4                                  

반대로이 미러 목록의 오른쪽은 원래 목록의 왼쪽-오른쪽 도보에 해당합니다. 이 오른쪽은 0에서 n-1까지의 정렬 된 하위 시퀀스입니다. 앤티리스트에서,이 정렬 된 서브 시퀀스는 독창적이지만, 최초의 첫 번째 요소의 인접한 두 사본 사이에서 임의의 선택을 제외하고.

하스켈, 46 바이트

(%)=scanl1
f l=zipWith(+)(min%l)[0..]==max%l

연속 최대 값과 최소 최소값의 벡터 차이가 [0,1,2,3 ...]인지 확인합니다.

l =             [2, 3, 1, 4, 0]

scanl1 max l =  [2, 3, 3, 4, 0]
scanl1 min l =  [2, 2, 1, 1, 0]  
difference =    [0, 1, 2, 3, 4]

Zgarb는로 2 바이트를 절약했습니다 (%)=scanl1.

자바 스크립트 (ES6), 45

a=>a.every((v,i)=>a[v]=!i|a[v-1]|a[v+1],a=[])

설명하기에는 너무 간단하다고 생각했지만 속임수가 있으며, 경우에 따라 첫 번째 버전 인 pre-golf가 있습니다.

a => {
  k = []; // I'll put a 1 in this array at position of each value 
          // that I find scanning the input list
  return a.every((v,i) => { // execute for each element v at position i
    // the index i is needed to manage the first iteration
    // return 1/true if ok, 0/false if not valid
    // .every will stop and return false if any iteration return falsy
    k[v] = 1; // mark the current position
    if ( i == 0 )
    {  // the first element is always valid
       return true;
    }
    else
    {
       return k[v-1] == 1 // valid if near a lesser value
              || k[v+1] == 1; // or valid if near a greater value
    }
  })
}

참고 : 호출 된 원래 배열에 대한 참조가 필요하지 않기 때문에 골프 코드에서 a대신 사용됩니다 . 따라서 매개 변수를 재사용하여 전역 네임 스페이스를 오염시키지 않습니다.kevery

테스트

antsy=
a=>a.every((v,i)=>a[v]=!i|a[v-1]|a[v+1],a=[])

var OkAll=true
;`[0] -> True
[0, 1] -> True
[1, 0] -> True
[0, 1, 2] -> True
[0, 2, 1] -> False
[2, 1, 3, 0] -> True
[3, 1, 0, 2] -> False
[1, 2, 0, 3] -> True
[2, 3, 1, 4, 0] -> True
[2, 3, 0, 4, 1] -> False
[0, 5, 1, 3, 2, 4] -> False
[6, 5, 4, 7, 3, 8, 9, 2, 1, 0] -> True
[4, 3, 5, 6, 7, 2, 9, 1, 0, 8] -> False
[5, 2, 7, 9, 6, 8, 0, 4, 1, 3] -> False
[20, 13, 7, 0, 14, 16, 10, 24, 21, 1, 8, 23, 17, 18, 11, 2, 6, 22, 4, 5, 9, 12, 3, 15, 19] -> False
[34, 36, 99, 94, 77, 93, 31, 90, 21, 88, 30, 66, 92, 83, 42, 5, 86, 11, 15, 78, 40, 48, 22, 29, 95, 64, 97, 43, 14, 33, 69, 49, 50, 35, 74, 46, 26, 51, 75, 87, 23, 85, 41, 98, 82, 79, 59, 56, 37, 96, 45, 17, 32, 91, 62, 20, 4, 9, 2, 18, 27, 60, 63, 25, 61, 76, 1, 55, 16, 8, 6, 38, 54, 47, 73, 67, 53, 57, 7, 72, 84, 39, 52, 58, 0, 89, 12, 68, 70, 24, 80, 3, 44, 13, 28, 10, 71, 65, 81, 19] -> False
[47, 48, 46, 45, 44, 49, 43, 42, 41, 50, 40, 39, 38, 51, 37, 36, 52, 35, 34, 33, 32, 53, 54, 31, 30, 55, 56, 29, 28, 57, 58, 59, 60, 27, 26, 61, 25, 62, 63, 64, 65, 66, 67, 24, 23, 22, 21, 68, 69, 20, 19, 18, 17, 70, 71, 16, 15, 72, 73, 74, 75, 76, 14, 13, 12, 77, 11, 10, 9, 8, 78, 7, 79, 80, 6, 81, 5, 4, 3, 82, 2, 83, 84, 1, 85, 86, 87, 0, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99] -> True`
.split`\n`.forEach(row => {
  var rowElements = row.match(/\w+/g), 
      expected = rowElements.pop()=='True',
      input = rowElements.map(x => +x),
      result = antsy(input),
      ok = result == expected;
  OkAll = OkAll && ok;
  console.log(ok?'OK':'KO', input+' -> '+result)
})
console.log(OkAll ? 'All passed' : 'Failed')

파이썬 2, 49 바이트

f=lambda l:l==[]or max(l)-min(l)<len(l)*f(l[:-1])

목록의 각 접두사에 최소값과 최대 값 사이의 모든 숫자가 포함되어 있는지 확인합니다. 최대 값과 최소값의 차이가 길이보다 작은 지 확인하면됩니다.

54 바이트 :

f=lambda l:1/len(l)or-~l.pop()in[min(l),max(l)+2]*f(l)

마지막 요소가 다른 요소의 최소값보다 작은 지 또는 최대 값보다 큰지 확인합니다. 그런 다음 마지막 요소를 제거하고 되풀이합니다. 단일 요소 목록에서 True를 출력합니다.

재미 있지만 더 긴 목록 이해를 통해 확인할 수도 있습니다.

lambda l:all(l.pop()in[min(l)-1,max(l)+1]for _ in l[1:])

나는 불평등을 사용하고 싶습니다 min(l)-2<l.pop()<max(l)+2,하지만 pop필요 먼저 일어날. 프로그램을 사용하여 오류 코드를 통해 출력하는 것이 더 짧을 수 있습니다.

수학, 42 바이트

!MatchQ[#,{a__,b_,___}/;Min@Abs[{a}-b]>1]&

패턴 일치를 사용 a하여 다음 요소와의 최대 차이 b가보다 큰 접두사 를 찾으려고 시도합니다 1(및 결과 무시 MatchQ).

펄, 39 38 35 바이트

에 +1 포함 -p

STDIN에 시퀀스를 제공하십시오.

antsy.pl <<< "2 1 3 0"

antsy.pl:

#!/usr/bin/perl -p
s%\d+%--$a[$&]x"@a"=~/1  /%eg;$_++

MATL , 11 바이트

&-|R1=a4L)A

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

설명

이것은 모든 쌍 단위 절대 차이의 행렬을 계산하고 위쪽 삼각형 부분을 유지합니다. 첫 번째 열을 제외한 모든 열에 적어도 1 개의 값이 있으면 결과는 true입니다.

&-     % All pairwise differences
|      % Absolute value
R      % Upper triangular part
1=     % Does each entry equal 1?
a      % Logical "or" along each column
4L)    % Remove first value
A      % Logical "and" of all results

R, 72 64 60 바이트

v=scan();for(i in seq(v))T=c(T,diff(sort(v[1:i])));all(T==1)

모든 왼쪽 하위 순열이 연속적 일 경우에만 (즉, 정렬시 차이가있는 경우) 순열은 anty입니다.

입력의 길이가 두 개 이상인 것으로 보장되면을 대신 1:sum(1|v)하여 seq(v)4 바이트를 절약 할 수 있습니다 .

seq(v)의 입력이 하나의 길이 일 때 조건이 다르게 행동한다 ---이 시퀀스를 생성하는 경우 1:v대신에이 seq_along(v). 그러나 다행히도이 경우 출력이 TRUE원하는 동작으로 나타납니다. 길이가 0 인 입력에서도 마찬가지입니다.

R에서는 T사전 설정 변수와 TRUE같지만 R은 재정의 할 수 있습니다. TRUE또한 같은 것으로 간주됩니다 1.

원래 솔루션에 대한 유용한 개선을위한 @Billywob에게 감사드립니다.

05AB1E , 7 바이트

Âìæ¹{¢O

온라인으로 사용해보십시오! 또는 수정 된 테스트 스위트로 .

설명

xnor가 그의 화려한 Pyth 답변에서 설명한 프로세스를 사용합니다 .
정확한 인스턴스의 경우 2를, 거짓의 경우 0을 반환합니다.

Âì        # prepend a reversed copy of input to input
  æ       # take powerset
   ¹{     # push a sorted copy of input
     ¢    # count occurances of sorted input in powerset
      O   # sum occurances (which for some reason is needed, feels like a bug)

펄, 63 바이트

참고 @Gabriel Banamy이 짧은 (55 바이트)를 내놓았다 대답 . 그러나이 솔루션은 여전히 ​​재미가 있다고 생각하므로 게시하고 있습니다.

바이트 수에는 62 바이트의 코드와 -n플래그가 포함됩니다.

s/\d+/1x($&+1)/ge;/ 1(1*)\b(?{$.&=$`=~m%\b(11)?$1\b%})^/;say$.

그것을 실행하려면 :

perl -nE 's/\d+/1x($&+1)/ge;/ 1(1*)\b(?{$.&=$`=~m%\b(11)?$1\b%})^/;say$.' <<< "3 2 5 4 1 0"

짧은 설명은 각 숫자 변환 k의 단항 표현 k+1( +1너무 필요 0의이 무시되지 않습니다)를. 그런 다음 각 숫자 k+1(단항으로 1(1*)표시됨) 에 대해 앞의 문자열 (에 의해 참조 됨 )에 k( $1hold k) 또는 k+2(있는 경우)가 있는지 확인합니다 . 아니라면 0으로 설정 합니다. 그런 다음 마지막 에 0으로 설정하지 않으면 인쇄 되고 그렇지 않으면 0으로 인쇄됩니다.11$1$-backtick$.$.1

뇌 플랙 302 264 256 바이트

46 바이트를 절약 해 준 Wheat Wizard 덕분에

([]){{}({}<>)<>([])}{}<>(({}))([]){{}({}<>)<>([])}{}<>(({}<>))<>(()){{}(({})<(({})<>[({})]<>(())){((<{}{}>))}{}{{}({}<><{}>)(<>)}{}<>({}<<>(({})<>[({})<>(())]){((<{}{}>))}{}{{}({}<><{}>)(<>)}{}<>>)<>>[({})](<()>)){{}{}(<(())>)}{}}([][()(())]){((<{}{}>))}{}

스택의 상단은 진실의 경우 1이고 거짓의 경우 0입니다.

Truthy : 온라인으로 사용해보십시오!
거짓 : 온라인으로 사용해보십시오!

아이디어는 개미가 오프 스택에서 방문한 최소 및 최대 수를 유지하는 것입니다. 그런 다음 각 숫자를 두 숫자와 비교하고 적절한 숫자를 업데이트하십시오. 다음 숫자가 최소값보다 1보다 작거나 최대 값보다 1보다 크지 않으면 루프에서 벗어나 false를 리턴하십시오.

간단한 설명 :

([])                             # duplicate the bottom element by
{{}({}<>)<>([])}{}<>             # reversing everything onto the other stack 
(({}))([])                       # duplicating the top element
{{}({}<>)<>([])}{}<>             # and reversing everything back

(({}<>))<>                       # copy the top element to the other stack (push twice)
(()){{}                          # push a 1 so the loop starts, and repeat until the top
                                 # two elements are equal
(({})<                           # hold onto the top element to compare later
(({})<>[({})]<>(()))             # push a 0 if diff with the top of the other stack is +1
{{}({}<><{}>)(<>)}{}             # logical not (the previous line pushed a 1 as the second
                                 # element already)
{{}({}<><{}>)<>(<()>)}{}         # replace the top of the other stack with this element if
                                 # the logical not gave us 1
<>({}<<>                         # take the minimum off the other stack temporarily 
(({})<>[({})<>(())])             # push a 0 if diff with the top of the other stack is -1
{((<{}{}>))}{}                   # logical not (the previous line pushed a 1 as the second
                                 # element already)
{{}({}<><{}>)(<>)}{}             # replace the top of the other stack with this element if
                                 # the logical not gave us 1
<>>)<>                           # put the minimum on back on
>)                               # put the element you were comparing back on
[({})](<()>)){{}{}(<(())>)}{}    # push 1 or 0 for not equal to the element we held earlier
                                 # (push the second number back on)
}                                # repeat the loop if the top 2 weren't equal
([][()(())]){((<{}{}>))}{}       # logical not of the height of the stack

젤리 , 9 8 7 바이트

;@UŒPċṢ

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

xnor의 답변에 대한 젤리 번역.

오래된 솔루션 :

;\Ṣ€IỊȦ
;\Ṣ€IE€P

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

아래의 Pyth 답변과 매우 유사하게 작동합니다.

;\          All prefixes (Accumulate (\) over concatenation (;))
  Ṣ€        (Ṣ)ort each (€) prefix
    I       (I)ncrements of each prefix (differences between consecutive elements).  Implicit vectorization.
     E€     Check if all elements are (E)qual (they will be iff the permutation is antsy,
               and all elements will be 1) for each (€) prefix
       P    Is this true for all prefixes?
     ỊȦ     For the other answer, are (Ȧ)ll elements 1 or less (Ị)?

CJam ( 21 20 바이트)

{:A,{_)A<$2*)@-#},!}

온라인 테스트 스위트

해부

이것은 xnor의 Haskell 답변에서 첫 번째 n요소 의 최대 값과 최소값의 차이는이어야한다는 관찰을 사용합니다 n-1.

{         e# Define a block. Stack: array
  :A,     e#   Store the array in A and get its length
  {       e#   Filter (with implicit , so over the array [0 ... len-1])
    _)A<  e#     Get the first i+1 elements of A (so we iterate over prefixes)
    $2*)  e#     Extract the last element without leaving an empty array if the
          e#     prefix is of length 1 by first duplicating the contents of the
          e#     prefix and then popping the last element
    @-#   e#     Search the prefix for max(prefix)-i, which should be min(prefix)
          e#     giving index 0
  },      e#   So the filter finds values of i for which the prefix of length i+1
          e#   doesn't have max(prefix) - min(prefix) = i
  !       e#   Negate, giving truthy iff there was no i matching the filter
}

대체 접근법 (또한 20 바이트)

{_{a+_)f-:z1&,*}*^!}

온라인 테스트 스위트

첫 번째 요소 이후의 각 요소가 이전 요소와 1 거리에 있는지 직접 확인합니다. 입력은 순열이므로 값을 반복하지 않으므로 충분한 테스트입니다. 1 바이트 절약을위한 Martin에게 감사합니다.

해부

{_{a+_)f-:z1&,*}*^!}

{         e# Declare a block. Stack: array
  _       e#   Work with a copy of the array
  {       e#   Fold...
    a+    e#     Add to the accumulator.
    _)f-  e#     Dup, pop last, map subtraction to get distance of this element from
          e#     each of the previous ones
    :z1&, e#     Check whether the absolute values include 1
    *     e#     If not, replace the accumulator with an empty array
  }*
  ^!      e#   Test whether the accumulator is equal to the original array
          e#   Note that this can't just be = because if the array is of length 1
          e#   the accumulator will be 0 rather than [0]
}

자바, 100 98 79 75 바이트

a->{int n=a[0],m=n-1;for(int i:a)n-=i==m+1?m-m++:i==n-1?1:n+1;return n==0;}

전에:

a->{int m,n;m=n=a[0];--m;for(int i:a)if(i==m+1)m=i;else if(i==n-1)n=i;else return 0>1;return 1>0;}

바꾸어 3 바이트를 저장 true하고 false으로 1>0하고 0>1.

Peter Taylor의 훌륭한 제안으로 23 바이트를 절약했습니다!

언 골프 드 :

a -> {
    int n = a[0], m = n - 1;
    for (int i : a)
        n -= i == m + 1? m - m++ : i == n - 1? 1 : n + 1;
    return n == 0;
}

로 지금까지 본 최고 및 최저 값을 추적 유지 m와 n; 새로운 값 m + 1이거나 n - 1다음 높은 값 또는 낮은 값인 경우에만 새 값을 수락 합니다. m루프 주위에서 처음으로 "일치"할 수 있도록 높은 값을 첫 번째 요소보다 작은 값으로 초기화합니다 . 참고 : 이것은 선형 시간 온라인 알고리즘입니다. 다른 많은 솔루션과 달리 현재, 최고, 최고 및 최저 값에 대해 3 워드의 메모리 만 필요합니다.

다음 값이 범위의 상한 및 하한을 모두 누락하면 최하단 값이 설정되고 -1하한이 진행되지 않고 0에 도달 할 수 없습니다. 그런 다음 낮은 값 ( n)이 0에 도달 했는지 확인하여 앤티 시퀀스를 감지합니다 .

(안타깝게도 첫 번째 잘못된 숫자 뒤에 나오는 것보다 항상 전체 시퀀스를보아야하기 때문에 효율이 떨어집니다 .하지만 다른 솔루션에서 O (n ^ 2 ) 및 지수 시간이 다가옵니다.)

용법:

import java.util.function.Predicate;

public class Antsy {
    public static void main(String[] args) {
        int[] values = { 6, 5, 4, 7, 3, 8, 9, 2, 1, 0 };
        System.out.println(test(values,
            a -> {
                int n = a[0], m = n - 1;
                for (int i : a)
                    n -= i == m + 1? m - m++ : i == n - 1? 1 : n + 1;
                return n == 0;
            }
        ));
    }

    public static boolean test(int[] values, Predicate<int[]> pred) {
        return pred.test(values);
    }
}

참고 : Java 8 람다를 사용하지 않고도 작성할 수도 있습니다.

자바 7, 89 바이트

boolean c(int[]a){int n=a[0],m=n-1;for(int i:a)n-=i==m+1?m-m++:i==n-1?1:n+1;return n==0;}

Pyth ( 포크 ), 13 바이트

!sstMM.+MSM._

이 Pyth 포크에 대한 온라인 시도 링크가 없습니다. 포크에는 델타 함수가 포함되어 있으며 .+이는 표준 Pyth 라이브러리의 일부가 아닙니다.

설명:

           ._  For each of the prefixes:
         SM    Sort it
      .+M      Get deltas (differences between consecutive elements), which for antsy
                 permutations would all be 1s
   tMM         Decrement each of the elements (all 0s for antsy permutations)
 ss            Sum all the results from the above together, 0 for antsy and >0 for non-antsy
!              Logical negation.

펄, 66 54 +1 = 55 바이트

+1 바이트 -n.

s/\d+/$.&=!@a||1~~[map{abs$_-$&}@a];push@a,$&/eg;say$.

설명:

s/\d+/$.&=!@a||1~~[map{abs$_-$&}@a];push@a,$&/eg;say$.
#input is automatically read into $_.
#regex automatically is performed on $_.
s/   /                                       /eg;
    #Substitution regex.
    #/g means to keep searching after the first match
    #/e evaluates the replacement as code instead of regex.
  \d+  #Match of at least 1 digit.  Match automatically gets stored in $&
      $.&=  #$. is initially 1.  This basically says $. = $. & (code)
           !@a  #Since @a is uninitialized, this returns !0, or 1
                #We don't want to check anything for the first match
              || #logical or
                1~~
                   #~~ is the smartmatch operator.  When RHS is scalar and LHS is array reference,
                   #it returns 1 iff RHS is equal to at least one value in de-referenced LHS.
                   [map{abs$_-$&}@a];
                       #Return an array reference to the array calculated by |$_ - $&|
                       #where $_ iterates over @a.  Remember $& is the stored digit capture.
                                     push@a,$& #pushes $& at the end of @a.
                                                 say$. #output the result

거짓이면 0을, 참이면 1을 인쇄합니다.

@Dada 덕분에 -11 바이트

Brainfuck, 60 바이트

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

순열은 구분 기호가없고 종료 줄 바꿈이없는 바이트로 제공됩니다. 이후 \x00입력이 발생, 이는 함께 구현을 위해 설계된다 EOF = -1. 출력은 \x00false와 \x01true입니다.

의 순열 경우 \x01최대가 할 chr(r)수있다, 우리는의 모든 인스턴스를 대체 할 수있는 ,+과를 ,57의 점수 EOF = 0구현입니다.

온라인으로 시도하십시오 (57 바이트 버전) : 입력은을 제외한 연속 된 바이트 범위의 순열로 제공 될 수 있으며 \x00출력은 \x00false이고 최소 범위는 true입니다.

우리는 지금까지 본 최소 및 최대를 추적하고 첫 번째 문자 이후의 각 문자에 대해 최소 -1인지 최대 +1인지 아닌지 확인합니다. 두 경우 모두 로컬 셀이 0이되도록 포인터를 일반 작업 공간 밖으로 이동하십시오.

메인 루프의 시작 부분에서 정상적인 작업 공간의 메모리 레이아웃은

c a b 0 0

여기서 c현재 문자, a분이며, b최대이다. (60 바이트 버전의 경우 모든 때문에 오프셋이 1로 처리됩니다 ,+.)

Brachylog , 22 바이트

:@[fb:{oLtT,Lh:T:efL}a

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

설명

목록에 연속 정수가 포함되어 있는지 여부를 확인하는 간결한 방법을 찾지 못했습니다. 내가 찾은 가장 짧은 것은 해당 목록의 첫 번째 요소와 마지막 요소 사이의 범위를 생성하고 해당 범위가 원래 목록인지 확인하는 것입니다.

:@[fb                       Take all but the first prefixes of the Input
     :{             }a      This predicate is true for all those prefixes
       oLtT,                Sort the prefix, call it L, its last element is T
            Lh:T            The list [First element of L, T]
                :efL        Find all integers between the First element of L and T. It must
                              result in L

배치, 133 바이트

@set/au=%1,l=%1-1,a=0
@for %%n in (%*)do @call:l %%n
@exit/b%a%
:l
@if %1==%u% (set/au+=1)else if %1==%l% (set/al-=1)else set a=1

입력을 명령 행 인수로 사용합니다. 성공의 경우 오류 레벨 0, 실패의 경우 1로 종료합니다.

J, 14 바이트

/:~-:>./\-<./\

이것은 @xnor의 방법을 기반으로 합니다.

설명

/:~-:>./\-<./\  Input: array P
        \       For each prefix of P
     >./          Reduce using the maximum
          <./\  Get the minimum of each prefix of p
         -      Subtract between each
   -:           Test if it matches
/:~               P sorted

자바, 170 바이트

boolean f(int[]a){int l=a.length,i=0,b=0,e=l-1;int[]x=new int[l];for(;i<l;i++)x[i]=i;for(i--;i>0;i--)if(a[i]==x[b])b++;else if(a[i]==x[e])e--;else return 0>1;return 1>0;}

배열 x은 0에서 최대 숫자까지 순서대로 값을 갖습니다 (Python이 훨씬 좋습니다 ...). 루프는 아직 발생하지 않은 x[b]가장 낮은 ( ) 또는 가장 높은 ( x[e]) 숫자 와 일치 시키려고 뒤로 이동합니다 . 그렇다면 해당 단계에서 해당 번호에 도달 할 수 있습니다.

여기에서 코드를 테스트하십시오 .

수학, 47 바이트

Martin Ender의 솔루션보다 조금 더 깁니다 (놀랍습니다!). 그러나 그것은 더 읽을 수없는 노력 중 하나이므로 좋습니다.

#=={}||{Max@#,Min@#}~MemberQ~Last@#&&#0@Most@#&

설명:

#=={}                         empty lists are antsy (function halts with True)
 ||                            or
{Max@#,Min@#}~MemberQ~Last@#  lists where the last number is largest or smallest
                              are possibly antsy (else function halts with False)
 &&                            and
#0@Most@#&                    recursively call this function after dropping the
                              last element of the list

자바 (7), (170) 169 바이트

import java.util.*;Object c(int[]a){List l=new ArrayList();l.add(a[0]);for(int i:a){if(l.indexOf(i)<0&l.indexOf(i-1)<0&l.indexOf(i+1)<0)return 0>1;l.add(i);}return 1>0;}

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

import java.util.*;
class M{
  static Object c(int[] a){
    List l = new ArrayList();
    l.add(a[0]);
    for(int i : a){
      if(l.indexOf(i) < 0 & l.indexOf(i-1) < 0 & l.indexOf(i+1) < 0){
        return 0>1; //false
      }
      l.add(i);
    }
    return 1>0; //true
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 0 }));
    System.out.println(c(new int[]{ 0, 1 }));
    System.out.println(c(new int[]{ 1, 0 }));
    System.out.println(c(new int[]{ 0, 1, 2 }));
    System.out.println(c(new int[]{ 0, 2, 1 }));
    System.out.println(c(new int[]{ 2, 1, 3, 0 }));
    System.out.println(c(new int[]{ 3, 1, 0, 2 }));
    System.out.println(c(new int[]{ 1, 2, 0, 3 }));
    System.out.println(c(new int[]{ 2, 3, 1, 4, 0 }));
    System.out.println(c(new int[]{ 0, 5, 1, 3, 2, 4 }));
    System.out.println(c(new int[]{ 6, 5, 4, 7, 3, 8, 9, 2, 1, 0 }));
    System.out.println(c(new int[]{ 4, 3, 5, 6, 7, 2, 9, 1, 0, 8 }));
    System.out.println(c(new int[]{ 5, 2, 7, 9, 6, 8, 0, 4, 1, 3 }));
    System.out.println(c(new int[]{ 20, 13, 7, 0, 14, 16, 10, 24, 21, 1, 8, 23, 17, 18, 11, 2, 6, 22, 4, 5, 9, 12, 3, 15, 19 }));
    System.out.println(c(new int[]{ 34, 36, 99, 94, 77, 93, 31, 90, 21, 88, 30, 66, 92, 83, 42, 5, 86, 11, 15, 78, 40, 48, 22, 29, 95, 64, 97, 43, 14, 33, 69, 49, 50, 35, 74, 46, 26, 51, 75, 87, 23, 85, 41, 98, 82, 79, 59, 56, 37, 96, 45, 17, 32, 91, 62, 20, 4, 9, 2, 18, 27, 60, 63, 25, 61, 76, 1, 55, 16, 8, 6, 38, 54, 47, 73, 67, 53, 57, 7, 72, 84, 39, 52, 58, 0, 89, 12, 68, 70, 24, 80, 3, 44, 13, 28, 10, 71, 65, 81, 19 }));
    System.out.println(c(new int[]{ 47, 48, 46, 45, 44, 49, 43, 42, 41, 50, 40, 39, 38, 51, 37, 36, 52, 35, 34, 33, 32, 53, 54, 31, 30, 55, 56, 29, 28, 57, 58, 59, 60, 27, 26, 61, 25, 62, 63, 64, 65, 66, 67, 24, 23, 22, 21, 68, 69, 20, 19, 18, 17, 70, 71, 16, 15, 72, 73, 74, 75, 76, 14, 13, 12, 77, 11, 10, 9, 8, 78, 7, 79, 80, 6, 81, 5, 4, 3, 82, 2, 83, 84, 1, 85, 86, 87, 0, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 }));
  }
}

산출:

true
true
true
true
false
true
false
true
true
false
true
false
false
false
false
true