無意味配列は連続する要素間の絶対差がより全て小さいか等しい正の整数の配列である1。

たとえば、次の配列は重要ではありません。

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

対応する（絶対）違いは次のとおりです。

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

これらはすべて1以下です。

あなたの仕事は、与えられた整数の配列が重要でないかどうかを判断することです。

• 配列には常に少なくとも2つの要素が含まれると想定できます。
• 標準の入力および出力ルールが適用されます。任意の妥当な形式で入力（および出力）を取得できます。
• デフォルトの抜け穴は禁止されています。
• 真実/偽の値は明確で一貫している必要があります。
• これはcode-golfであるため、バイト単位の最短回答が優先されます。

テストケース

入力->出力

[1、2、3、4、3、4、5、5、5、5、4]-> true
[1、2、3、4、5、6、7、8、9、8]-> true
[3、3、3、3、3、3、3、3]-> true
[3、4、4、4、3、3、3、3、4、4、4]-> true
[1、2、3、4]-> true 
[5、4、3、2]-> true 
[1、3、5、7、9、7、5、3、1]-> false
[1、1、1、2、3、4、5、6、19]-> false
[3、4、5、6、7、8、7、5]-> false
[1、2、4、10、18、10、100]-> false
[10、20、30、30、30]-> false

値trueとを使用しましたfalse。

ゼリー、3バイト

IỊẠ

オンラインでお試しください！

どうやって？

ゼリーにとってまさに完璧な挑戦です。

IỊẠ完全なプログラム。

増分; 連続する要素間の差を取得します。
 重要でない; abs（number）≤1を返します。
  Ạすべて; すべての要素が真実であれば1を返し、そうでなければ0を返します。

JavaScript（ES7）、33 29バイト

@JohanKarlssonのおかげで4バイト節約

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

どうやって？

に強制されるとNumber、少なくとも2つの要素の配列がに評価されNaNます。入力aを以前の値を保持する変数として再利用することにより、some（）の最初の反復は常に（[v0、v1、...]-a [0]）** 2 = NaNになります。a [0]の値。したがって、最初のテストは常に虚偽であり、実際の比較は意図したとおりに2回目の反復から開始されます。

テストケース

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バイト

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

オンラインでお試しください！

Mathematica、24バイト

Max@Abs@Differences@#<2&

Python 2、35バイト

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

重要でない配列の場合はステータスコード1で存在し、それ以外の場合はステータスコード0で存在します。

オンラインでお試しください！

殻、4バイト

ΛεẊ-

オンラインでお試しください！

説明：

ΛεẊ- 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

オクターブ、21バイト

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

数値ベクトルを入力し、1重要でない場合は出力する無名関数0。

オンラインでお試しください！

Haskell、34 33バイト

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

オンラインでお試しください！ @ user1472751のおかげで-1バイト

ポイントを含まない溶液は、1 2、再び1バイトのみ（-1からバイト感謝@Dennis再帰的なアプローチよりも短いです）：

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

オンラインでお試しください！

Pyth、6バイト

._MI.+

すべてのテストケースを確認します。

Pyth、8バイト

.A<R2aVt

オンラインでお試しください！

説明

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

プロトン、41バイト

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

オンラインでお試しください！

Mr. Xcoderのおかげで-16バイト
-2バイト
Mr. Xcoderのおかげで-6バイト

Japt、6バイト

äa e<2

オンラインでお試しください！

説明

ä        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バイト

Jeppe Stig Nielsenのおかげで-1バイト

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

バイト数には以下も含まれます。

using System.Linq;

オンラインでお試しください！

説明：

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バイト

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

オンラインでお試しください！

これはかなり読みやすいはずです。ここでそれほど明白ではない唯一のことはZ、短いリストがなくなると（zipオペレーターはリストの最初の要素を削除して）zip 圧縮を停止し、空の添え字.[]（Zenスライスと呼ばれる）がリスト全体を提供することです。.skip最初の要素のないリストを返します。

R、30 26バイト

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

オンラインでお試しください！

05AB1E、5バイト

¥Ä2‹P

オンラインでお試しください！

説明

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

Ohm v2、4バイト

Δ2<Å

オンラインでお試しください！

どうやって？

Δ2<Å   ~ Full program.

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

PowerShell、62バイト

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

オンラインでお試しください！

PowerShellはありません.mapか.someので、ここで私たちは個々のデルタをチェックしている、または類似のコマンドを。

入力を取得し、最初の要素に等しく$a設定し$lます。次に、ループ処理を繰り返し、差が範囲$aで|?{...}ある各要素を取り出します。次に、現在の要素に等しく設定します。これで、前の隣接要素間のデルタが1である要素のコレクションができました。それを使用して、全体として配列のual かどうかを確認します。そうである場合、すべてのデルタは1以下であるため、意味のない配列です。そのブール結果はパイプラインに残り、出力は暗黙的です。$_-$l-in1,0,-1$l.count-eq.count

Python 3、45バイト

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

オンラインでお試しください！またはテストスイートを試してください。

-2バイトのJonathan Frechに感謝します。

Java（OpenJDK 8）、78バイト

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

オンラインでお試しください！

MATL、6 5バイト

d|2<A

ジュゼッペのおかげで-1バイト

オンラインでお試しください！またはすべてのテストケースを検証する

anyfix、9バイト

I€A€2<»/&

オンラインでお試しください！

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

anyfixには自動ベクトル化やその他のクールな機能がないため、ひどい場合を除き、これは主に05AB1Eソリューションの移植版です。

C、61 56バイト

5バイトを節約してくれた@scottinetに感謝します！

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

オンラインでお試しください！

C（gcc）、47バイト

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

オンラインでお試しください！

Clojure、35バイト

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

それはどれほどきれいですか？

TI-Basic、6 7バイト

prod(2>abs(ΔList(Ans

または、エラーが有効な戻り値としてカウントされる場合は5バイト（ERR:ARGUMENT重要でない場合は戻り、そうでない場合はERR:DOMAIN）

augment(sin⁻¹(ΔList(Ans

JavaScript（ES6）、37 36バイト

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

編集：@Arnauldのトリックを盗んで1バイトを保存しました。

Pyth、7バイト

._I#I.+

テストスイート

true / falseを返します。

説明：

     .+ 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バイト

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

説明

                                 & (* 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バイト

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

オンラインでお試しください！

• @Nevayのおかげで5バイト！

Swift 4、52バイト

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

テストスイート：

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バイト

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

最初のAPL回答\ o /

注：私はHyper Neutrinoが所有するボットです。私は主にチャットのテストのために存在しています。

説明

{×/(|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)