Diberikan daftar bilangan bulat positif menentukan apakah ada elemen yang lebih besar dari dua tetangganya atau kurang dari dua tetangganya ("benjolan"). Untuk lebih jelasnya, benjolan tidak akan pernah menjadi item pertama atau terakhir dari daftar karena mereka hanya memiliki satu tetangga.

Program Anda harus menampilkan salah satu dari dua nilai yang konsisten, masing-masing sesuai dengan daftar tanpa benjolan atau daftar dengan benjolan. Nilai-nilainya tidak penting, Anda dapat memilihnya sendiri.

Ini adalah kode-golf sehingga jawaban akan dicetak dalam byte dengan lebih sedikit byte yang lebih baik.

Uji kasus

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

Jelly , 5 byte

IṠIỊẠ

Mengembalikan 0 jika ada masalah, 1 jika tidak.

Cobalah online!

Bagaimana itu bekerja

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 byte

Mengembalikan boolean.

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

Uji kasus

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

Bagaimana?

Kami menggunakan a untuk menyimpan nilai n sebelumnya . Kami menetapkan x ke 1 jika a <n , -1 jika a> n atau 0 jika a = n . Dan kami menguji apakah old_x * x <0 , yang hanya mungkin jika ( old_x = 1 dan x = -1 ) atau ( old_x = -1 dan x = 1 ).

Karena x diinisialisasi ke fungsi panggilan balik anonim dari beberapa () , maka dipaksakan untuk NaN selama iterasi pertama, yang membuat tes salah.

Haskell , 42 byte

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

Cobalah online!

Penjelasan

Pertama kita memiliki fungsi fyang mengambil fungsi biner dan daftar dan menerapkan fungsi biner untuk setiap pasangan yang berdekatan dalam daftar.

Kemudian fungsi utama kami berlaku f(-)untuk daftar input. Ini menghitung daftar perbedaan. Kami kemudian menerapkan f(*)ke daftar untuk mengalikan setiap pasangan yang berdekatan. Terakhir kami bertanya apakah ada pasangan yang kurang dari nol.

Angka dalam daftar akhir hanya bisa negatif jika itu adalah produk dari angka negatif dan positif dari daftar perbedaan. Dengan demikian untuk menghasilkan entri negatif (dan kemudian mengembalikan true) daftar asli harus beralih dari meningkat menjadi menurun atau sebaliknya, yaitu harus memiliki benjolan.

Python 2 , 43 byte

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

Mengembalikan Benar jika ada benjolan, kesalahan jika tidak ada. ( diizinkan secara default )

Cobalah online!

Paket Oktaf dengan Gambar, 34 32 byte

2 byte disimpan berkat @StewieGriffin !

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

Cobalah online!

Penjelasan

Hitung perbedaan berturut-turut, susun dalam blok geser panjang 2, dapatkan produk dari masing-masing blok, dan uji apakah ada produk yang negatif.

R, 48 byte

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

Cobalah online!

Cara kerjanya langkah demi langkah menggunakan c (1,4,1,4) sebagai contoh:

> 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

Sebagai bonus, berikut adalah solusi dengan paket dan konsep yang sama menggunakan zoo:

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

Haskell , 33 byte

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

Cobalah online!

True jika ada masalah, kesalahan jika tidak ada.

Perl 6 , 39 byte

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

Cobalah online!

$_adalah argumen daftar untuk fungsi anonim ini. .[1..*]adalah daftar yang sama, tetapi dengan elemen pertama yang dijatuhkan. Zcmpritsleting kedua daftar bersama dengan cmpoperator, menghasilkan daftar Ordernilai. Misalnya, untuk daftar input 1, 2, 2, 2, 1ini akan menghasilkan daftar More, Same, Same, Less.

Sekarang kita hanya perlu tahu apakah daftar itu mengandung dua elemen yang berdekatan More, Lessatau Less, More. Trik yang saya gunakan adalah untuk mengubah daftar menjadi string dengan batas ruang ~, kemudian menguji apakah itu berisi substring re Latau s M. (Yang pertama tidak bisa hanya e Lkarena Samejuga diakhiri dengan "e".)

Operator kecocokan cerdas mengembalikan salah satu Matchobjek (jika kecocokan berhasil) atau Nil(jika tidak), jadi sokonversi apa pun itu menjadi nilai boolean.

Bahasa Wolfram (Mathematica) , 40 byte

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

Cobalah online!

Ruby , 55 46 byte

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

Cobalah online!

Seorang lambda menerima sebuah array dan mengembalikan boolean.

-9 byte: Ganti (x<y&&y>z)||(x>y&&y<z)dengan (y-x)*(y-z)>0(terima kasih kepada 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 byte

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 byte

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

-2 byte terima kasih kepada @ OlivierGrégoire .
-13 byte berkat @Nevay .

Cobalah online.

R , 58 56 byte

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

Cobalah online!

Disimpan 2 byte berkat Giuseppe

J , 16 15 byte

-1 byte terima kasih kepada FrownyFrog

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

Cobalah online!

Asli: 16 byte

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

2-/\] - Perbedaan dari setiap item yang berdekatan

2*/\ - produk dari setiap item yang berdekatan

[:<./ - minimum

0> - negatif?

Cobalah online!

Japt , 11 byte

-5 byte terima kasih kepada @ETHproductions

ä- mÌäa d>1

Cobalah online! | Uji kasus

Ini menggunakan algoritma Dennis

Japt , 9 byte

ä- ä* d<0

Cobalah online!

Gabungan jawaban Oliver dengan pendekatan yang digunakan oleh beberapa jawaban lain.

Attache , 39 byte

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

Cobalah online!

Cukup senang dengan hasilnya.

Penjelasan

Ini adalah komposisi dari empat fungsi:

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

Deltamendapat perbedaan antar elemen. =

Kemudian, Signditerapkan pada setiap perbedaan, memberi kita array 1s, 0s, dan -1s. =

Lalu, Slices&2berikan semua irisan panjang dua dari array, berikan semua pasangan perbedaan.

Akhirnya, Any&:&{_*~?Sum[__]}sama dengan, untuk input x:

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

Ini mencari elemen yang menjumlahkan ke nol tetapi bukan nol. Jika ada pasangan elemen seperti itu ada, maka ada benjolan.

MATL , 8 byte

dZSd|1>a

Cobalah online!

Sekam , 7 byte

V<0Ẋ*Ẋ-

Cobalah online!

Penjelasan

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

Oktaf , 33 byte

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

Cobalah online!

Penjelasan:

@(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 byte

s₃.¬≤₁∧¬≥₁

Cobalah online!

Berhasil (true. ) jika ada masalah, dan gagal ( false.) jika tidak ada masalah

Penjelasan

Ini sudah bisa dibaca:

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

05AB1E , 7 byte

¥ü‚P0‹Z

Cobalah online!

Penjelasan

¥         # 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 byte

s₃s₂ᶠ-ᵐ×<0

Cobalah online!

Tidak hampir serapi dan seanggun jawaban 10 byte @ Fatalize yang sudah ada, tetapi berhasil!

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

Sekam , 9 byte

▼mεẊ-Ẋo±-

Cobalah online!

Menggunakan algoritma Dennis.

Perl 5 , 54 + 2 ( -pa) = 56 byte

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

Cobalah online!

Python 2 , 60 byte

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

Cobalah online!

Hampir sama, berpikir itu akan lebih pendek ...

Python 2 , 63 byte

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

Cobalah online!

Pyt , 11 7 byte

₋ʁ*0<Ʃ±

Output 1 jika ada bump, 0 sebaliknya

Cobalah online!

Jawaban Haskell dari Port of Wheat Wizard

Cara lama (11 byte):

₋±₋Å1≤ĐŁ↔Ʃ=

Cobalah online!

Mengembalikan Palsu jika ada benjolan, Benar sebaliknya

Port of Dennis 'Jelly menjawab

Bahasa Wolfram (Mathematica) , 37 36 byte

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

Memberikan kebalikan dari jawaban test case (False dan True terbalik). Berlaku a! untuk beralih ke bentuk normal.

ATAU

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

Juga membalikkan output, jadi gantikan FreeQdenganMatchQ untuk bentuk normal.

Penjelasan: Ambil tanda perbedaan urutan. Jika urutan yang dihasilkan meliputi {1, -1} atau {-1,1} ada benjolan. Nilai absolut perbedaan {1, -1} atau {-1,1} adalah 2 dalam kedua kasus.

Matikan byte lain dengan mengkuadratkan daftar akhir alih-alih mengambil nilai absolut:

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

Cobalah online!

Perl, 35 byte

Termasuk +3untuk-p

bump.pl:

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

Jalankan sebagai:

bump.pl <<< "3 1 2"

Julia 0,6 , 57 56 byte

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

Pada dasarnya hanya jawaban python yang benar-benar manusiawi. -1 byte dari user71546

Cobalah online!

Julia 0,6 , 39 byte

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

Gaya rekursi Lispy, alias jawaban python Dennis. Kembali trueketika ada benjolan, jika tidak menimbulkan kesalahan. Ini mungkin harus 42 byte karena Anda harus memercikkannya saat menelepon. Misalnya untuk a=[1,2,1]Anda memanggil sebagai f(a...).f(a)=f(a...)akan menghapus kebutuhan itu, tetapi lebih lama. Saya perlu mendapatkan rekursi yang lebih baik, dan saya tidak begitu suka menulis kode yang menimbulkan kesalahan.

Cobalah online!