前書き

0からr-1までの数字の定規があるとします。2つの数字の間にアリを置くと、定規上で不規則にクロールを開始します。定規は非常に狭いので、アリはある数の位置から別の位置まで歩くことができません。アリが初めて数字の上を歩くときに、それを記録します。これにより、r番号の順列が得られます。私たちは、順列があると言うイライラそれは、このように蟻によって生成することができます。あるいは、最初のエントリを除くすべてのエントリp [i]が前のエントリから距離1以内にある場合、順列pはアンティです。

例

長さ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内にないため、antyではありません。アリは5に到達するために4を通過する必要があります。

タスク

数字の順列所与0にR-1一部のための1≤R≤100順列がイライラ、及びfalsy値でない場合であれば、任意の合理的な形式で、出力truthy値。

テストケース

[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 、まさにそこにある2 ^R-1の長さのイライラ順列R。

Pyth、7バイト

/y+_QQS

オンラインでお試しください。（指数関数的なランタイムのため、小さなテストケースのみが含まれます。）Truthyの出力2、Falsyの出力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))

where subseqは、最初のリストの要素が2番目のリストに順番に表示されるかどうかを出力します。必ずしも隣接する必要はありません。これsubseqは、要素の順序を保持する2番目のリストのすべてのサブセットを取得し、最初のリストの出現回数をカウントすることにより、Pythで行われます。これには指数関数的な時間がかかります。

なぜこれが機能するのですか？順列が乱雑になるためには、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のソートされたサブシーケンスです。antyリストでは、このソートされたサブシーケンスは一意です。ただし、元の最初の要素の2つの隣接するコピー間の任意の選択を除きます。

Haskell、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。

JavaScript（ES6）、45

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

説明として必要なのは簡単すぎると思ったが、トリックがあり、念のため、ここに私の最初のバージョン、プレゴルフがある

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

Python 2、49バイト

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

リストの各プレフィックスに、minとmaxの間のすべての数値が含まれているかどうかを確認します。これは、最大値と最小値の差がその長さよりも小さいかどうかを確認することによって行われます。

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最初に必要なことです。エラーコードを介して出力するプログラムを使用すると、おそらく短くなります。

Mathematica、42バイト

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

パターンマッチングを使用aして、次の要素bとの最大差がより大きい1（およびの結果を否定するMatchQ）プレフィックスを見つけようとします。

Perl、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)

置換は、その左部分置換がすべて連続している場合（つまり、並べ替えたときに差が1つある場合）にのみ有効です。

入力が1個以下の長さを持つことが保証されている場合、我々は交換することができ1:sum(1|v)てseq(v)4つのバイトを保存します、。

seq(v)入力は長さ1である場合に、条件が異なる動作場合---それはシーケンスを生成する1:v代わりにseq_along(v)。ただし、幸いなことに、出力はTRUEこの場合になります。これは望ましい動作です。長さゼロの入力でも同じことが起こります。

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)

Perl、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（sが無視されない+1ようにするために必要です0）。次に、各番号k+1（として単項で表現）について、前の文字列（で参照）に（hold ）または（thenである）が存在1(1*)するかどうかを調べます。いいえの場合、ゼロに設定します。その後で、私たちは、印刷終了となりますどの我々はそうでない場合はゼロ、またはゼロに設定したことがない場合。k$1kk+211$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*)@-#},!}

オンラインテストスイート

解剖

これは、最初のn要素の最大値と最小値の差がである必要があるというHaskellの回答でxnorによる観察を使用しています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]
}

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

trueとfalseを1>0とに置き換えて3バイトを節約しました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ループの最初に「一致」するように最初の要素よりも1つ小さいます。注：これは線形時間のオンラインアルゴリズムです。他の多くのソリューションとは異なり、現在の値、これまでの最高値、最低値までの3ワードのメモリのみが必要です。

次の値が範囲の上限と下限の両方を逃した場合、これまでの最低値は -1、ゼロに到達することはありません。次に、低い値nがゼロに達したかどうかをチェックすることにより、アンチシーケンスを検出します。

（残念なことに、これは効率が悪くなります。なぜなら、最初のシーケンスの後にベイルアウトするのではなく、常にシーケンス全体を見る必要があるからです。 間違っん数、他のソリューションが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ラムダを利用せずに作成することもできます。

Java 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（fork）、13バイト

!sstMM.+MSM._

このPythのフォークのTry It Onlineリンクはありません。フォークにはデルタ関数が含まれています.+標準のPythライブラリの一部ではないdeltasます。

説明：

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

Perl、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

falseの場合は0、trueの場合は1を出力します。

@Dadaのおかげで-11バイト

Brainfuck、60バイト

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

順列は、区切り文字と終了改行のないバイトとして与えられます。以来\x00入力で発生する、これはと実装のために設計されていますEOF = -1。出力は\x00falseおよび\x01 trueです。

\x01までの順列chr(r)が許可されている場合、57のスコアの,+withのすべてのインスタンス,を、EOF = 0実装。

オンラインで試してみてください（57バイトバージョン）：入力は\x00、を除くバイト範囲の順列として指定でき、出力は\x00 falseで、範囲の最小値はtrueになります。

これまでに見られた最小値と最大値を追跡し、最初の文字の後の各文字について、それがmin-1またはmax + 1であるか、どちらでもないかを確認します。どちらの場合も、ローカルセルがゼロになるように、ポインターを通常の作業スペースの外側に移動します。

メインループの開始時の通常の作業スペースのメモリレイアウトは次のとおりです。

c a b 0 0

どこで cで、現在の文字、a最小、b最大です。（60バイトバージョンの場合、のため、すべてが1のオフセットで処理され,+ます。）

ブラキログ、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

Java、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]）の番号に一致しようとして逆方向に進みます。その場合、その数でその数に達する可能性があります。

ここでコードをテストします。

Mathematica、47バイト

マーティン・エンダーのソリューションよりも少し長いです（驚きです！）。しかし、それは私の読めない努力の1つなので、それは良いことです：D

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

Java 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