무의미한 배열 연속 소자 사이의 차이 절대 값보다 모두 작거나 같은 양의 정수들의 어레이이다 (1) .

예를 들어 다음 배열은 중요하지 않습니다.

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

해당 (절대) 차이점은 다음과 같습니다.

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

모두 1 보다 작거나 같습니다 .

당신의 임무는 주어진 정수 배열이 중요하지 않은지를 결정하는 것입니다.

• 배열에 항상 두 개 이상의 요소가 포함되어 있다고 가정 할 수 있습니다.
• 표준 입력 및 출력 규칙이 적용됩니다. 합리적인 형식으로 입력 및 출력 할 수 있습니다.
• 기본 허점 은 금지되어 있습니다.
• 진실 / 거짓 값은 명확하고 일관되어야합니다.
• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

테스트 사례

입력-> 출력

[1, 2, 3, 4, 3, 4, 5, 5, 5, 4]-> 참
[1, 2, 3, 4, 5, 6, 7, 8, 9, 8]-> 참
[3, 3, 3, 3, 3, 3, 3]-> 참
[3, 4, 4, 4, 3, 3, 3, 4, 4, 4]-> 참
[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ỊẠ 풀 프로그램.

I 증분; 연속 요소의 차이를 얻으십시오.
 Ị 중요하지 않은; abs (숫자) ≤ 1을 반환합니다.
  Ạ 모두; 모든 요소가 진실이면 1을, 그렇지 않으면 0을 반환합니다.

자바 스크립트 (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

파이썬 3 , 40 바이트

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

온라인으로 사용해보십시오!

Mathematica, 24 바이트

Max@Abs@Differences@#<2&

파이썬 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.

온라인으로 사용해보십시오!

하스켈 , 34 33 바이트

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

온라인으로 사용해보십시오! @ user1472751 덕분에 -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)

온라인으로 사용해보십시오!

Xcoder 덕분에 -16 바이트 Mr. Xcoder 덕분에
-2 바이트
-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 코어) , 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!)

펄 6 , 25 바이트

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

온라인으로 사용해보십시오!

이것은 꽤 읽을 수 있어야합니다. 여기서 덜 분명한 것은 zip 연산자 Z가 더 짧은 목록이 소진되면 오른쪽에서 목록의 첫 번째 요소를 제거하고 압축을 중지하고 .[]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

옴 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이고 그래서 지금 우리가 요소의 컬렉션을 가지고 우리는 가지고 그와 그것의 여부를 확인 연간받는 전체 배열의 형태가됩니다. 그렇다면 모든 델타는 1 이하이므로 중요하지 않은 배열입니다. 해당 부울 결과는 파이프 라인에 남아 있으며 출력은 암시 적입니다.|?{...}$_-$l-in1,0,-1$l.count-eq.count

파이썬 3 , 45 바이트

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

온라인으로 사용해보십시오! 또는 테스트 스위트를 사용해보십시오.

-2 바이트의 Jonathan Frech 에게 감사 합니다.

자바 (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

모든 수정에는 자동 벡터화 및 기타 멋진 기능이 없으므로 끔찍한 것을 제외하고는 대부분 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);}

온라인으로 사용해보십시오!

클로저, 35 바이트

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

얼마나 깔끔한가요?

TI 기본, 6 7 바이트

prod(2>abs(ΔList(Ans

또는, 에러가 유효한 반환 값으로 간주되는 경우 5 바이트 ( ERR:ARGUMENT중요하지 않은 경우 반환 ERR:DOMAIN)

augment(sin⁻¹(ΔList(Ans

자바 스크립트 (ES6), 37 36 바이트

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

편집 : @ Arnauld의 트릭을 훔쳐서 1 바이트를 절약했습니다.

Pyth, 7 바이트

._I#I.+

테스트 스위트

참 / 거짓을 반환합니다.

설명:

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

자바 (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 바이트!

스위프트 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)