Biorąc pod uwagę listę dodatnich liczb całkowitych, określ, czy istnieje element, który jest większy niż jego dwóch sąsiadów lub mniejszy niż jego dwóch sąsiadów („wypukłość”). Żeby było jasne, wypukłość nigdy nie może być pierwszą lub ostatnią pozycją na liście, ponieważ mają tylko jednego sąsiada.

Twój program powinien wypisać jedną z dwóch spójnych wartości, z których każda odpowiada albo liście bez nierówności, albo liście z nierównościami. To, jakie są wartości, nie ma znaczenia, możesz sam je wybrać.

To jest golf golfowy, więc odpowiedzi będą liczone w bajtach, przy czym mniej bajtów będzie lepszych.

Przypadki testowe

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

Galaretka , 5 bajtów

IṠIỊẠ

Zwraca 0, jeśli jest nierówność, 1 jeśli nie.

Wypróbuj online!

Jak to działa

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 bajtów

Zwraca wartość logiczną.

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

Przypadki testowe

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

W jaki sposób?

Używamy a do przechowywania poprzedniej wartości n . Ustawiamy x na 1, jeśli a <n , -1 jeśli a> n lub 0, jeśli a = n . I sprawdzamy, czy old_x * x <0 , co jest możliwe tylko wtedy, gdy ( old_x = 1 i x = -1 ) lub ( old_x = -1 i x = 1 ).

Ponieważ x jest inicjowany do anonimowej funkcji zwrotnej niektórych () , jest on wymuszany na NaN podczas pierwszej iteracji, co powoduje, że test jest fałszywy.

Haskell , 42 bajty

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

Wypróbuj online!

Wyjaśnienie

Najpierw mamy funkcję, fktóra pobiera funkcję binarną i listę i stosuje funkcję binarną do każdej sąsiedniej pary na liście.

Następnie nasza główna funkcja dotyczy f(-)listy wejść. Oblicza to listę różnic. Następnie ubiegamy f(*)się o listę, aby pomnożyć każdą sąsiednią parę. Na koniec pytamy, czy jakakolwiek para jest mniejsza niż zero.

Liczba na liście końcowej może być ujemna tylko wtedy, gdy jest iloczynem liczby ujemnej i dodatniej z listy różnic. Dlatego w celu uzyskania wpisu ujemnego (a następnie zwrócenia wartości true) pierwotna lista musi przejść z wartości rosnącej na malejącą lub odwrotnie, tzn. Musi mieć nierówność.

Python 2 , 43 bajty

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

Zwraca wartość True, jeśli wystąpi guz, błędy, jeśli go nie ma. ( domyślnie dozwolone )

Wypróbuj online!

Oktawa z pakietem obrazów, 34 32 bajty

2 bajty zapisane dzięki @StewieGriffin !

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

Wypróbuj online!

Wyjaśnienie

Oblicza kolejne różnice, układa je w przesuwne bloki o długości 2, uzyskuje iloczyn każdego bloku i sprawdza, czy jakikolwiek taki produkt jest ujemny.

R, 48 bajtów

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

Wypróbuj online!

Jak to działa krok po kroku na przykładzie 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

Jako bonus, oto rozwiązanie o podobnej długości i koncepcji wykorzystujące pakiet zoo:

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

Haskell , 33 bajty

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

Wypróbuj online!

True jeśli jest nierówność, błędy, jeśli nie ma.

Perl 6 , 39 bajtów

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

Wypróbuj online!

$_jest argumentem listy tej anonimowej funkcji. .[1..*]to ta sama lista, ale z pominiętym pierwszym elementem. Zcmpzamyka obie listy razem z cmpoperatorem, co daje listę Orderwartości. Na przykład dla listy wejściowej 1, 2, 2, 2, 1spowoduje to powstanie listy More, Same, Same, Less.

Teraz musimy tylko wiedzieć, czy ta lista zawiera dwa sąsiednie elementy, More, Lessczy Less, More. Trik, którego użyłem, to przekonwertowanie listy na łańcuch rozdzielany spacjami za pomocą ~, a następnie przetestowanie, czy zawiera ona podłańcuch, re Lczy s M. (Pierwszy nie może być tylko e Ldlatego, że Samekończy się również na „e”.)

Inteligentny operator dopasowania zwraca Matchobiekt (jeśli dopasowanie się powiedzie) lub Nil(jeśli się nie udało), więc sokonwertuje cokolwiek to jest na wartość logiczną.

Wolfram Language (Mathematica) , 40 bajtów

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

Wypróbuj online!

Rubinowy , 55 46 bajtów

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

Wypróbuj online!

Lambda akceptuje tablicę i zwraca wartość logiczną.

-9 bajtów Wymienić (x<y&&y>z)||(x>y&&y<z)z (y-x)*(y-z)>0(dzięki 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 bajtów

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 bajtów

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

-2 bajty dzięki @ OlivierGrégoire .
-13 bajtów dzięki @Nevay .

Wypróbuj online.

R , 58 56 bajtów

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

Wypróbuj online!

Zaoszczędzono 2 bajty dzięki Giuseppe

J , 16 15 bajtów

-1 bajt dzięki FrownyFrog

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

Wypróbuj online!

Oryginał: 16 bajtów

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

2-/\] - różnice między sąsiadującymi elementami

2*/\ - produkty z każdej sąsiedniej pozycji

[:<./ - minimum

0> - jest negatywny?

Wypróbuj online!

Japt , 11 bajtów

-5 bajtów dzięki @ETHproductions

ä- mÌäa d>1

Wypróbuj online! | Przypadki testowe

Wykorzystuje algorytm Dennisa

Japt , 9 bajtów

ä- ä* d<0

Wypróbuj online!

Zestawienie odpowiedzi Olivera z podejściem zastosowanym w kilku innych odpowiedziach.

Attache , 39 bajtów

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

Wypróbuj online!

Całkiem zadowolony z tego, jak to się potoczyło.

Wyjaśnienie

Jest to kompozycja czterech funkcji:

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

Deltapobiera różnice między elementami. =

Następnie Signstosuje się do każdej różnicy, dając nam tablicę 1s, 0s i -1s. =

Następnie Slices&2daje wszystkie wycinki długości dwa z tablicy, podając wszystkie pary różnic.

Wreszcie Any&:&{_*~?Sum[__]}jest równoważne z danymi wejściowymi x:

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

Wyszukuje elementy, które sumują się do zera, ale nie są zerem. Jeśli istnieje jakakolwiek taka para elementów, oznacza to nierówność.

MATL , 8 bajtów

dZSd|1>a

Wypróbuj online!

Łuska , 7 bajtów

V<0Ẋ*Ẋ-

Wypróbuj online!

Wyjaśnienie

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

Oktawa , 33 bajty

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

Wypróbuj online!

Wyjaśnienie:

@(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 bajtów

s₃.¬≤₁∧¬≥₁

Wypróbuj online!

Udaje się ( true.), jeśli występuje nierówność, i nie ( false.), jeśli nie ma nierówności.

Wyjaśnienie

Jest to już dość czytelne:

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

05AB1E , 7 bajtów

¥ü‚P0‹Z

Wypróbuj online!

Wyjaśnienie

¥         # 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 bajtów

s₃s₂ᶠ-ᵐ×<0

Wypróbuj online!

Nie jest tak schludny i elegancki jak istniejąca 10-bajtowa odpowiedź @ Fatalize, ale działa!

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

Łuska , 9 bajtów

▼mεẊ-Ẋo±-

Wypróbuj online!

Wykorzystuje algorytm Dennisa.

Perl 5 , 54 + 2 ( -pa) = 56 bajtów

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

Wypróbuj online!

Python 2 , 60 bajtów

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

Wypróbuj online!

Prawie to samo, pomyślałem, że będzie krótszy ...

Python 2 , 63 bajty

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

Wypróbuj online!

Pyt , 11 7 bajtów

₋ʁ*0<Ʃ±

Wysyła 1, jeśli występuje nierówność, 0 w przeciwnym razie

Wypróbuj online!

Odpowiedź Haskell z Port of Wheat Wizard

Stary sposób (11 bajtów):

₋±₋Å1≤ĐŁ↔Ʃ=

Wypróbuj online!

Zwraca wartość Fałsz, jeśli wystąpi guz, Prawda w przeciwnym razie

Portowa odpowiedź Dennisa na galaretkę

Wolfram Language (Mathematica) , 37 36 bajtów

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

Podaje przeciwieństwo odpowiedzi na przypadki testowe (odwrócone False i True). Przygotuj a, !aby przejść do normalnej postaci.

LUB

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

Odwrócona także wyjście, więc zastąpić FreeQz MatchQnormalnej formie.

Objaśnienie: Weź znak różnic w sekwencji. Jeśli wynikowa sekwencja obejmuje {1, -1} lub {-1,1} występuje nierówność. Bezwzględna wartość różnic {1, -1} lub {-1,1} wynosi 2 w obu przypadkach.

Ogol kolejny bajt, wyrównując ostateczną listę zamiast przyjmując wartość bezwzględną:

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

Wypróbuj online!

Perl, 35 bajtów

Obejmuje +3dla-p

bump.pl:

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

Uruchom jako:

bump.pl <<< "3 1 2"

Julia 0.6 , 57 56 bajtów

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

Zasadniczo, po prostu całkowicie ludzka odpowiedź na python. -1 bajt od użytkownika 71546

Wypróbuj online!

Julia 0.6 , 39 bajtów

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

Styl rekurencji Lispy, czyli odpowiedź pytona Dennisa. Zwraca, truegdy występuje nierówność, w przeciwnym razie zgłasza błąd. Powinno to być może 42 bajty, ponieważ musisz przeliterować go podczas rozmowy. Np. Dzwonisz a=[1,2,1]jako f(a...). f(a)=f(a...)usunę tę potrzebę, ale jest ona dłuższa. Muszę poprawić rekurencję i nie lubię pisać kodu, który generuje błąd.

Wypróbuj online!