一个微不足道阵列是正整数，其中连续元素之间的绝对差均小于或等于的阵列1。

例如，以下数组无关紧要：

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

因为相应的（绝对）差异是：

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

全部小于或等于1。

您的任务是确定给定的整数数组是否不重要。

• 您可以假定数组始终包含至少两个元素。
• 标准输入和输出规则适用。您可以采用任何合理的格式输入（和输出）。
• 默认漏洞是禁止的。
• 真实/虚假的值必须是不同且一致的。
• 这是代码高尔夫球，因此最短答案以字节为单位。

测试用例

输入->输出

[1、2、3、4、3、4、5、5、5、4]-> true
[1、2、3、4、5、6、7、8、9、8]-> true
[3，3，3，3，3，3，3]-> true
[3，4，4，4，3，3，3，4，4，4]-> true
[1、2、3、4]->是 
[5、4、3、2]->是 
[1、3、5、7、9、7、5、3、1]->否
[1、1、1、2、3、4、5、6、19]->否
[3，4，5，6，7，8，7，5]->否
[1、2、4、10、18、10、100]->否
[10，20，30，30，30]->错误

我使用了值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，将至少两个元素的数组评估为NaN。通过将输入a重新用作保存先前值的变量，some（）的第一次迭代始终导致（[v0，v1，...]-a [0]）** 2 = NaN，无论a [0]的值。因此，第一次测试总是虚假的，实际的比较从第二次迭代开始，正如它们的意图一样。

测试用例

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)

在线尝试！ -1个字节感谢@ user1472751

无点解决方案比递归方法要短一个一 两个又一个字节（由于@Dennis的 -1字节）：

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)

在线尝试！

-16字节归Xcoder先生
-2字节
-6字节归Xcoder先生

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字节

-1字节感谢Jeppe Stig Nielsen

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运算符将停止压缩（我们在右侧删除了列表的第一个元素），并且空下标.[]（称为Zen slice）给出了整个列表。.skip返回不包含第一个元素的列表。

R，30 26字节

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

在线尝试！

05AB1E，5个字节

¥Ä2‹P

在线尝试！

说明

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

欧姆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并取出其中|?{...}差$_-$l是-in范围的每个元素1,0,-1。然后，我们将其设置为$l等于当前元素。因此，现在我们有了一个元素集合，它们的前一个邻居之间的增量为1。我们将其取.count为，然后检查它是否与整个数组的-equal .count相同。如果是，则每个增量都等于或小于1，因此它是一个无关紧要的数组。该布尔结果留在管道上，并且输出是隐式的。

Python 3，45字节

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

在线尝试！或尝试测试套件。

感谢Jonathan Frech提供了-2个字节。

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个字节，感谢Giuseppe

在线尝试！或验证所有测试用例

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

除可怕之外，这主要是05AB1E解决方案的一个端口，因为anyfix没有自动矢量化和其他有趣的功能

C，61 56字节

感谢@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;}

在线尝试！

• 5字节感谢@Nevay！

斯威夫特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)