Đưa ra một danh sách các số nguyên dương xác định xem có một phần tử nào lớn hơn hai lân cận của nó hoặc nhỏ hơn hai lân cận của nó (một "vết sưng"). Để rõ ràng một vết sưng không bao giờ có thể là mục đầu tiên hoặc cuối cùng của danh sách bởi vì họ chỉ có một người hàng xóm.

Chương trình của bạn sẽ xuất ra một trong hai giá trị nhất quán, mỗi giá trị tương ứng với một danh sách không có sự va chạm hoặc danh sách có sự va chạm. Giá trị là gì không quan trọng, bạn có thể tự mình chọn chúng.

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn.

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

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

Thạch , 5 byte

IṠIỊẠ

Trả về 0 nếu có một vết sưng, 1 nếu không.

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

Làm thế nào nó hoạt động

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

Trả về một boolean.

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

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

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

Làm sao?

Chúng tôi sử dụng a để lưu trữ giá trị trước đó của n . Chúng tôi đặt x thành 1 nếu a <n , -1 nếu a> n hoặc 0 nếu a = n . Và chúng tôi kiểm tra xem old_x * x <0 , điều này chỉ có thể nếu ( old_x = 1 và x = -1 ) hoặc ( old_x = -1 và x = 1 ).

Vì x được khởi tạo cho hàm gọi lại ẩn danh của một số () , nên nó bị ép buộc với NaN trong lần lặp đầu tiên, điều này làm cho thử nghiệm sai lệch.

Haskell , 42 byte

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

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

Giải trình

Đầu tiên chúng ta có hàm flấy hàm nhị phân và danh sách và áp dụng hàm nhị phân cho mọi cặp liền kề trong danh sách.

Sau đó, chức năng chính của chúng tôi áp dụng f(-)cho danh sách đầu vào. Điều này tính toán danh sách khác biệt. Sau đó chúng tôi áp dụng f(*)vào danh sách để nhân mọi cặp liền kề. Cuối cùng, chúng tôi hỏi nếu có cặp nào nhỏ hơn 0.

Một số trong danh sách kết thúc chỉ có thể âm nếu đó là sản phẩm của một số âm và dương từ danh sách chênh lệch. Do đó, để tạo ra một mục tiêu cực (và sau đó trả về đúng), danh sách ban đầu phải chuyển từ tăng sang giảm hoặc ngược lại, đó là phải có một vết sưng.

Python 2 , 43 byte

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

Trả về Đúng nếu có một vết sưng, lỗi nếu không có. ( được phép theo mặc định )

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

Octave với gói hình ảnh, 34 32 byte

Lưu 2 byte nhờ @StewieGriffin !

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

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

Giải trình

Tính toán sự khác biệt liên tiếp, sắp xếp chúng trong các khối trượt có chiều dài 2, lấy sản phẩm của từng khối và kiểm tra xem có sản phẩm nào âm tính không.

R, 48 byte

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

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

Cách thức hoạt động từng bước bằng cách sử dụng c (1,4,1,4) làm ví dụ:

> 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

Như một phần thưởng, đây là một giải pháp có độ dài và khái niệm tương tự bằng cách sử dụng gói 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

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

True nếu có một vết sưng, lỗi nếu không có.

Perl 6 , 39 byte

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

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

$_là đối số danh sách cho hàm ẩn danh này. .[1..*]là cùng một danh sách, nhưng với phần tử đầu tiên bị loại bỏ. Zcmpnén hai danh sách cùng với cmptoán tử, dẫn đến một danh sách các Ordergiá trị. Ví dụ, đối với một danh sách đầu vào, 1, 2, 2, 2, 1điều này sẽ dẫn đến danh sách More, Same, Same, Less.

Bây giờ chúng ta chỉ cần biết liệu danh sách đó có chứa hai phần tử liền kề More, Lesshay không Less, More. Thủ thuật tôi đã sử dụng là chuyển đổi danh sách thành một chuỗi được phân tách bằng dấu cách ~, sau đó kiểm tra xem nó có chứa chuỗi con re Lhay không s M. (Cái đầu tiên không thể chỉ e Lvì Samecũng kết thúc bằng "e".)

Toán tử kết hợp thông minh trả về một Matchđối tượng (nếu kết quả khớp thành công) hoặc Nil(nếu không), do đó sochuyển đổi bất cứ thứ gì thành giá trị boolean.

Ngôn ngữ Wolfram (Mathicala) , 40 byte

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

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

Ruby , 55 46 byte

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

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

Một lambda chấp nhận một mảng và trả về boolean.

-9 byte: Thay thế (x<y&&y>z)||(x>y&&y<z)bằng (y-x)*(y-z)>0(nhờ 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
    }
}

PostgreQuery 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 nhờ @ OlivierGrégoire .
-13 byte nhờ @Nevay .

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

R , 58 56 byte

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

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

Đã lưu 2 byte nhờ Giuseppe

J , 16 15 byte

-1 byte nhờ FrownyFrog

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

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

Bản gốc: 16 byte

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

2-/\] - sự khác biệt của từng hạng mục liền kề

2*/\ - sản phẩm của từng mặt hàng liền kề

[:<./ - mức tối thiểu

0> - là tiêu cực?

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

Japt , 11 byte

-5 byte nhờ @ETHproductions

ä- mÌäa d>1

Hãy thử trực tuyến! | Các trường hợp thử nghiệm

Cái này sử dụng thuật toán của Dennis

Japt , 9 byte

ä- ä* d<0

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

Một bản hòa trộn câu trả lời của Oliver với cách tiếp cận được sử dụng bởi một số câu trả lời khác.

Tùy viên , 39 byte

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

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

Khá hạnh phúc với cách này bật ra.

Giải trình

Đây là một thành phần của bốn chức năng:

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

Deltacó được sự khác biệt giữa các yếu tố. = =

Sau đó, Signđược áp dụng cho từng khác biệt, cho chúng ta một mảng 1s, 0s và-1 s. = =

Sau đó, Slices&2 đưa ra tất cả các lát có độ dài hai từ mảng, cho tất cả các cặp khác biệt.

Cuối cùng, Any&:&{_*~?Sum[__]}tương đương với, cho đầu vào x:

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

Điều này tìm kiếm các phần tử có tổng bằng 0 nhưng không bằng không. Nếu bất kỳ cặp yếu tố như vậy tồn tại, thì có một vết sưng.

MATL , 8 byte

dZSd|1>a

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

Husk , 7 byte

V<0Ẋ*Ẋ-

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

Giải trình

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

Octave , 33 byte

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

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

Giải trình:

@(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₃.¬≤₁∧¬≥₁

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

Thành công ( true.) nếu có một vết sưng, và thất bại ( false.) nếu không có vết sưng.

Giải trình

Điều này khá dễ đọc rồi:

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

05AB1E , 7 byte

¥ü‚P0‹Z

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

Giải trình

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

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

Không gần như gọn gàng và thanh lịch như câu trả lời 10 byte hiện có của @ Fatalize, nhưng nó hoạt động!

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

Husk , 9 byte

▼mεẊ-Ẋo±-

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

Sử dụng thuật toán của Dennis.

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

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

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

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:]))

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

Khá nhiều điều tương tự, nghĩ rằng nó sẽ ngắn hơn mặc dù ...

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:]))

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

Pyt , 11 7 byte

₋ʁ*0<Ʃ±

Đầu ra 1 nếu có một vết sưng, 0 nếu không

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

Câu trả lời Haskell của Port of Wheat

Cách cũ (11 byte):

₋±₋Å1≤ĐŁ↔Ʃ=

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

Trả về Sai nếu có vết sưng, Đúng khác

Câu trả lời của cảng Dennis 'Jelly

Ngôn ngữ Wolfram (Mathicala) , 37 36 byte

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

Cung cấp ngược lại với các câu trả lời trường hợp thử nghiệm (Sai ​​và đúng đảo ngược). Chuẩn bị một! để chuyển sang hình thức bình thường.

HOẶC LÀ

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

Cũng đảo ngược đầu ra, vì vậy thay thế FreeQbằngMatchQ cho hình thức bình thường.

Giải thích: Lấy dấu hiệu của sự khác biệt của chuỗi. Nếu chuỗi kết quả bao gồm {1, -1} hoặc {-1,1} có một vết sưng. Giá trị tuyệt đối chênh lệch của {1, -1} hoặc {-1,1} là 2 trong cả hai trường hợp.

Tắt một byte khác bằng cách bình phương danh sách cuối cùng thay vì lấy giá trị tuyệt đối:

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

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

Perl, 35 byte

Bao gồm +3cho-p

bump.pl:

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

Chạy như:

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

Về cơ bản chỉ là câu trả lời trăn của hoàn toàn con người. -1 byte từ user71546

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

Julia 0,6 , 39 byte

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

Phong cách đệ quy Lispy, còn gọi là câu trả lời trăn của Dennis. Trả về truekhi một vết sưng tồn tại, nếu không sẽ ném một lỗi. Đây có thể là 42 byte vì bạn phải tách nó khi gọi. Ví dụ cho a=[1,2,1]bạn gọi là f(a...).f(a)=f(a...)sẽ loại bỏ nhu cầu đó, nhưng lâu hơn. Tôi cần phải có một đệ quy tốt hơn và tôi thực sự không thích viết mã gây ra lỗi.

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