Giriş

Diyelim ki 0'dan r-1'e kadar sayıları olan bir cetveliniz var . Sayılardan herhangi birinin arasına bir karınca yerleştirin ve cetvel üzerinde düzensiz bir şekilde taramaya başlar. Cetvel o kadar dardır ki, karınca aradaki tüm sayılar üzerinde yürümeden bir konumdan diğerine yürüyemez. Karınca ilk kez bir numaraya girdiğinde, onu kaydedersiniz ve bu size r sayıları için bir izin verir . Bu şekilde bir karınca tarafından üretilebiliyorsa, permütasyonun antsy olduğunu söylüyoruz . Alternatif olarak, ilk hariç bazı p [i] girişleri bir önceki girişten 1 uzakta ise , bir permütasyon p yanıltıcıdır .

Örnekler

Uzunluk-6 permütasyonu

4, 3, 5, 2, 1, 0

Çünkü, sabırsız bir 3 mesafe 1 içinde 4 , 5 arasında mesafe 1 içinde 4 , 2 arasındaki mesafe 1 içinde , 3 , 1 mesafe 1 içinde 2 ve 0 mesafe 1 içinde 1 . Permütasyon

3, 2, 5, 4, 1, 0

antsy değildir, çünkü 5 , 3 veya 2'nin 1'i arasında değildir ; karınca 5 almak için 4 geçmesi gerekirdi .

Görev

Herhangi bir makul formatta 1 ≤ r ≤ 100 için 0 ile r-1 arasındaki sayılardaki bir permütasyon göz önüne alındığında , eğer permüyonun antipse ise bir aldatma değeri ve eğer değilse sahte bir değer verilir.

Test durumları

[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

Eğlence gerçek: için r ≥ 1 , tam olarak orada 2 ^r-1 uzunluğu Antsy permütasyon r .

Pyth, 7 bayt

/y+_QQS

Çevrimiçi deneyin. (Üstel çalışma süresi nedeniyle sadece küçük test vakaları dahil edilmiştir.) Truthy için 2, Falsey için 0 çıktılar.

/          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

Diğer bir deyişle,

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

burada subseqçıkış ilk listenin elemanları ikinci listede sırayla görünür olup, zorunlu olarak bitişik değildir. Bu subseq, Pyth'te, öğelerin sırasını tutan ikinci listenin tüm alt kümelerini alarak ve ilk listenin oluşum sayısını sayarak yapılır. Bu üssel zaman alır.

Bu neden işe yarıyor? Bir permüsyonun antipsi olması için 0'dan n-1'e adım atmak sadece sola, sonra sadece sağa gitmekten ibaret olmalıdır. Bunun nedeni, birinci öğeden daha büyük olan öğelerin soldan sağa artması ve bundan daha küçük olanların soldan sağa düşmesi gerektiğidir.

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

Listeyi tersine bir kopyasını sola koyarak yansıtırsak, bu yürüyüş sadece sağa gider.

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

Buna karşılık, bu yansıtma listesinin herhangi bir hakkı, orijinal listenin soldan sağa yürüyüşüne karşılık gelir. Bu doğru, sadece 0'dan n-1'e kadar sıralanmış bir dizilimdir. Bir antsy listesinde, bu sıralanan sıralama, orijinal ilk elemanın bitişik iki kopyası arasındaki keyfi bir seçim dışında, benzersizdir.

Haskell, 46 bayt

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

Çalışan maksima ve çalışan minima arasındaki vektör farkının [0,1,2,3 ...] olup olmadığını kontrol eder.

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 ile 2 bayt kurtardı (%)=scanl1.

JavaScript (ES6), 45

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

Bir açıklama olarak ihtiyaç duymayacak kadar basit olduğunu düşündüm, ama bir numara var, ve tam da, işte ilk versiyonum golf öncesi

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

Not: aramanın içindeki orijinal diziye referans almam gerekmediğinden golf kodunda ayerine kullanılır . Bu yüzden parametreyi yeniden kullanarak global isim alanını kirletmekten kaçınırım.kevery

Ölçek

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 bayt

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

Listedeki her ön ekin min ve max dahil arasındaki tüm sayıları içerip içermediğini kontrol eder. Max ve min arasındaki farkın uzunluktan az olup olmadığını kontrol ederek bunu yapar.

54 bayt:

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

Son öğenin, diğer öğelerin dakikalarından birinden daha az mı yoksa en fazla birinden daha mı fazla olduğunu kontrol eder. Sonra son elemanı kaldırır ve özyinelemeler. Tek eleman listesinde, True çıktı verir.

Bu aynı zamanda eğlenceli ancak daha uzun bir liste anlayışıyla kontrol edilebilir.

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

Eşitsizliği kullanmak isterdim min(l)-2<l.pop()<max(l)+2, ama önce popyapılması gerekenler. Hata kodu ile çıktı almak için bir program kullanmak daha kısa olacaktır.

Mathematica, 42 bayt

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

Bir asonraki öğeden maksimum farkı (ve sonucu olumsuzlayarak) bbüyük olan bir önek bulmak ve denemek için desen eşleştirmesini kullanır .1MatchQ

Perl, 39 38 35 bayt

İçin +1 içerir -p

STDIN'de sıra ver:

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

antsy.pl:

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

MATL , 11 bayt

&-|R1=a4L)A

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

Bu, tüm ikili çift mutlak farkların matrisini hesaplar ve üst üçgen kısmı tutar. Sonuç, birincisi dışındaki tüm sütunlarda en az 1 değer varsa doğrudur.

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

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

Bir permütasyon, eğer ve sadece soldaki tüm alt bölümlerinin sürekli olması durumunda (yani, sıralandığında bir fark varsa), takmadır.

Girdi Birden fazla uzunluğa sahip garanti edilirse, o zaman yerini alabilir 1:sum(1|v)ile seq(v)dört bayt kazandırır,.

seq(v)Giriş uzunluklarda olduğu zaman, bu durum davranır farklı --- o dizisi, eğer 1:vyerine seq_along(v). Ancak, neyse ki, çıktı TRUEbu durumda istenen davranış olarak ortaya çıkıyor. Aynı şey sıfır uzunluklu giriş için de geçerlidir.

R'de, Teşit bir önceden ayarlanmış değişkendir TRUE(ancak R, yeniden tanımlamanıza izin verir). TRUEaynı zamanda eşit olarak kabul edilir 1.

Orijinal çözümde bazı yararlı iyileştirmeler için @Billywob'a teşekkür ederiz.

05AB1E , 7 bayt

Âìæ¹{¢O

Çevrimiçi deneyin! veya değiştirilmiş bir test paketi olarak .

açıklama

Xnor tarafından açıklanan Pyth cevabında açıklanan süreci kullanır .
Gerçek örnekleri için 2, sahte için 0 döndürür.

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

@Gabriel Banamy'nin daha kısa (55 bayt) bir cevapla geldiğini unutmayın . Ama bu çözümün hala ilginç olduğunu düşünüyorum, bu yüzden gönderiyorum.

Bayt sayısı, 62 bayt kod ve -nbayrağını içerir.

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

Çalıştırmak için:

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

Kısa açıklamalar : her sayıyı kbirliğin temsili durumuna dönüştürür k+1(bu +1gereklidir, böylece 0s göz ardı edilmez). Daha sonra her bir sayı için k+1(aynı şekilde ifade edilir 1(1*)), önceki dizgede (referans gösterilen ) ya k( $1tutma k) ya da k+2(o zaman olan ) olup olmadığına bakarız . Hayır ise, sıfıra ayarlanırız . Sonunda , asla sıfıra ya da sıfıra ayarlamazsak , yazdıracağız .11$1$-backtick$.$.1

Brain-Flak 302 264 256 Bayt

46 bayt tasarruf için Buğday Sihirbazı sayesinde

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

Yığının tepesi gerçeğe uygun bir 1 ve sahte için 0 olacak.

Truthy: Çevrimiçi Deneyin!
Falsy: Çevrimiçi Deneyin!

Buradaki fikir, karıncanın istifini ziyaret ettiği asgari ve azami sayıyı tutmaktır. Sonra her numarayı ikisiyle karşılaştırın ve uygun olanı güncelleyin. Bir sonraki sayı en az 1'den küçük veya en fazla 1'den küçük değilse, döngüden ayrılın ve yanlış döndürün.

Kısa açıklama:

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

Jöle , 9 8 7 bayt

;@UŒPċṢ

Çevrimiçi Deneyin!

Xnor'ın cevabının bir Jelly çevirisi.

Eski çözümler:

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

Çevrimiçi deneyin!

Aşağıdaki Pyth cevabımı çok benzer çalışır:

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

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

Çevrimiçi test paketi

teşrih

Bu, Haskell cevabında xnor tarafından yapılan gözlemi kullanır, ilk nelementlerin maksimum ve minimum arasındaki farkın olması gerektiği yanıtını verir 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
}

Alternatif yaklaşım (ayrıca 20 bayt)

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

Çevrimiçi test paketi

Bu, doğrudan ilk elemandan sonraki her elemanın bir önceki elemandan 1 uzakta olduğunu kontrol eder. Girdi bir permütasyon olduğundan ve dolayısıyla değerleri tekrarlamadığından, bu yeterli bir testtir. Martin'e 1 baytlık tasarruf için teşekkürler.

teşrih

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

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

eskiden:

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

Değiştirerek 3 bayt kaydedilmiş trueve falseile 1>0ve 0>1.

Peter Taylor'ın mükemmel önerileri sayesinde 23 bayt kurtarıldı!

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

Olarak bugüne kadar gördüğü en yüksek ve en düşük değerler takip edin mve n; sadece yeni bir değeri kabul ederse m + 1veya bir n - 1sonraki veya daha yüksek değer ise; yüksek değeri, milk elemandan daha küçük bir değere, böylece ilk kez döngü etrafında "eşleşecek" şekilde başlatın. Not: Bu doğrusal zaman, çevrimiçi bir algoritmadır. Diğer çözümlerin çoğundan farklı olarak, şu ana kadar elde edilen, en yüksek ve en düşük değer için yalnızca üç sözcük gerektirir.

Bir sonraki değer, aralığın hem yüksek hem de düşük uçlarını özlüyorsa, şimdiye kadar en düşük değer olarak ayarlanır -1ve sonra düşük uç hiçbir zaman ilerleyemez ve sıfıra ulaşamaz. Daha sonra düşük değerin nsıfıra ulaşıp ulaşmadığını kontrol ederek bir antsy dizi tespit ettik .

(Ne yazık ki bu daha az etkilidir, çünkü ilk yanlış numaradan sonra kurtulmak yerine her zaman dizinin tamamına bakmamız gerekir , ancak diğer çözümler O (n ^ 2 kullanırken), 23 baytlık bir tasarrufla (!) Tartışmak zordur. ) ve üstel zaman yaklaşımları.)

Kullanımı:

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

Not: Bu ayrıca Java 8 lambdalarından yararlanmadan da yazılabilir:

Java 7, 89 bayt

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 ( çatal ), 13 bayt

!sstMM.+MSM._

Hayır Deneyin Bu Pyth çatal için çevrimiçi bağlantı. Çatal .+, standart Pyth kütüphanesinin bir parçası olmayan deltas fonksiyonunu içerir .

Açıklama:

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

İçin +1 bayt -n.

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

Açıklama:

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 ise 0, true ise 1 yazdırır.

@Dada sayesinde -11 bayt

Brainfuck, 60 bayt

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

Permütasyon, ayırıcı ve sonlandırıcı newline olmayan bayt olarak verilir. Girdide \x00gerçekleştiğinden bu , ile yapılan uygulamalar için tasarlanmıştır EOF = -1. Çıktı \x00yanlış ve \x01doğru.

Bir permütasyon Eğer \x01up chr(r)izin verilir, o zaman tüm örneklerini yerini alabilir ,+ile ,bir ile 57 puan için EOF = 0uygulanması.

Çevrimiçi deneyin (57 bayt sürümü): Girdi hariç \x00, herhangi bir bitişik bayt aralığının permantı olarak verilebilir ve çıktı \x00yanlış ve doğru değer için minimum olur.

Şimdiye kadar görülen minimum ve maksimum değerleri takip ediyoruz ve ilk karakterden sonraki her karakter için min-1 veya maksimum + 1 olup olmadığını kontrol ediniz. Hiçbirinde, imleci normal çalışma alanının dışına hareket ettirerek yerel hücrelerin sıfır olmasını sağlayın.

Normal çalışma alanının ana döngünün başlangıcındaki bellek düzeni

c a b 0 0

cGeçerli karakter nerede , amin ve bmaks. (60 baytlık sürüm için, her şey nedeniyle 1 ofset ile ele alınır ,+.)

Brachylog , 22 bayt

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

Çevrimiçi deneyin!

açıklama

Bir listenin ardışık tamsayılar içerip içermediğini kontrol etmenin kısa bir yolunu bulamadım. Bulduğum en kısa süre, o listenin ilk ve son elemanı arasında bir aralık oluşturmak ve o aralığın orijinal liste olup olmadığını kontrol etmektir.

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

Toplu iş, 133 bayt

@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

Girdiyi komut satırı argümanları olarak alır. Başarı için hata seviyesi 0, başarısızlık için 1 değerinden çıkar.

J, 14 bayt

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

Bu @ xnor yöntemine dayanmaktadır .

açıklama

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

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, siparişte 0 ile maksimum arasında bir değere sahiptir (Python burada çok daha iyi olurdu ...). Döngü, henüz karşılaşılmayan x[b]en düşük ( ) veya en yüksek ( x[e]) sayıya uymaya çalışırken geriye doğru gider ; eğer öyleyse, bu sayıya o adımda ulaşılabilir.

Burada test kodu .

Mathematica, 47 bayt

Martin Ender'in çözümünden biraz daha uzun (sürpriz sürpriz!). Ama bu benim daha okunamayan çabalarımdan biri, bu yüzden iyi: D

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

Açıklama:

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

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 ve test kodu:

Burada dene.

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

Çıktı:

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