正の整数のリストが与えられると、2つの近傍よりも大きいか、2つの近傍よりも小さい（「バンプ」）要素があるかどうかを判別します。明確にするために、バンプは隣人が1人しかいないため、リストの最初または最後の項目にはなりません。

プログラムは、バンプのないリストまたはバンプのあるリストにそれぞれ対応する2つの一貫した値のいずれかを出力する必要があります。値が何であるかは重要ではありません。自分で選択することができます。

これはコードゴルフであるため、回答はバイト単位で記録され、バイト数は少ない方が良いでしょう。

テストケース

[] -> 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.

JavaScript（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

どうやって？

aを使用して、nの以前の値を保存します。我々セットXの1であれば、<N 、-1なら> Nまたは0なら= N。そして、old_x * x <0かどうかをテストします。これは、（old_x = 1 and x = -1）または（old_x = -1 and x = 1）の場合にのみ可能です。

xはsome（）の匿名コールバック関数に初期化されるため、最初の反復中にNaNに強制され、テストが偽になります。

Haskell、42バイト

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

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

説明

まずf、バイナリ関数とリストを受け取り、リスト内の隣接するすべてのペアにバイナリ関数を適用する関数があります。

次に、メイン関数がf(-)入力リストに適用されます。これにより、差分リストが計算されます。次にf(*)、リストに適用して、隣接するすべてのペアを乗算します。最後に、ペアがゼロより小さいかどうかを尋ねます。

終了リストの数値は、差分リストの負の数と正の数の積である場合にのみ負になります。したがって、負のエントリを生成する（およびtrueを返す）には、元のリストを増加から減少、またはその逆に切り替える必要があります。つまり、バンプが必要です。

Python 2、43バイト

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

バンプがある場合はTrueを返し、ない場合はエラーを返します。（デフォルトで許可されています）

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

画像パッケージ付きオクターブ、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

おまけとして、パッケージを使用した同様の長さとコンセプトのソリューションがありますzoo：

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

Haskell、33バイト

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

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

True バンプがある場合はエラー、エラーがない場合はエラー。

Perl 6、39バイト

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

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

$_この匿名関数のリスト引数です。 .[1..*]は同じリストですが、最初の要素が削除されています。 Zcmp2つのリストをcmp演算子と一緒に圧縮し、Order値のリストを作成します。たとえば、入力リストの場合、1, 2, 2, 2, 1これはlistになりますMore, Same, Same, Less。

今、私たちはそのリストが隣接する二つの要素が含まれているかどうかを知る必要がありますMore, LessかLess, More。私が使用したトリックは、リストをスペースで区切られた文字列に変換し、~サブストリングre Lまたはのいずれかを含むかどうかをテストすることs Mです。（最初の1つは、「e」で終わるe Lという理由だけではありませんSame。）

スマートマッチ演算子は、Matchオブジェクト（一致が成功したNil場合）または（成功しなかった場合）のいずれかを返すため、それsoが何であれブール値に変換します。

Wolfram言語（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)

Java 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

オンラインでお試しください！| テストケース

これはデニスのアルゴリズムを使用します

Japt、9バイト

ä- ä* d<0

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

他のいくつかの回答で使用されているアプローチとオリバーの回答のマッシュアップ。

アタッシュ、39バイト

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

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

これがどのようになったかにかなり満足しています。

説明

これは、4つの機能の組み合わせです。

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]

これにより、合計がゼロになるがゼロではない要素が検索されます。そのような要素のペアが存在する場合、バンプがあります。

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±-

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

デニスのアルゴリズムを使用します。

Perl 5、54 + 2（-pa）= 56バイト

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

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

Python 2、60バイト

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

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

ほぼ同じことですが、もっと短くなると思いました...

Python 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を出力します

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

Port of Wheat WizardのHaskellの回答

古い方法（11バイト）：

₋±₋Å1≤ĐŁ↔Ʃ=

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

バンプがある場合はFalse、そうでない場合はTrueを返します。

デニス港のゼリーの答え

Wolfram言語（Mathematica）、37 36バイト

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

テストケースの答えの反対を返します（FalseとTrueが逆転）。を先頭に追加し!て、通常の形式に切り替えます。

または

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]&

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

Perl、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]))

基本的には完全に人間のPythonの答えです。user71546から-1バイト

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

ジュリア0.6、39バイト

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

Lispy recursion style、別名Dennisのpython回答。trueバンプが存在する場合に戻り、そうでない場合はエラーをスローします。呼び出し時にスプラッシュする必要があるので、これは多分42バイトでなければなりません。たとえば、a=[1,2,1]として呼び出しますf(a...)。f(a)=f(a...)その必要性はなくなりますが、より長くなります。再帰を改善する必要がありますが、エラーをスローするコードを書くのはあまり好きではありません。

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