介绍

假设您有一个标尺，编号从0到r-1。您在任何两个数字之间放置一个蚂蚁，它开始在尺子上不规则地爬行。标尺是如此狭窄，以至于蚂蚁不能不走其间的所有数字就不能从一个位置走到另一位置。当蚂蚁第一次行走在一个数字上时，您将其记录下来，这使您可以对r数进行排列。我们说一个置换是坐立不安，如果它可以通过这种方式蚂蚁产生。或者，如果除第一个条目外的每个条目p [i]都在与某个先前条目的距离1之内，则置换p是无意义的。

例子

长度为6的排列

4, 3, 5, 2, 1, 0

是anty，因为3在距离1的4之内，5在距离1的4之内，2在距离3的距离1之内，1在距离2的距离1之内，以及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 ，恰好有2 ^R-1长度的坐立不安排列ř。

Pyth，7个字节

/y+_QQS

在线尝试。（由于运行时间的延长，仅包含了一些小的测试用例。）输出2为Truthy，0为Falsey。

/          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输出第一列表的元素是否按顺序出现在第二列表中，不一定相邻。将subseq在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的排序子序列。在蚂蚁列表中，此排序的子序列是唯一的，除了在原始第一个元素的两个相邻副本之间进行任意选择之外。

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

注意：在golfed代码a中使用代替k，因为我不需要引用every调用中的原始数组。所以我避免使用参数来污染全局名称空间

测试

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

检查列表的每个前缀是否包含其最小值和最大值之间的所有数字。通过检查最大和最小的差是否小于其长度来实现。

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:sum(1|v)使用seq(v)，从而节省了四个字节。

的seq(v)在if条件的行为不同，当输入长度为一，---它产生的序列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（这+1是必需的，因此0s不会被忽略）。然后，对于每个数字k+1（以，以一元形式表示1(1*)），我们查看前面的字符串（由引用）中是否存在k（$1hold k）或k+2（then ）。如果否，则设置为零。在那末我们打印，如果我们从不将其设置为零，否则将为零。11$1$-backtick$.$.1

脑高射炮 302 264 256个字节

感谢 Wheat Wizard节省了46个字节

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

堆栈的顶部为真时为1，为虚假时为0。

Truthy：在线试用！
Falsy： 在线尝试！

这个想法是将蚂蚁访问过的最小和最大数量保存在栈外。然后将每个数字与这两个数字进行比较，并更新相应的数字。如果下一个数字不小于最小值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答案的Jelly翻译。

旧解决方案：

;\Ṣ€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。由于输入是排列，因此不会重复值，因此这是一个足够的测试。感谢Martin节省了1个字节。

解剖

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

通过替换保存的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小于第一个元素的值，以使它在循环中第一次“匹配”。注意：这是线性时间在线算法。与许多其他解决方案不同，对于当前值，最高值和最低值，它仅需要三个字的存储空间。

如果下一个值未同时达到该范围的高端和低端，则将最低值设置为-1，然后低端将永远无法继续并达到零。然后，我们通过检查下限值是否n达到零来检测一个蚂蚁序列。

（不幸的是，这效率不高，因为我们总是不得不看整个序列，而不是在第一个错误的数字后求救，但是当其他解决方案使用O（n ^ 2）时，很难说节省23字节（！） ）和指数时间法。）

用法：

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 lambda的情况下编写：

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分支的“在线试用”链接。分支包含deltas函数.+，该函数不属于标准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.

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。

-11个字节感谢@Dada

Brainfuck，60个字节

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

排列以字节形式给出，没有分隔符，没有终止换行符。由于\x00发生在输入中，因此设计用于的实现EOF = -1。输出\x00为false和\x01true。

如果置换\x01最多chr(r)是允许的，那么我们可以更换的所有实例,+与,用于与得分为57 EOF = 0实现。

在线试用（57字节版本）：输入可以作为任何连续的字节范围（不包括）的排列给出\x00，并且输出将为\x00false，范围的最小值为true。

我们跟踪到目前为止所看到的min和max，对于第一个字符之后的每个字符，检查它是min-1还是max + 1还是都不是。如果都不是，则将指针移到正常工作空间之外，以使本地单元格变为零。

主循环开始时正常工作空间的内存布局为

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

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个字节

比Martin Ender的解决方案长一点（惊讶！）。但这是我更难以理解的工作之一，所以很好：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