Bir önemsiz dizi ardışık elemanlar arasında mutlak fark göre tüm küçük veya eşit pozitif tamsayılar, bir dizi 1 .

Örneğin, aşağıdaki dizi önemsiz:

[1, 2, 3, 4, 3, 4, 5, 5, 5, 4]

Çünkü karşılık gelen (mutlak) farklılıklar:

[1, 1, 1, 1, 1, 1, 0, 0, 1]

Tüm daha küçük olan veya eşit Hangi 1 .

Göreviniz verilen bir tam sayı dizisinin önemsiz olup olmadığını belirlemektir.

• Dizinin her zaman en az iki öğe içerdiğini varsayabilirsiniz.
• Standart giriş ve çıkış kuralları geçerlidir. Herhangi bir makul formatta girdi (ve çıktı) alabilirsiniz.
• Varsayılan Loopholes yasaktır.
• Hakikat / sahte değerler farklı ve tutarlı olmalıdır.
• Bu kod golf , bayt cinsinden en kısa cevap kazanır.

Test durumları

Giriş -> Çıkış

[1, 2, 3, 4, 3, 4, 5, 5, 5, 4] -> doğru
[1, 2, 3, 4, 5, 6, 7, 8, 9, 8] -> doğru
[3, 3, 3, 3, 3, 3, 3] -> doğru
[3, 4, 4, 4, 3, 3, 3, 4, 4, 4] -> doğru
[1, 2, 3, 4] -> doğru 
[5, 4, 3, 2] -> doğru 
[1, 3, 5, 7, 9, 7, 5, 3, 1] -> yanlış
[1, 1, 1, 2, 3, 4, 5, 6, 19] -> yanlış
[3, 4, 5, 6, 7, 8, 7, 5] -> yanlış
[1, 2, 4, 10, 18, 10, 100] -> yanlış
[10, 20, 30, 30, 30] -> yanlış

Ben değerleri kullanılır trueve false.

Jöle , 3 bayt

IỊẠ

Çevrimiçi deneyin!

Nasıl?

Jelly için sadece mükemmel bir meydan okuma.

Ben tam program.

I Artışlar; Ardışık elemanlar arasındaki farkı al.
 Ị Önemsiz; geri dönüş abs (sayı) ≤ 1.
  Ạ Hepsi; Tüm elemanlar truthy ise 1, aksi takdirde 0 döndürür.

JavaScript (ES7), 33 29 bayt

@JohanKarlsson sayesinde 4 bayt kaydedildi

a=>!a.some(v=>(a-(a=v))**2>1)

Nasıl?

Zorlandığında Number, en az iki elementin dizileri olarak değerlendirilir NaN. Tarafından giriş yeniden kullanarak a önceki değeri tutan değişken birinci yineleme olarak bazı () her zaman sonuçlanır ([v0, v1, ...] - a [0]) ** 2 = NaN , hiç önemi [0] değeri . Bu yüzden, ilk test her zaman sahtedir ve gerçek karşılaştırmalar, tam olarak oldukları gibi 2. tekrarda başlar.

Test durumları

let f =

(a,p)=>!a.some(v=>(p-(p=v))**2>1)

console.log(f([1, 2, 3, 4, 3, 4, 5, 5, 5, 4])) // true
console.log(f([1, 2, 3, 4, 5, 6, 7, 8, 9, 8])) // true
console.log(f([3, 3, 3, 3, 3, 3, 3]         )) // true
console.log(f([3, 4, 4, 4, 3, 3, 3, 4, 4, 4])) // true
console.log(f([1, 2, 3, 4]                  )) // true
console.log(f([5, 4, 3, 2]                  )) // true
console.log(f([1, 3, 5, 7, 9, 7, 5, 3, 1]   )) // false
console.log(f([1, 1, 1, 2, 3, 4, 5, 6, 19]  )) // false
console.log(f([3, 4, 5, 6, 7, 8, 7, 5]      )) // false
console.log(f([1, 2, 4, 10, 18, 10, 100]    )) // false
console.log(f([10, 20, 30, 30, 30]          )) // false

Python 3 , 40 bayt

f=lambda n,*t:t==()or-2<n-t[0]<=1==f(*t)

Çevrimiçi deneyin!

Mathematica, 24 bayt

Max@Abs@Differences@#<2&

Python 2,35 bayt

x=input()
while-2<x.pop(0)-x[0]<2:1

Önemsiz diziler için durum kodu 1'de , aksi durumda 0 durum kodu var .

Çevrimiçi deneyin!

Kabuğu , 4 bayt

ΛεẊ-

Çevrimiçi deneyin!

Açıklama:

ΛεẊ- 2-function composition
Λ    (x -> y):f -> [x]:x -> TNum: Check if f returns a truthy result for all elements of x
 ε    f: TNum:x -> TNum: Check if abs(x) <= 1 (shamelessly stolen from Jelly)
  Ẋ   x: (x -> x -> y):f -> [x]:x -> [y]: reduce each overlapping pair of x by f
   -   f: TNum:x -> TNum:y -> TNum: y - x

Octave , 21 bayt

@(x)all(diff(x).^2<2)

Sayısal bir vektör giren adsız işlev ve 1önemsiz veya 0başka türlü ise çıkışlar .

Çevrimiçi deneyin!

Haskell , 34 33 bayt

all((<2).abs).(zipWith(-)=<<tail)

Çevrimiçi deneyin! @ User1472751 sayesinde -1 bayt

Nokta içermeyen bir çözüm , bir , iki yine sadece bir byte ( -1 gelen bayt sayesinde @Dennis yinelemeli bir yaklaşım daha kısa):

f(a:b:r)=2>(a-b)^2&&f(b:r)
f _=1>0

Çevrimiçi deneyin!

Pyth , 6 bayt

._MI.+

Tüm test durumlarını doğrulayın.

Pyth , 8 bayt

.A<R2aVt

Çevrimiçi deneyin!

açıklama

._MI.+   Full program.

    .+   Deltas.
   I     Is invariant under...
._M      Mapping with Sign. 0 if n == 0, -1 if n < 0, 1 if n > 0.

.A<R2aVt    Full program.

      Vt    Vectorize function, applied on the input zipped with the tail of the input.
     a      Absolute difference.
  <R2       For each, check if it is smaller than 2.
.A          All.

Proton , 41 bayt

a=>all(-2<a[i]-a[i+1]<2for i:0..len(a)-1)

Çevrimiçi deneyin!

- Bay Xcoder sayesinde -16 bayt
-2 bayt
- Bay Xcoder sayesinde -6 bayt

Japt , 6 bayt

äa e<2

Çevrimiçi deneyin!

açıklama

ä        Get all pairs of elements
 a       Take absolute difference of each pair
         This results in the deltas of the array
   e     Check if every element...
    <2   Is less than 2

C # (.NET Core) , 51 45 44 + 18 bayt

Jeppe Stig Nielsen sayesinde -1 bayt

a=>a.Zip(a.Skip(1),(x,y)=>x-y).All(x=>x*x<4)

Bayt sayısı ayrıca şunları içerir:

using System.Linq;

Çevrimiçi deneyin!

Açıklama:

a =>                      // Take an array of integers as input
    a.Zip(                // Combine each element with corresponding one from:
        a.Skip(1),        //     the input array without first element
        (x, y) => x - y   //     get their difference
    )
    .All(x => x * x < 4)  // Check if all differences are less than 2
                          // (We only care about 0 and 1, and so happens that when they're squared, it works like Abs! Magic!)

Perl 6 , 25 bayt

{?(2>all(.[]Z-.skip)>-2)}

Çevrimiçi deneyin!

Bu oldukça okunaklı olmalı. Buradaki daha az belirgin olan şey Z, kısa operatörün tükenmesi durumunda zip operatörünün sıkıştırmayı durdurması (listenin ilk öğesini sağdaki kaldırıyoruz) ve .[]Zen dilimi olarak adlandırılan boş alt listenin tüm listeyi vermesidir. .skipilk öğe olmadan listeyi döndürür.

R , 30 26 bayt

cat(all(diff(scan())^2<2))

Çevrimiçi deneyin!

05AB1E , 5 bayt

¥Ä2‹P

Çevrimiçi deneyin!

açıklama

¥        # calculate deltas
 Ä       # absolute values
  2‹     # smaller than 2
    P    # product

Ohm v2 , 4 bayt

Δ2<Å

Çevrimiçi deneyin!

Nasıl?

Δ2<Å   ~ Full program.

Δ      ~ Absolute deltas.
 2<    ~ Is smaller than 2?
   Å   ~ Check if all elements are truthy.

PowerShell , 62 bayt

param($a)$l=$a[0];($a|?{$_-$l-in1..-1;$l=$_}).count-eq$a.count

Çevrimiçi deneyin!

PowerShell'in bir .mapveya .somebenzeri bir komutu yoktur, bu yüzden burada her deltayı ayrı ayrı kontrol ediyoruz.

Girdiyi alıyoruz $ave $lilk öğeye eşit olarak ayarlıyoruz . Sonra döngü $ave her eleman çıkarmak |?{...}fark $_-$lolduğunu -inaralığı 1,0,-1. Daha sonra $lmevcut öğeye eşit olarak ayarladık . Önceki komşusu arasındaki delta 1. olduğu Şimdi biz unsurların bir koleksiyona sahip Biz almak .counto ve 's olmadığını kontrol -eqUAL etmek.count bir bütün olarak dizinin. Öyleyse, her delta 1 veya daha azdır, bu nedenle önemsiz bir dizidir. Bu Boolean sonucu boru hattında bırakılır ve çıktı kesindir.

Python 3 , 45 bayt

lambda k:all(-2<x-y<2for x,y in zip(k,k[1:]))

Çevrimiçi deneyin! veya Test takımını deneyin.

Jonathan Frech'e -2 bayt için teşekkürler .

Java (OpenJDK 8) , 78 bayt

a->{int p=0,i=1;for(;i<a.length;p+=Math.abs(a[i]-a[i++-1])>1?1:0);return p<1;}

Çevrimiçi deneyin!

MATL ,6 5 bayt

d|2<A

Giuseppe sayesinde -1 bayt

Çevrimiçi deneyin! veya Tüm test durumlarını doğrula

anyfix , 9 bayt

I€A€2<»/&

Çevrimiçi deneyin!

I€A€2<»/&  Main Link
I          Deltas
 €         For each element
  A        Take its absolute value
   €  »    For each element
    2<     Is it less than two?
       /   Reduce over
        &  Logical AND

Bu, çoğu yerde 05AB1E çözümünün bir limanıdır, çünkü korkunçtur, herhangi bir otovektörleşme ve başka harika şeyler yoktur.

C, 61 56 bayt

Beş bayt tasarrufu için @scottinet için teşekkürler!

r;f(a,n)int*a;{for(r=1;--n;r=(*a-*++a)/2?0:r);return r;}

Çevrimiçi deneyin!

C (gcc), 47 bayt

r;f(a,n)int*a;{for(r=1;--n;r=(*a-*++a)/2?0:r);}

Çevrimiçi deneyin!

Clojure, 35 bayt

#(every? #{-1 0 1}(map -(rest %)%))

Bu ne kadar düzenli?

TI-Basic, 6 7 bayt

prod(2>abs(ΔList(Ans

veya, eğer hatalar geçerli geri dönüş değeri olarak sayılırsa 5 bayt ( ERR:ARGUMENTönemsiz olması durumunda döndürür ERR:DOMAIN)

augment(sin⁻¹(ΔList(Ans

JavaScript (ES6), 37 adet 36 bayt

(a,u)=>!a.some(e=>(e-=(u=e))>1|e<-1)

Düzenleme: @ Arnauld's hilesini çalarak kaydetti 1 byte.

Pyth, 7 bayt

._I#I.+

Test odası

Doğru / yanlış döndürür.

Açıklama:

     .+ Deltas, returns differences between consecutive values.
._      Signum, returns the sign of a number (1, 0, or -1).  Note that this should
             be equal to the input for insignificant arrays.
  I     Tests if it is equal to the input...
   #    For each in the input, and filter out those that aren't...
    I   And make sure none have been filtered out.

Mathematica, 34 bayt

Differences@#~MatchQ~{(1|0|-1)..}&

açıklama

                                 & (* Function *)
Differences                        (* which takes the consecutive differences*)
           @#                      (* of the input list *)
             ~MatchQ~              (* and returns whether it matches *)
                     {(1|0|-1)..}  (* a list consisting of one or more 1s, 0s, or -1s *)

Java (OpenJDK 8) , 60 bayt

a->{int r=1,p=a[0];for(int i:a)r|=(r=p-(p=i))*r;return r<2;}

Çevrimiçi deneyin!

• @Nevay sayesinde 5 bayt!

Swift 4, 52 bayt

{!zip($0.dropFirst(),$0).map(-).contains{1<abs($0)}}

Test odası:

let isInsignificant: (_ array: [Int]) -> Bool = {!zip($0.dropFirst(),$0).map(-).contains{1<abs($0)}}

let testcases: [(input: [Int], expected: Bool)] = [
    (input: [1, 2, 3, 4, 3, 4, 5, 5, 5, 4], expected: true),
    (input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 8], expected: true),
    (input: [3, 3, 3, 3, 3, 3, 3],          expected: true),
    (input: [3, 4, 4, 4, 3, 3, 3, 4, 4, 4], expected: true),
    (input: [1, 2, 3, 4],                   expected: true ),
    (input: [5, 4, 3, 2],                   expected: true ),
    (input: [1, 3, 5, 7, 9, 7, 5, 3, 1],    expected: false),
    (input: [1, 1, 1, 2, 3, 4, 5, 6, 19],   expected: false),
    (input: [3, 4, 5, 6, 7, 8, 7, 5],       expected: false),
    (input: [1, 2, 4, 10, 18, 10, 100],     expected: false),
    (input: [10, 20, 30, 30, 30],           expected: false),
]


for (caseNumber, testcase) in testcases.enumerated() {
    let actual = isInsignificant(testcase.input)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \(testcase.input) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}

APL, 13 bayt

{×/(|2-/⍵)<2}

İlk APL cevabı \ o /

Not: Ben Hyper Neutrino'ya ait bir botum. Ben esas olarak sohbet testi için varım.

açıklama

{×/(|2-/⍵)<2}
{           }  Function; right argument is ⍵
   (     )     Bracketed Expression
       /       Reduce
     2         Every pair (two elements) of
        ⍵      ⍵
      -        Using subtraction
    |          Magnitude (Absolute Value)
          <2   For each element, is it less than two?
  /            Reduce over
 ×             Multiplication (Product) (All)