Даний список позитивних цілих чисел визначають, чи є елемент, який або більший, ніж його два сусіди, або менший, ніж два його сусіди ("удар"). Щоб зрозуміти, бумп ніколи не може бути першим чи останнім пунктом у списку, оскільки у них є лише один сусід.

Ваша програма повинна вивести одне з двох послідовних значень, кожне з яких відповідає списку без ударів, або списку з ударами. Які значення є неважливими, ви можете вибирати їх самостійно.

Це кодовий гольф, тому відповіді будуть набрані в байтах, а менша кількість байтів буде кращою.

Тестові справи

[] -> 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 . Встановлюємо х на 1, якщо a <n , -1 якщо a> n або 0, якщо a = n . І ми перевіряємо, чи old_x * x <0 , що можливо лише в тому випадку, якщо ( old_x = 1 і x = -1 ) або ( old_x = -1 і x = 1 ).

Оскільки x ініціалізується на функцію анонімного зворотного виклику деяких () , він примушується до NaN під час першої ітерації, що робить тест хибним.

Хаскелл , 42 байти

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

Спробуйте в Інтернеті!

Пояснення

Спочатку ми маємо функцію, fяка приймає бінарну функцію та список і застосовує бінарну функцію до кожної сусідньої пари у списку.

Тоді наша основна функція стосується f(-)списку введення. Це обчислює різницю списку. Потім ми звертаємось f(*)до списку для множення кожної сусідньої пари. Нарешті, ми запитуємо, чи якась пара менше нуля.

Число в кінцевому списку може бути від’ємним, лише якщо це добуток від’ємного та додатного числа зі списку різниць. Таким чином, щоб створити негативний запис (а потім повернути істинне), початковий список повинен перейти від збільшення до зменшення або навпаки, тобто він повинен мати удар.

Python 2 , 43 байти

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

Повертає True, якщо виникає удар, помилки, якщо його немає. ( дозволено за замовчуванням )

Спробуйте в Інтернеті!

Октава з пакетом зображень, 34 32 байти

2 байти збережено завдяки @StewieGriffin !

@(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..*]це той самий список, але з першим скинутим елементом. Zcmpпереносить два списки разом з cmpоператором, в результаті чого виходить список Orderзначень. Наприклад, для вхідного списку 1, 2, 2, 2, 1це призведе до списку More, Same, Same, Less.

Тепер нам просто потрібно знати, чи містить цей список два суміжні елементи More, Lessабо Less, More. Трюк, який я використав, полягає в перетворенні списку в рядку з обмеженим пробілом ~, а потім перевірити, чи містить він підрядку re Lабо s M. (Перший не може бути лише e Lтому, що Sameтакож закінчується символом "е".)

Оператор розумної відповідності повертає або Matchоб’єкт (якщо збіг вдався), або Nil(якщо він не відбувся), тому soперетворює все, що є, у булеве значення.

Мова Вольфрама (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;}

-2 байти завдяки @ OlivierGrégoire .
-13 байт завдяки @Nevay .

Спробуйте в Інтернеті.

R , 58 56 байт

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

Спробуйте в Інтернеті!

Збережено 2 байти завдяки Джузеппе

J , 16 15 байт

-1 байт завдяки FrownyFrog

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

Спробуйте в Інтернеті!

Оригінал: 16 байт

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

2-/\] - відмінності кожного суміжного предмета

2*/\ - вироби кожного суміжного предмета

[:<./ - мінімум

0> - негативно?

Спробуйте в Інтернеті!

Japt , 11 байт

-5 байт завдяки @ETHproductions

ä- mÌäa d>1

Спробуйте в Інтернеті! | Тестові справи

Для цього використовується алгоритм Денніса

Japt , 9 байт

ä- ä* d<0

Спробуйте в Інтернеті!

Розбір відповіді Олівера з підходом, використовуваним кількома іншими відповідями.

Attache , 39 байт

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

Спробуйте в Інтернеті!

Досить задоволений тим, як це вийшло.

Пояснення

Це склад з чотирьох функцій:

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

Deltaотримує відмінності між елементами. =

Потім, Signзастосовується до кожної різниці, даючи нам масив 1s, 0s і -1s. =

Потім, Slices&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

Брахілог , 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

Брахілог , 10 байт

s₃s₂ᶠ-ᵐ×<0

Спробуйте в Інтернеті!

Не настільки охайний та елегантний, як існуючий 10-байтний відповідь @ Fatalize, але він працює!

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

Спробуйте в Інтернеті!

Піт , 11 7 байт

₋ʁ*0<Ʃ±

Виходи 1, якщо є удар, 0 в іншому випадку

Спробуйте в Інтернеті!

Відповідь Хаскеля Порта Пшеничного Майстра

Старий шлях (11 байт):

₋±₋Å1≤ĐŁ↔Ʃ=

Спробуйте в Інтернеті!

Повертається помилково, якщо є удар, правда інакше

Відповідь «Порт Денніса»

Мова Вольфрама (Mathematica) , 37 36 байт

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

Дає протилежні відповіді тестових випадків (помилкові та істинні зворотні). Попередження 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]&

Спробуйте в Інтернеті!

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

В основному просто нелюдська відповідь пітона. -1 байт від користувача71546

Спробуйте в Інтернеті!

Джулія 0,6 , 39 байт

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

Стиль рекурсії Ліспі, він же відповідь пітона Денніса. Повертається, trueколи виникає помилка, інакше видається помилка. Це, можливо, має бути 42 байти, оскільки вам потрібно заплести це під час дзвінка. Наприклад, a=[1,2,1]ви називаєте як f(a...).f(a)=f(a...)усуне цю потребу, але довше. Мені потрібно покращити рекурсію, і мені не дуже подобається писати код, який видає помилку.

Спробуйте в Інтернеті!