Một mảng không đáng kể là một mảng các số nguyên dương, nơi mà sự khác biệt tuyệt đối giữa các yếu tố liên tiếp đều nhỏ hơn hoặc bằng 1 .

Ví dụ, mảng sau không đáng kể:

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

Bởi vì sự khác biệt (tuyệt đối) tương ứng là:

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

Tất cả đều nhỏ hơn hoặc bằng 1 .

Nhiệm vụ của bạn là xác định xem một mảng số nguyên đã cho có đáng kể hay không.

• Bạn có thể giả định rằng mảng luôn chứa ít nhất hai phần tử.
• Quy tắc đầu vào và đầu ra tiêu chuẩn được áp dụng. Bạn có thể lấy đầu vào (và đầu ra) ở bất kỳ định dạng hợp lý nào.
• Lỗ hổng mặc định bị cấm.
• Các giá trị trung thực / giả mạo phải khác biệt và nhất quán.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.

Các trường hợp thử nghiệm

Đầu vào -> Đầu ra

[1, 2, 3, 4, 3, 4, 5, 5, 5, 4] -> đúng
[1, 2, 3, 4, 5, 6, 7, 8, 9, 8] -> đúng
[3, 3, 3, 3, 3, 3, 3] -> đúng
[3, 4, 4, 4, 3, 3, 3, 4, 4, 4] -> đúng
[1, 2, 3, 4] -> đúng 
[5, 4, 3, 2] -> đúng 
[1, 3, 5, 7, 9, 7, 5, 3, 1] -> sai
[1, 1, 1, 2, 3, 4, 5, 6, 19] -> sai
[3, 4, 5, 6, 7, 8, 7, 5] -> sai
[1, 2, 4, 10, 18, 10, 100] -> sai
[10, 20, 30, 30, 30] -> sai

Tôi đã sử dụng các giá trị truevà false.

Thạch , 3 byte

IỊẠ

Hãy thử trực tuyến!

Làm sao?

Chỉ là thử thách hoàn hảo cho Jelly.

Chương trình đầy đủ.

Tôi tăng; Lấy sự khác biệt giữa các yếu tố liên tiếp.
 Ị không đáng kể; trở lại abs (số) 1.
  Ạ Tất cả; trả về 1 nếu tất cả các phần tử là trung thực, 0 nếu không.

JavaScript (ES7), 33 29 byte

Đã lưu 4 byte nhờ @JohanKarlsson

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

Làm sao?

Khi bị ép buộc Number, các mảng của ít nhất hai yếu tố được ước tính NaN. Bằng cách sử dụng lại đầu vào a làm biến giữ giá trị trước đó, lần lặp đầu tiên của một số () luôn dẫn đến ([v0, v1, ...] - a [0]) ** 2 = NaN , bất kể giá trị của một [0] . Vì vậy, bài kiểm tra đầu tiên luôn sai lệch và các so sánh thực tế bắt đầu ở lần lặp thứ 2, giống như ý của chúng.

Các trường hợp thử nghiệm

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 byte

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

Hãy thử trực tuyến!

Toán học, 24 byte

Max@Abs@Differences@#<2&

Python 2 , 35 byte

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

Tồn tại với mã trạng thái 1 cho các mảng không đáng kể, với mã trạng thái 0 nếu không.

Hãy thử trực tuyến!

Husk , 4 byte

ΛεẊ-

Hãy thử trực tuyến!

Giải trình:

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

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

Hàm ẩn danh nhập vào một vectơ số và tham số 1nếu không đáng kể hoặc theo 0cách khác.

Hãy thử trực tuyến!

Haskell , 34 33 byte

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

Hãy thử trực tuyến! -1 byte nhờ @ user1472751

Giải pháp không có điểm là một hai lần nữa chỉ một byte ( nhờ -1 byte từ @Dennis ) ngắn hơn phương pháp đệ quy:

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

Hãy thử trực tuyến!

Bình thường , 6 byte

._MI.+

Xác nhận tất cả các trường hợp thử nghiệm.

Bình thường , 8 byte

.A<R2aVt

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

-16 byte nhờ Mr. Xcoder
-2 byte
-6 byte nhờ Mr. Xcoder

Japt , 6 byte

äa e<2

Hãy thử trực tuyến!

Giải trình

ä        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 byte

-1 byte nhờ Jeppe Stig Nielsen

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

Số lượng byte cũng bao gồm:

using System.Linq;

Hãy thử trực tuyến!

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Điều này nên được đọc khá. Điều duy nhất ít rõ ràng hơn ở đây là toán tử zip Zsẽ ngừng nén khi danh sách ngắn hơn đã hết (chúng tôi xóa phần tử đầu tiên của danh sách ở bên phải) và chỉ mục trống .[], được gọi là Zen lát, cung cấp toàn bộ danh sách. .skiptrả về danh sách mà không có phần tử đầu tiên.

R , 30 26 byte

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

Hãy thử trực tuyến!

05AB1E , 5 byte

¥Ä2‹P

Hãy thử trực tuyến!

Giải trình

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

Ohm v2 , 4 byte

Δ2<Å

Hãy thử trực tuyến!

Làm sao?

Δ2<Å   ~ Full program.

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

PowerShell , 62 byte

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

Hãy thử trực tuyến!

PowerShell không có .maphoặc .somehoặc tương tự lệnh, vì vậy ở đây chúng tôi đang từng kiểm tra từng đồng bằng.

Chúng tôi lấy đầu vào $avà đặt $lbằng với phần tử đầu tiên. Sau đó, chúng tôi lặp qua $avà lấy ra từng yếu tố trong đó |?{...}sự khác biệt $_-$llà -inphạm vi 1,0,-1. Sau đó chúng ta đặt $lbằng với phần tử hiện tại. Vì vậy, bây giờ chúng ta có một tập hợp các phần tử trong đó đồng bằng giữa hàng xóm trước của chúng là 1. Chúng ta lấy phần .countđó và kiểm tra xem nó có -eqphải .countlà toàn bộ mảng không. Nếu có, thì mỗi delta là 1 hoặc ít hơn, vì vậy đó là một mảng không đáng kể. Kết quả Boolean đó được để lại trên đường ống và đầu ra là ẩn.

Python 3 , 45 byte

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

Hãy thử trực tuyến! hoặc Thử bộ kiểm tra.

Cảm ơn Jonathan Frech cho -2 byte.

Java (OpenJDK 8) , 78 byte

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

Hãy thử trực tuyến!

MATL ,6 5 byte

d|2<A

-1 byte nhờ Giuseppe

Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm

bất kỳ , 9 byte

I€A€2<»/&

Hãy thử trực tuyến!

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

Đây chủ yếu là một cổng của giải pháp 05AB1E ngoại trừ khủng khiếp vì anyfix không có chế độ tự động hóa và những thứ hay ho khác

C, 61 56 byte

Cảm ơn @scottinet vì đã lưu năm byte!

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

Hãy thử trực tuyến!

C (gcc), 47 byte

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

Hãy thử trực tuyến!

Clojure, 35 byte

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

Làm thế nào gọn gàng?

TI-Basic, 6 7 byte

prod(2>abs(ΔList(Ans

hoặc, 5 byte nếu lỗi được tính là giá trị trả về hợp lệ (trả về ERR:ARGUMENTnếu không đáng kể, khác ERR:DOMAIN)

augment(sin⁻¹(ΔList(Ans

JavaScript (ES6), 37 36 byte

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

Chỉnh sửa: Đã lưu 1 byte bằng cách ăn cắp thủ thuật của @ Arnauld.

Bình thường, 7 byte

._I#I.+

Phòng thử nghiệm

Trả về đúng / sai.

Giải trình:

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

Toán học, 34 byte

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

Giải trình

                                 & (* 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 byte

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

Hãy thử trực tuyến!

• 5 byte nhờ @Nevay!

Swift 4, 52 byte

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

Bộ kiểm tra:

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 byte

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

Câu trả lời APL đầu tiên \ o /

Lưu ý: Tôi là một bot thuộc sở hữu của Hyper Neutrino. Tôi tồn tại chủ yếu để thử nghiệm trò chuyện.

Giải trình

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