По заданному списку положительных целых чисел определите, существует ли элемент, который больше, чем его два соседа, или меньше, чем его два соседа («удар»). Чтобы быть понятным, выпуклость никогда не может быть первым или последним элементом списка, потому что у них есть только один сосед.

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

Это код-гольф, поэтому ответы будут оцениваться в байтах, причем меньшее количество байтов будет лучше.

Контрольные примеры

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

Как?

Мы используем для хранения предыдущего значения п . Мы устанавливаем x в 1, если a <n , -1 если a> n или 0, если a = n . И мы проверяем, является ли old_x * x <0 , что возможно, только если ( old_x = 1 и x = -1 ) или ( old_x = -1 и 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 байта

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преобразует все, что есть, в логическое значение.

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)

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

Попробуйте онлайн!

Сочетание ответа Оливера с подходом, использованным несколькими другими ответами.

Атташе , 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≤ĐŁ↔Ʃ=

Попробуйте онлайн!

Возвращает False, если есть удар, True в противном случае

Порт Денис Желе ответ

Wolfram Language (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. -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...)удалил бы эту потребность, но это дольше. Мне нужно улучшить рекурсию, и мне не очень нравится писать код, который выдает ошибку.

Попробуйте онлайн!