Giới thiệu

Giả sử bạn có một thước kẻ có các số từ 0 đến r-1 . Bạn đặt một con kiến ​​vào giữa hai số bất kỳ và nó bắt đầu bò một cách thất thường trên thước kẻ. Thước kẻ hẹp đến mức con kiến ​​không thể đi từ vị trí này sang vị trí khác mà không đi trên tất cả các con số ở giữa. Khi con kiến ​​đi trên một con số lần đầu tiên, bạn ghi lại nó và điều này mang lại cho bạn một hoán vị của các số r . Chúng tôi nói rằng một hoán vị là antsy nếu nó có thể được tạo ra bởi một con kiến ​​theo cách này. Ngoài ra, một hoán vị p là antsy nếu mọi mục nhập p [i] ngoại trừ mục đầu tiên nằm trong khoảng cách 1 từ một số mục trước đó.

Ví dụ

Hoán vị chiều dài 6

4, 3, 5, 2, 1, 0

là antsy, vì 3 nằm trong khoảng cách 1 của 4 , 5 nằm trong khoảng cách 1 của 4 , 2 nằm trong khoảng cách 1 từ 3 , 1 nằm trong khoảng cách 1 từ 2 và 0 nằm trong khoảng cách 1 từ 1 . Hoán vị

3, 2, 5, 4, 1, 0

không phải là antsy, vì 5 không nằm trong khoảng cách 1 của 3 hoặc 2 ; con kiến ​​sẽ phải vượt qua 4 để đến 5 .

Nhiệm vụ

Cho một hoán vị của các số từ 0 đến r-1 cho khoảng 1 ≤ r 100 ở bất kỳ định dạng hợp lý nào, xuất ra một giá trị trung thực nếu hoán vị là antsy và nếu không có giá trị giả.

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

[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

Fun thực tế: cho r ≥ 1 , có chính xác 2 ^r-1 antsy hoán vị độ dài r .

Bình thường, 7 byte

/y+_QQS

Hãy thử trực tuyến. (Chỉ bao gồm các trường hợp thử nghiệm nhỏ do thời gian chạy theo cấp số nhân.) Kết quả 2 cho Truthy, 0 cho 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

Nói cách khác,

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

trong đó subseqđầu ra cho dù các phần tử của danh sách đầu tiên xuất hiện theo thứ tự trong danh sách thứ hai, không nhất thiết phải liền kề. Việc subseqnày được thực hiện trong Pyth bằng cách lấy tất cả các tập hợp con của danh sách thứ hai, theo thứ tự các phần tử và đếm số lần xuất hiện của danh sách đầu tiên. Điều này mất thời gian theo cấp số nhân.

Tại sao điều này làm việc? Để hoán vị là antsy, bước từ 0 đến n-1 phải bao gồm chỉ đi bên trái, sau đó chỉ đi bên phải. Điều này là do các phần tử lớn hơn phần tử đầu tiên phải tăng từ trái sang phải và các phần tử nhỏ hơn phần tử phải giảm từ trái sang phải.

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

Nếu chúng ta phản chiếu danh sách bằng cách đặt một bản sao đảo ngược sang bên trái của nó, thì bước đi này bây giờ chỉ đi bên phải.

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

Ngược lại, bất kỳ bên phải của danh sách gương này tương ứng với một bước đi bên trái rồi bên phải của danh sách ban đầu. Điều này đúng chỉ là một thứ tự được sắp xếp từ 0 đến n-1. Trong một danh sách antsy, thứ tự được sắp xếp này là duy nhất, ngoại trừ một lựa chọn tùy ý giữa hai bản sao liền kề của phần tử đầu tiên ban đầu.

Haskell, 46 byte

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

Kiểm tra xem độ chênh lệch vectơ của cực đại đang chạy và cực tiểu đang chạy 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 lưu 2 byte với (%)=scanl1.

JavaScript (ES6), 45

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

Tôi nghĩ rằng nó quá đơn giản để giải thích, nhưng có một mẹo, và chỉ trong trường hợp, đây là phiên bản đầu tiên của tôi, trước khi chơi 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
    }
  })
}

Lưu ý: trong mã golf ađược sử dụng thay vì k, vì tôi không cần tham chiếu đến mảng ban đầu bên trong everycuộc gọi. Vì vậy, tôi tránh làm ô nhiễm không gian tên toàn cầu sử dụng lại tham số

Kiểm tra

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 byte

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

Kiểm tra xem mỗi tiền tố của danh sách có chứa tất cả các số giữa bao gồm tối thiểu và tối đa của nó hay không. Nó làm như vậy bằng cách kiểm tra xem chênh lệch của max và min có nhỏ hơn chiều dài của nó không.

54 byte:

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

Kiểm tra xem phần tử cuối cùng có nhỏ hơn một phần tử của phần tử khác hay không nhiều hơn phần tử tối đa của chúng. Sau đó, loại bỏ phần tử cuối cùng và đệ quy. Trên danh sách một thành phần, xuất ra True.

Điều này cũng có thể được kiểm tra thông qua một sự hiểu biết danh sách thú vị nhưng dài hơn.

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

Tôi muốn sử dụng bất đẳng thức min(l)-2<l.pop()<max(l)+2, nhưng popcần phải xảy ra trước tiên. Sử dụng một chương trình để xuất qua mã lỗi có thể sẽ ngắn hơn.

Toán học, 42 byte

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

Sử dụng khớp mẫu để thử và tìm tiền tố acó chênh lệch tối đa so với phần tử tiếp theo blớn hơn 1(và phủ định kết quả của MatchQ).

Perl, 39 38 35 byte

Bao gồm +1 cho -p

Đưa ra trình tự trên STDIN:

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

antsy.pl:

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

MATL , 11 byte

&-|R1=a4L)A

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

Điều này tính toán một ma trận của tất cả các khác biệt tuyệt đối theo cặp và giữ phần tam giác trên. Kết quả là đúng nếu có ít nhất 1 giá trị trong tất cả các cột trừ cột đầu tiên.

&-     % 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 byte

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

Một hoán vị là antsy khi và chỉ khi tất cả các phép con bên trái của nó là liên tục (tức là có sự khác biệt khi sắp xếp).

Nếu đầu vào được đảm bảo có độ dài nhiều hơn một, thì chúng ta có thể thay thế 1:sum(1|v)bằng seq(v), giúp tiết kiệm bốn byte.

Điều kiện seq(v)trong if hoạt động khác đi khi đầu vào có độ dài một --- nó tạo ra chuỗi 1:vthay vì seq_along(v). Tuy nhiên, may mắn thay, đầu ra hóa ra là TRUEtrong trường hợp này, đó là hành vi mong muốn. Điều tương tự cũng xảy ra đối với đầu vào có độ dài bằng không.

Trong R, Tlà một biến đặt trước bằng TRUE(nhưng R cho phép bạn xác định lại nó). TRUEcũng được coi là bằng 1.

Cảm ơn @Billywob vì một số cải tiến hữu ích cho giải pháp ban đầu.

05AB1E , 7 byte

Âìæ¹{¢O

Hãy thử trực tuyến! hoặc như một bộ kiểm tra sửa đổi .

Giải trình

Sử dụng quy trình được mô tả bởi xnor trong câu trả lời Pyth tuyệt vời của anh ấy .
Trả về 2 cho các trường hợp trung thực và 0 cho sai.

Âì        # 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 byte

Lưu ý rằng @Gabriel Banamy đã đưa ra câu trả lời ngắn hơn (55 byte) . Nhưng tôi nghĩ giải pháp này vẫn thú vị, vì vậy tôi sẽ đăng nó.

Tổng số byte bao gồm 62 byte mã và -ncờ.

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

Để chạy nó:

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

Giải thích ngắn : chuyển đổi từng số kthành biểu diễn đơn nhất của k+1(điều đó +1là cần thiết để 0s không bị bỏ qua). Sau đó, đối với mỗi số k+1(được biểu thị bằng unary as 1(1*)), chúng ta xem xét nếu k( $1giữ k) hoặc k+2(đó là 11$1) có mặt trong chuỗi trước (được tham chiếu bởi $-backtick). Nếu không, sau đó chúng tôi đặt $.thành không. Tại sau đó kết thúc, chúng tôi in $.sẽ được 1nếu chúng ta không bao giờ đặt nó là không, hoặc không có khác.

Brain-Flak 302 264 256 byte

Cảm ơn Wheat Wizard đã lưu 46 byte

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

Đỉnh của ngăn xếp sẽ là 1 cho sự thật và 0 cho giả.

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

Ý tưởng là giữ số lượng tối thiểu và tối đa mà con kiến ​​đã truy cập trong ngăn xếp tắt. Sau đó so sánh từng số với cả hai số đó và cập nhật số thích hợp. Nếu số tiếp theo không nhỏ hơn 1 hoặc nhỏ hơn tối đa 1, thoát ra khỏi vòng lặp và trả về sai.

Giải thích ngắn gọn:

([])                             # 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

Thạch , 9 8 7 byte

;@UŒPċṢ

Dùng thử trực tuyến!

Một bản dịch Jelly của câu trả lời của xnor.

Giải pháp cũ:

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

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

Hoạt động rất giống với câu trả lời Pyth của tôi dưới đây:

;\          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 byte)

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

Bộ kiểm tra trực tuyến

Mổ xẻ

Điều này sử dụng sự quan sát của xnor trong câu trả lời Haskell của anh ta rằng sự khác biệt giữa tối đa và tối thiểu của các nyếu tố đầu tiên phải là 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
}

Cách tiếp cận khác (cũng 20 byte)

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

Bộ kiểm tra trực tuyến

Điều này kiểm tra trực tiếp rằng mỗi phần tử sau phần đầu tiên nằm ở khoảng cách 1 từ phần tử trước. Vì đầu vào là một hoán vị và do đó không lặp lại các giá trị, nên đây là một thử nghiệm đầy đủ. Cảm ơn Martin vì đã tiết kiệm 1 byte.

Mổ xẻ

{_{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 byte

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

Trước kia:

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

Đã lưu 3 byte bằng cách thay thế truevà falsebằng 1>0và 0>1.

Đã lưu 23 byte nhờ các đề xuất tuyệt vời từ Peter Taylor!

Ung dung:

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

Theo dõi các giá trị cao nhất và thấp nhất được thấy cho đến nay mvà n; chỉ chấp nhận một giá trị mới nếu nó là m + 1hoặc n - 1tức là giá trị cao hơn hoặc thấp hơn tiếp theo; khởi tạo giá trị cao, mnhỏ hơn một phần tử so với phần tử đầu tiên để nó "khớp" lần đầu tiên xung quanh vòng lặp. Lưu ý: đây là một thuật toán trực tuyến thời gian tuyến tính. Nó chỉ yêu cầu ba từ bộ nhớ, cho các giá trị hiện tại, cao nhất và thấp nhất cho đến nay, không giống như nhiều giải pháp khác.

Nếu giá trị tiếp theo bỏ lỡ cả hai đầu cao và thấp của phạm vi, giá trị thấp nhất cho đến nay được đặt thành -1và sau đó đầu thấp không bao giờ có thể tiến hành và đạt đến không. Sau đó, chúng tôi phát hiện một chuỗi antsy bằng cách kiểm tra xem giá trị thấp n, có đạt đến không.

(Thật không may, điều này kém hiệu quả hơn vì chúng ta luôn phải xem xét toàn bộ chuỗi thay vì bảo lãnh sau số sai đầu tiên , nhưng thật khó để tranh luận với khoản tiết kiệm 23 byte (!) Khi các giải pháp khác đang sử dụng O (n ^ 2 ) và cách tiếp cận thời gian theo cấp số nhân.)

Sử dụng:

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

Lưu ý: điều này cũng có thể được viết mà không tận dụng lợi thế của lambdas Java 8:

Java 7, 89 byte

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 ( ngã ba ), 13 byte

!sstMM.+MSM._

Không có liên kết Dùng thử trực tuyến cho ngã ba này của Pyth. Ngã ba bao gồm chức năng deltas .+, không phải là một phần của thư viện Pyth tiêu chuẩn.

Giải trình:

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

+1 byte cho -n.

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

Giải trình:

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

In 0 nếu sai, 1 nếu đúng.

-11 byte nhờ @Dada

Brainfuck, 60 byte

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

Hoán vị được đưa ra dưới dạng byte không có dấu phân cách và không có dòng mới kết thúc. Vì \x00xảy ra trong đầu vào, điều này được thiết kế để thực hiện với EOF = -1. Đầu ra là \x00sai và\x01 đúng.

Nếu một phép hoán vị \x01lên đến chr(r)được cho phép, thì chúng ta có thể thay thế tất cả các trường hợp ,+với ,điểm số 57 bằng một EOF = 0triển khai.

Dùng thử trực tuyến (phiên bản 57 byte): Đầu vào có thể được cung cấp dưới dạng hoán vị của bất kỳ phạm vi byte liền kề nào loại trừ \x00và đầu ra sẽ là\x00 sai và tối thiểu của phạm vi là đúng.

Chúng tôi theo dõi tối thiểu và tối đa được nhìn thấy cho đến nay, và đối với mỗi ký tự sau lần đầu tiên, hãy kiểm tra xem đó là min-1 hay max + 1 hay không. Trong trường hợp không, di chuyển con trỏ ra ngoài không gian làm việc bình thường để các ô cục bộ trở thành số không.

Bố cục bộ nhớ của không gian làm việc bình thường ở đầu vòng lặp chính là

c a b 0 0

trong đó clà ký tự hiện tại, alà tối thiểu và blà tối đa. (Đối với phiên bản 60 byte, mọi thứ được xử lý với độ lệch là 1 vì ,+.)

Brachylog , 22 byte

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

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

Giải trình

Tôi chưa tìm thấy cách kiểm tra ngắn gọn xem danh sách có chứa số nguyên liên tiếp hay không. Ngắn nhất tôi tìm thấy là tạo ra một phạm vi giữa phần tử đầu tiên và cuối cùng của danh sách đó và kiểm tra xem phạm vi đó là danh sách ban đầu.

:@[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

Mẻ, 133 byte

@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

Lấy đầu vào làm đối số dòng lệnh. Thoát với lỗi cấp 0 cho thành công, 1 cho thất bại.

J, 14 byte

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

Điều này dựa trên phương pháp của @ xnor .

Giải trình

/:~-:>./\-<./\  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 byte

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

Mảng xcó các giá trị từ 0 đến số tối đa theo thứ tự (Python sẽ tốt hơn nhiều ở đây ...). Vòng lặp đi ngược lại cố gắng khớp số thấp nhất ( x[b]) hoặc cao nhất ( x[e]) chưa gặp phải; nếu có, con số đó có thể đạt được trong bước đó.

Mã kiểm tra tại đây .

Toán học, 47 byte

Lâu hơn một chút so với giải pháp của Martin Ender (ngạc nhiên bất ngờ!). Nhưng đó là một trong những nỗ lực không thể đọc được của tôi, vì vậy điều đó thật tốt: D

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

Giải trình:

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

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

Mã thử nghiệm & mã hóa:

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

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

Đầu ra:

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