บทนำ

สมมติว่าคุณมีผู้ปกครองที่มีตัวเลขจาก0ไปR-1 คุณวางมดไว้ระหว่างตัวเลขสองตัวใด ๆ แล้วมันก็เริ่มคลานอย่างผิดพลาดบนไม้บรรทัด ผู้ปกครองแคบมากจนมดไม่สามารถเดินจากตำแหน่งหนึ่งไปอีกตำแหน่งหนึ่งได้โดยไม่ต้องเดินตามตัวเลขทั้งหมดในระหว่างนั้น เมื่อมดเดินมาหาตัวเลขเป็นครั้งแรกคุณจะบันทึกและสิ่งนี้จะให้การเปลี่ยนรูปของตัวเลขr เราบอกว่าการเรียงสับเปลี่ยนเป็นสิ่งที่บ้าถ้ามันสามารถสร้างขึ้นโดยมดในวิธีนี้ อีกวิธีหนึ่งคือการเรียงสับเปลี่ยนpคือ antsy หากทุกรายการp [i]ยกเว้นรายการแรกอยู่ภายในระยะทาง 1 จากรายการก่อนหน้าบางส่วน

ตัวอย่าง

การเรียงสับเปลี่ยนความยาว -6

4, 3, 5, 2, 1, 0

เป็น antsy เพราะ3อยู่ในระยะที่ 1 จาก4 , 5อยู่ในระยะที่ 1 จาก4 , 2อยู่ในระยะที่ 1 จาก3 , 1อยู่ในระยะที่ 1 จาก2และ0อยู่ในระยะที่ 1 จาก1 การเรียงสับเปลี่ยน

3, 2, 5, 4, 1, 0

ไม่ได้วิตกกังวลเพราะ5ไม่ได้อยู่ในระยะที่ 1 ทั้ง3หรือ2 ; มดจะต้องผ่าน4ที่จะได้รับ5

งาน

กำหนดการเปลี่ยนแปลงของตัวเลขจาก0ถึงr-1สำหรับ1 ≤ r ≤ 100ในรูปแบบที่สมเหตุสมผลให้เอาท์พุทค่าความจริงหากการเปลี่ยนรูปเป็นความโกรธและค่าเท็จถ้าไม่

กรณีทดสอบ

[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พีชคณิต antsy ของความยาวR

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 ในรายการ antsy เรียงลำดับนี้เป็นเอกลักษณ์ยกเว้นตัวเลือกโดยพลการระหว่างสองสำเนาที่อยู่ติดกันขององค์ประกอบแรกที่เป็นต้นฉบับ

Haskell, 46 ไบต์

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

ตรวจสอบว่าความแตกต่างของเวกเตอร์ของ maxima ที่กำลังทำงานและ minima ที่ทำงานอยู่คือ [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])

ตรวจสอบว่าแต่ละคำนำหน้าของรายการมีตัวเลขทั้งหมดระหว่างขั้นต่ำและสูงสุดรวมหรือไม่ มันทำได้โดยการตรวจสอบว่าความแตกต่างของ max และ min น้อยกว่าความยาวหรือไม่

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 ค่าในคอลัมน์ทั้งหมดยกเว้นค่าแรก

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

การเปลี่ยนแปลงคือความโกรธถ้าหากว่า subpermutations ด้านซ้ายทั้งหมดนั้นมีความต่อเนื่อง

หากอินพุตรับประกันว่ามีความยาวมากกว่าหนึ่งเราสามารถแทนที่1:sum(1|v)ด้วยseq(v)ซึ่งจะบันทึกสี่ไบต์

seq(v)ในถ้าเงื่อนไขพฤติกรรมแตกต่างกันเมื่อเข้าเป็นหนึ่งของความยาว --- มันสร้างลำดับแทน1:v seq_along(v)อย่างไรก็ตามโชคดีที่ผลลัพธ์ออกมาเป็นTRUEในกรณีนี้ซึ่งเป็นพฤติกรรมที่ต้องการ สิ่งเดียวกันก็เกิดขึ้นสำหรับอินพุตที่ไม่มีความยาว

ใน R Tคือตัวแปรที่ตั้งไว้ล่วงหน้าเท่ากับTRUE(แต่ R อนุญาตให้คุณกำหนดใหม่) นอกจากนี้ยังจะถือว่าเป็นเท่ากับTRUE1

ขอบคุณ @Billywob สำหรับการปรับปรุงที่เป็นประโยชน์ต่อโซลูชันต้นฉบับ

05AB1E , 7 ไบต์

Âìæ¹{¢O

ลองออนไลน์! หรือเป็นชุดทดสอบการแก้ไข

คำอธิบาย

ใช้กระบวนการที่อธิบายไว้โดยXNOR ในคำตอบของเขา
ส่งคืน 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 bytes) คำตอบ แต่ฉันคิดว่าโซลูชันนี้ยังน่าสนใจดังนั้นฉันจึงโพสต์

จำนวนไบต์ประกอบด้วยรหัสและ-nแฟล็ก 62 ไบต์

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ให้เป็นตัวแทนของ unary k+1(ที่+1จำเป็นดังนั้น0s จะไม่ถูกละเว้น) แล้วสำหรับแต่ละหมายเลขk+1(แสดงในเอกเป็น1(1*)) เรามองว่าถ้าอย่างใดอย่างหนึ่งk( $1ถือk) หรือk+2(ซึ่งเป็นแล้ว11$1) ที่มีอยู่ในสตริงก่อนหน้า (อ้างอิงจาก$-backtick) ถ้าไม่เช่นนั้นเราตั้งค่า$.เป็นศูนย์ ในตอนท้ายเราพิมพ์$.ซึ่งจะเป็น1ถ้าเราไม่เคยตั้งค่าเป็นศูนย์หรือเป็นศูนย์

Brain-Flak 302 264 256 Bytes

ขอบคุณ Wheat Wizardสำหรับการบันทึก 46 ไบต์

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

ด้านบนของสแต็กจะเป็น 1 สำหรับความจริงและ 0 สำหรับเท็จ

Truthy: ลองออนไลน์!
Falsy: ลองออนไลน์!

แนวคิดคือเก็บหมายเลขต่ำสุดและสูงสุดที่ ant ได้เข้าชมในกองซ้อน จากนั้นเปรียบเทียบแต่ละหมายเลขกับทั้งสองและอัพเดตหมายเลขที่เหมาะสม หากตัวเลขถัดไปไม่ใช่ 1 น้อยกว่าค่าต่ำสุดหรือมากกว่า 1 ค่าสูงสุดให้แบ่งออกจากลูปและส่งกลับค่าเท็จ

คำอธิบายสั้น ๆ :

([])                             # 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 ของเขาว่าความแตกต่างระหว่างสูงสุดและต่ำสุดของแรกองค์ประกอบที่ควรจะเป็นnn-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>00>1

บันทึกแล้ว 23 ไบต์ด้วยคำแนะนำที่ยอดเยี่ยมจาก Peter Taylor!

Ungolfed:

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ถึงศูนย์หรือไม่

(น่าเสียดายที่นี่มีประสิทธิภาพน้อยกว่าเพราะเราต้องดูลำดับทั้งหมดมากกว่าการประกันตัวหลังจากหมายเลขผิดครั้งแรกแต่มันยากที่จะโต้แย้งกับการประหยัด 23- ไบต์ (!) เมื่อโซลูชันอื่นกำลังใช้ 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);
    }
}

หมายเหตุ: สามารถเขียนได้โดยไม่ใช้ประโยชน์จาก lambdas 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 ( ทางแยก ), 13 ไบต์

!sstMM.+MSM._

ไม่มีการเชื่อมโยงลองออนไลน์สำหรับทางแยกของ Pyth fork มีฟังก์ชัน 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

พิมพ์ 0 ถ้าเป็นเท็จ 1 ถ้าเป็นจริง

-11 ไบต์ขอบคุณ @Dada

Brainfuck, 60 ไบต์

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

การเรียงสับเปลี่ยนจะถูกกำหนดเป็นไบต์โดยไม่มีตัวคั่นและไม่ขึ้นบรรทัดใหม่ เนื่องจากเกิดขึ้นในการป้อนข้อมูลนี้ถูกออกแบบมาสำหรับการใช้งานกับ\x00 EOF = -1เอาต์พุตเป็น\x00เท็จและ\x01เป็นจริง

หากอนุญาตให้มีการเปลี่ยนรูป\x01ได้สูงสุดchr(r)เราสามารถแทนที่อินสแตนซ์ทั้งหมด,+ด้วย,เป็น 57 คะแนนด้วยการEOF = 0ใช้งาน

ลองใช้ออนไลน์ (รุ่น 57- ไบต์): อินพุตสามารถกำหนดเป็นช่วงเปลี่ยนแปลงของช่วงไบต์ที่ต่อเนื่องใด ๆ ที่ไม่รวม\x00และเอาต์พุตจะเป็น\x00เท็จและต่ำสุดของช่วงเป็นจริง

เราติดตามนาทีและสูงสุดที่เห็นจนถึงตอนนี้และสำหรับตัวละครแต่ละตัวหลังแรกให้ตรวจสอบว่ามันเป็น min-1 หรือ max + 1 หรือไม่ ในกรณีที่ไม่ใช่ให้ย้ายตัวชี้นอกพื้นที่ทำงานปกติเพื่อให้เซลล์ในท้องถิ่นกลายเป็นศูนย์

เลย์เอาต์ของหน่วยความจำของพื้นที่ทำงานปกติที่จุดเริ่มต้นของลูปหลักคือ

c a b 0 0

โดยที่cอักขระปัจจุบันaคือ min และbmax (สำหรับรุ่น 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;}

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

Ungolfed & รหัสการทดสอบ:

ลองที่นี่

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