양의 정수 목록이 주어지면 두 이웃보다 크거나 두 이웃보다 작은 요소 ( "범프")가 있는지 판별합니다. 범프를 명확하게하는 것은 하나의 이웃 만 있기 때문에 목록의 첫 번째 또는 마지막 항목이 될 수 없습니다.

프로그램은 범프가없는 목록 또는 범프가있는 목록에 해당하는 두 개의 일관된 값 중 하나를 출력해야합니다. 값이 중요하지 않은 것은 직접 선택할 수 있습니다.

이것은 코드 골프 이므로 바이트 수가 적을수록 답이 바이트로 표시됩니다.

테스트 사례

[] -> False
[1] -> False
[1,2] -> False
[1,2,1] -> True
[1,2,2] -> False
[1,2,3] -> False
[1,2,2,1] -> False
[1,2,2,3] -> False
[1,2,1,2] -> True
[1,3,2] -> True
[3,1,2] -> True
[2,2,2] -> False

젤리 , 5 바이트

IṠIỊẠ

반환 0 범프,이 있다면 1 이 아니라면.

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

작동 원리

IṠIỊẠ  Main link. Argument: A (integer array)

I      Increments; take all forward differences of A.
 Ṡ     Take the signs.
       The signs indicate whether the array is increasing (1), decreasing (-1), or
       constant at the corresponding point. A 1 followed by a -1 indicates a local
       maximum, a -1 followed by a 1 a local minimum.
  I    Increments; take the forward differences again.
       Note that 1 - (-1) = 2 and (-1) - 1 = -2. All other seven combinations of
       signs map to -1, 0, or 1.
   Ị   Insignificant; map each difference d to (-1 ≤ d ≤ 1).
    Ạ  All; return 1 if all differences are insignificant, 0 if not.

자바 스크립트 (ES6), 38 바이트

부울을 반환합니다.

a=>a.some(x=n=>x*(x=a<n|-(a>(a=n)))<0)

테스트 사례

let f =

a=>a.some(x=n=>x*(x=a<n|-(a>(a=n)))<0)

console.log(f([]))              // False
console.log(f([1]))             // False
console.log(f([1,2]))           // False
console.log(f([1,2,1]))         // True
console.log(f([1,2,2]))         // False
console.log(f([1,2,3]))         // False
console.log(f([1,2,2,1]))       // False
console.log(f([1,2,2,3]))       // False
console.log(f([1,2,1,2]))       // True
console.log(f([1,3,2]))         // True
console.log(f([2,0,1]))         // True
console.log(f([2,2,2]))         // False
console.log(f([-4,100000,89]))  // True

어떻게?

우리는 사용 을 이전 값을 저장하기 위해 N을 . 우리는 집합 X를 로 한 경우 은 <N , -1 경우 A> N 또는 0 의 경우 A = N . 그리고 old_x * x <0 인지 테스트합니다 . 이는 ( old_x = 1 및 x = -1 ) 또는 ( old_x = -1 및 x = 1 ) 경우에만 가능합니다 .

x 는 some () 의 익명 콜백 함수로 초기화 되기 때문에 첫 번째 반복 중에 NaN 으로 강제 변환되어 테스트가 잘못됩니다.

하스켈 , 42 바이트

any(<0).f(*).f(-)
f a b=zipWith a b$tail b

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

설명

먼저 f이진 함수와 목록을 가져와 이진 함수를 목록의 모든 인접한 쌍에 적용하는 함수가 있습니다.

그런 다음 주요 기능 f(-)이 입력 목록에 적용됩니다 . 차이 목록을 계산합니다. 그런 다음 f(*)모든 인접한 쌍을 곱하기 위해 목록에 적용 합니다. 마지막으로 어떤 쌍이 0보다 작은 지 묻습니다.

끝 목록의 숫자는 차이 목록의 음수와 양수의 곱인 경우에만 음수 일 수 있습니다. 따라서 음수 항목을 생성 한 다음 true를 반환하려면 원래 목록이 증가에서 감소로 또는 그 반대로 전환되어야합니다. 즉, 충돌이 발생해야합니다.

파이썬 2 , 43 바이트

f=lambda x,y,z,*t:0>(y-x)*(z-y)or f(y,z,*t)

반환 사실 이없는 경우 오류가, 범프가 있다면. ( 기본적으로 허용됨 )

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

이미지 패키지가있는 옥타브 , 34 32 바이트

@StewieGriffin 덕분에 2 바이트가 절약 되었습니다 !

@(x)0||prod(im2col(diff(x),2))<0

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

설명

연속적인 차이를 계산하고 길이가 2 인 슬라이딩 블록으로 정렬하고 각 블록의 곱을 구한 다음 해당 제품이 음수인지 테스트합니다.

R, 48 바이트

function(x)any(apply(embed(diff(x),2),1,prod)<0)

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

c (1,4,1,4)를 예로 사용하여 단계별로 작동하는 방법 :

> x=c(1,4,1,4)
> diff(x)
[1]  3 -3  3
> embed(diff(x),2)
     [,1] [,2]
[1,]   -3    3
[2,]    3   -3
> apply(embed(diff(x),2),1,prod)
[1] -9 -9
> any(apply(embed(diff(x),2),1,prod)<0)
[1] TRUE

보너스로, 다음은 package를 사용하는 비슷한 길이와 개념의 솔루션입니다 zoo.

function(x)any(zoo::rollapply(diff(x),2,prod)<0)

하스켈 , 33 바이트

f(p:r@(c:n:_))=(c-p)*(c-n)>0||f r

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

True 충돌이 있으면 그렇지 않으면 오류가 발생합니다.

펄 6 , 39 바이트

{so~(.[1..*]Zcmp$_)~~/'re L'|'s M'/}

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

$_이 익명 함수에 대한 목록 인수입니다. .[1..*]동일한 목록이지만 첫 번째 요소가 삭제되었습니다. 연산자 Zcmp와 함께 두 목록을 압축하여 값 cmp목록을 생성 Order합니다. 예를 들어, 입력 목록의 1, 2, 2, 2, 1경우 list가 More, Same, Same, Less됩니다.

이제 우리는 단지 그 목록은 인접한 두 요소가 포함되어 있는지 여부를 알 필요가 More, Less또는 Less, More. 내가 사용한 트릭은을 사용하여 목록을 공백으로 구분 된 문자열로 변환 ~한 다음 하위 문자열 re L또는을 포함하는지 테스트하는 것 s M입니다. (첫 번째 는 "e"로 끝나기 e L때문에 할 수 없습니다 Same.)

스마트 일치 연산자는 Match개체가 일치하거나 일치 Nil하지 않은 경우 개체를 반환하므로 개체를 so부울 값으로 변환합니다.

Wolfram Language (Mathematica) , 40 바이트

MatchQ[{___,x_,y_,z_,___}/;x<y>z||x>y<z]

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

루비 , 55 46 바이트

->a{a.each_cons(3).any?{|x,y,z|(y-x)*(y-z)>0}}

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

배열을 수락하고 부울을 반환하는 람다.

-9 바이트 : 교체 (x<y&&y>z)||(x>y&&y<z)로 (y-x)*(y-z)>0(덕분에 GolfWolf )

->a{
  a.each_cons(3)              # Take each consecutive triplet
    .any?{ |x,y,z|            # Destructure to x, y, z
      (y-x)*(y-z) > 0         # Check if y is a bump
    }
}

PostgreSQL 173 바이트

SELECT DISTINCT ON(a)a,x>j and x>k OR x<least(j,k)FROM(SELECT a,x,lag(x,1,x)OVER(w)j,lead(x,1,x)OVER(w)k FROM d WINDOW w AS(PARTITION BY rn ORDER BY xn))d ORDER BY 1,2 DESC;
     a     | c 
-----------+---
 {1}       | f
 {1,2}     | f
 {1,2,1}   | t
 {1,2,1,2} | t
 {1,2,2}   | f
 {1,2,2,1} | f
 {1,2,2,3} | f
 {1,2,3}   | f
 {1,3,2}   | t
 {2,2,2}   | f
 {3,1,2}   | t
(11 rows)

자바 8 108 104 101 86 84 79 72 바이트

a->{int i=a.length,p=0;for(;i-->1;)i|=p*(p=a[i]-a[i-1])>>-1;return-i>1;}

@ OlivierGrégoire 덕분에 -2 바이트 . @Nevay
덕분에 -13 바이트 .

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

R , 58 56 바이트

function(x)any(abs(diff(sign(diff(c(NA,x)))))>1,na.rm=T)

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

주세페 덕분에 2 바이트 절약

J , 16 15 바이트

FrownyFrog 덕분에 -1 바이트

1 e.0>2*/\2-/\]

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

원본 : 16 바이트

0>[:<./2*/\2-/\]

2-/\] -인접한 각 항목의 차이점

2*/\ -각 인접 품목의 제품

[:<./ -최소

0> -부정적이야?

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

Japt , 11 바이트

@ETHproductions 덕분에 -5 바이트

ä- mÌäa d>1

온라인으로 사용해보십시오! | 테스트 사례

이것은 Dennis의 알고리즘을 사용 합니다.

Japt , 9 바이트

ä- ä* d<0

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

다른 여러 답변에서 사용 된 방식으로 Oliver의 답변을 매쉬업했습니다.

첨부 , 39 바이트

Any&:&{_*~?Sum[__]}@Slices&2@Sign@Delta

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

이것이 어떻게 나타 났는지에 매우 만족합니다.

설명

이것은 네 가지 기능으로 구성되어 있습니다.

Delta
Sign
Slices&2
Any&:&{_*~?Sum[__]}

Delta요소 간의 차이를 얻습니다. =

그런 다음 Sign각 차이에 적용되어 1s, 0s 및 -1s 의 배열을 제공합니다 . =

그런 다음 Slices&2배열에서 길이 2의 모든 슬라이스를 제공하여 모든 쌍의 차이를 제공합니다.

마지막으로 Any&:&{_*~?Sum[__]}입력과 x같습니다.

Any[&{_*~?Sum[__]}, x]
Any[[el] -> { el[0] and not (el[0] + el[1] = 0) }, x]

합계는 0이지만 0이 아닌 요소를 검색합니다. 그러한 요소 쌍이 존재하면 충돌이 발생합니다.

MATL , 8 바이트

dZSd|1>a

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

껍질 , 7 바이트

V<0Ẋ*Ẋ-

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

설명

V<0Ẋ*Ẋ-  Implicit input, say [2,5,5,1,4,5,3]
     Ẋ-  Consecutive differences: [3,0,-4,3,1,-2]
   Ẋ*    Consecutive products: [0,0,-12,3,-2]
V<0      Is any of them negative? Return 1-based index: 3

옥타브 , 33 바이트

@(x)0||abs(diff(sign(diff(x))))>1

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

설명:

@(x)                           % Anonymous function taking x as input
                  diff(x)       % Takes the difference between consecutive elements
             sign(diff(x))      % The sign of the differences
        diff(sign(diff(x)))     % The difference between the signs
    abs(diff(sign(diff(x)))>1   % Check if the absolute value is 2
@(x)abs(diff(sign(diff(x)))>1   % Output as matrices that are treated truthy or falsy

Brachylog , 10 바이트

s₃.¬≤₁∧¬≥₁

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

true.범프가 있으면 성공 ( )하고 범프 false.가 없으면 실패 ( )합니다.

설명

이것은 이미 꽤 읽을 수 있습니다 :

s₃.           There is a substring of the input…
  .¬≤₁        …which is not non-decreasing…
      ∧       …and…
       ¬≥₁    …which is not non-increasing

05AB1E , 7 바이트

¥ü‚P0‹Z

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

설명

¥         # calculate delta's
 ü‚       # pair each element with the next element
   P      # product of each pair
    0‹    # check each if less than 0
      Z   # max

Brachylog , 10 바이트

s₃s₂ᶠ-ᵐ×<0

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

@Fatalize의 기존 10 바이트 답변만큼 깔끔하고 우아하지는 않지만 작동합니다!

s₃   % There exists a substring of three elements [I,J,K] in the array such that

s₂ᶠ  % When it's split into pairs [[I,J],[J,K]]

-ᵐ   % And each difference is taken [I-J, J-K]

×    % And those differences are multiplied (I-J)*(J-K)
     % (At a bump, one of those will be negative and the other positive. 
     % At other places, both differences will be positive, or both negative, 
     %  or one of them 0 - ultimately resulting in a non-negative product.)

<0   % The product is negative

껍질 , 9 바이트

▼mεẊ-Ẋo±-

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

Dennis의 알고리즘을 사용합니다.

Perl 5 , 54 + 2 ( -pa) = 56 바이트

map$\|=$F[$_-1]!=(sort{$a-$b}@F[$_-2..$_])[1],2..$#F}{

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

파이썬 2 , 60 바이트

lambda l:any(p>c<n or p<c>n for p,c,n in zip(l,l[1:],l[2:]))

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

거의 같은 것이지만, 더 짧을 것이라고 생각했습니다 ...

파이썬 2 , 63 바이트

f=lambda l:l[3:]and(l[0]>l[1]<l[2]or l[0]<l[1]>l[2]or f(l[1:]))

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

Pyt , 11 7 바이트

₋ʁ*0<Ʃ±

범프가 있으면 1을 출력하고, 그렇지 않으면 0을 출력합니다

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

포트 밀 마법사는 하스켈 대답

이전 방식 (11 바이트) :

₋±₋Å1≤ĐŁ↔Ʃ=

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

범프가 있으면 False를, 그렇지 않으면 True를 반환

데니스 포트 젤리 답변

Wolfram Language (Mathematica) , 37 36 바이트

FreeQ[(d=Differences)@Sign@d@#,-2|2]&

테스트 사례 답변의 반대 (False 및 True가 반대로)를 제공합니다. a !를 앞에 붙여서 일반 양식으로 전환하십시오.

또는

Abs@(d=Differences)@Sign@d@#~FreeQ~2&

또한 출력을 반전되므로 교체 FreeQ와 MatchQ정상 폼.

설명 : 순서의 차이점을 표시하십시오. 결과 시퀀스에 {1, -1} 또는 {-1,1}이 포함 된 경우 충돌이 있습니다. 두 경우 모두 {1, -1} 또는 {-1,1}의 차이의 절대 값은 2입니다.

절대 값을 사용하는 대신 최종 목록을 제곱하여 다른 바이트를 제거하십시오.

FreeQ[(d=Differences)@Sign@d@#^2,4]&

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

펄, 35 바이트

포함 +3을 위해-p

bump.pl:

#!/usr/bin/perl -p
s%\S+ %$a*1*($a=$&-$')%eg;$_=/-/

다음으로 실행 :

bump.pl <<< "3 1 2"

줄리아 0.6 , 57 56 바이트

l->any(p>c<n||p<c>n for(p,c,n)=zip(l,l[2:end],l[3:end]))

기본적으로 완전히 인간의 파이썬 답변입니다. 사용자에서 -1 바이트

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

줄리아 0.6 , 39 바이트

f(x,y,z,a...)=x>y<z||x<y>z||f(y,z,a...)

Lispy 재귀 스타일, 일명 Dennis의 Python 답변. true범프가 존재하면 반환 하고, 그렇지 않으면 오류가 발생합니다. 호출 할 때 표시해야하므로 42 바이트 여야합니다. 예를 a=[1,2,1]들어으로 전화하십시오 f(a...). f(a)=f(a...)그 필요성을 제거하지만 더 길다. 재귀를 더 잘해야하며 오류가 발생하는 코드를 작성하는 것을 정말로 좋아하지 않습니다.

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