Dada uma lista de números inteiros positivos, determine se existe um elemento que é maior que seus dois vizinhos ou menor que seus dois vizinhos (um "bump"). Para ficar claro, um solavanco nunca pode ser o primeiro ou o último item da lista, porque eles têm apenas um vizinho.

Seu programa deve gerar um dos dois valores consistentes, cada um correspondente a uma lista sem bumps ou a uma lista com bumps. Quais são os valores não são importantes, você pode escolhê-los.

Isso é código-golfe, então as respostas serão pontuadas em bytes, com menos bytes sendo melhores.

Casos de teste

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

Geléia , 5 bytes

IṠIỊẠ

Retorna 0 se houver um aumento, 1 se não houver.

Experimente online!

Como funciona

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 bytes

Retorna um booleano.

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

Casos de teste

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

Quão?

Usamos a para armazenar o valor anterior de n . Definimos x como 1 se a <n , -1 se a> n ou 0 se a = n . E testar se old_x * x <0 , o que só é possível se ( old_x = 1 e x = -1 ) ou ( old_x = -1 e x = 1 ).

Como x é inicializado para a função de retorno de chamada anônima de some () , ele é coagido ao NaN durante a primeira iteração, o que torna o teste falso.

Haskell , 42 bytes

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

Experimente online!

Explicação

Primeiro, temos a função fque pega uma função binária e uma lista e aplica a função binária a todos os pares adjacentes da lista.

Então nossa função principal se aplica f(-)à lista de entradas. Isso calcula a lista de diferenças. Em seguida, aplicamos f(*)à lista para multiplicar todos os pares adjacentes. Por fim, perguntamos se algum par é menor que zero.

Um número na lista final só pode ser negativo se for o produto de um número negativo e positivo da lista de diferenças. Portanto, para produzir uma entrada negativa (e depois retornar true), a lista original deve mudar de crescente para decrescente ou vice-versa, ou seja, deve ter um bump.

Python 2 , 43 bytes

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

Retorna True se houver um erro, erros se não houver. ( permitido por padrão )

Experimente online!

Oitava com Pacote de Imagens, 34 32 bytes

2 bytes salvos graças a @StewieGriffin !

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

Experimente online!

Explicação

Calcula diferenças consecutivas, organiza-as em blocos deslizantes de comprimento 2, obtém o produto de cada bloco e testa se esse produto é negativo.

R, 48 bytes

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

Experimente online!

Como funciona passo a passo usando c (1,4,1,4) como exemplo:

> 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

Como bônus, aqui está uma solução de tamanho e conceito semelhante usando o pacote zoo:

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

Haskell , 33 bytes

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

Experimente online!

True se houver um solavanco, erros se não houver.

Perl 6 , 39 bytes

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

Experimente online!

$_é o argumento da lista para essa função anônima. .[1..*]é a mesma lista, mas com o primeiro elemento descartado. Zcmpfecha as duas listas junto com o cmpoperador, resultando em uma lista de Ordervalores. Por exemplo, para uma lista de entrada, 1, 2, 2, 2, 1isso resultaria na lista More, Same, Same, Less.

Agora só precisamos saber se essa lista contém dois elementos adjacentes More, Lessou Less, More. O truque que usei é converter a lista em uma string delimitada por espaço ~e testar se ela contém substring re Lou s M. (O primeiro não pode ser apenas e Lporque Sametambém termina com um "e".)

O operador de correspondência inteligente retorna um Matchobjeto (se a correspondência for bem-sucedida) ou Nil(se não foi o caso); portanto, soconverte o que quer que seja em um valor booleano.

Wolfram Language (Mathematica) , 40 bytes

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

Experimente online!

Rubi , 55 46 bytes

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

Experimente online!

Um lambda aceitando uma matriz e retornando booleano.

-9 bytes: Substitua (x<y&&y>z)||(x>y&&y<z)por (y-x)*(y-z)>0(graças ao 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 bytes

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 bytes

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

-2 bytes graças a @ OlivierGrégoire .
-13 bytes graças a @Nevay .

Experimente online.

R , 58 56 bytes

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

Experimente online!

Economizou 2 bytes graças a Giuseppe

J , 16 15 bytes

-1 byte graças a FrownyFrog

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

Experimente online!

Original: 16 bytes

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

2-/\] - diferenças de cada item adjacente

2*/\ - produtos de cada item adjacente

[:<./ - o mínimo

0> - é negativo?

Experimente online!

Japt , 11 bytes

-5 bytes graças a @ETHproductions

ä- mÌäa d>1

Experimente online! |Casos de teste

Isso usa o algoritmo de Dennis

Japonês , 9 bytes

ä- ä* d<0

Experimente online!

Um mashup da resposta de Oliver com a abordagem usada por várias outras respostas.

Anexo , 39 bytes

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

Experimente online!

Muito feliz com o resultado.

Explicação

Esta é uma composição de quatro funções:

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

Deltaobtém as diferenças entre os elementos. =

Então, Signé aplicada a cada diferença, dando uma série de 1s, 0s, e-1 s. =

Então, Slices&2 fornece todas as fatias de comprimento dois da matriz, fornecendo todos os pares de diferenças.

Finalmente, Any&:&{_*~?Sum[__]}é equivalente a, para entrada x:

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

Ele procura por elementos que somam zero, mas não são zero. Se qualquer par de elementos existir, haverá um aumento.

MATL , 8 bytes

dZSd|1>a

Experimente online!

Casca , 7 bytes

V<0Ẋ*Ẋ-

Experimente online!

Explicação

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

Oitava , 33 bytes

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

Experimente online!

Explicação:

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

Braquilog , 10 bytes

s₃.¬≤₁∧¬≥₁

Experimente online!

Sucede ( true.) se houver um solavanco e falha (false. ) se não houver um solavanco.

Explicação

Isso já é bastante legível:

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

05AB1E , 7 bytes

¥ü‚P0‹Z

Experimente online!

Explicação

¥         # calculate delta's
 ü‚       # pair each element with the next element
   P      # product of each pair
    0‹    # check each if less than 0
      Z   # max

Braquilog , 10 bytes

s₃s₂ᶠ-ᵐ×<0

Experimente online!

Não é tão elegante e elegante quanto a resposta de 10 bytes existente do @ Fatalize, mas funciona!

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

Casca , 9 bytes

▼mεẊ-Ẋo±-

Experimente online!

Usa o algoritmo de Dennis.

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

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

Experimente online!

Python 2 , 60 bytes

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

Experimente online!

Praticamente a mesma coisa, mas pensei que seria mais curto ...

Python 2 , 63 bytes

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

Experimente online!

Pyt , 11 7 bytes

₋ʁ*0<Ʃ±

Saídas 1 se houver um aumento, 0 caso contrário

Experimente online!

Resposta do Haskell do Assistente do Porto de Trigo

Maneira antiga (11 bytes):

₋±₋Å1≤ĐŁ↔Ʃ=

Experimente online!

Retorna False se houver um aumento, True caso contrário

Resposta da geléia do Porto de Dennis

Wolfram Language (Mathematica) , 37 36 bytes

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

Fornece o oposto das respostas do caso de teste (Falso e Verdadeiro invertidos). Anexar um! para mudar para o formato normal.

OU

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

Saída também invertida, então substitua FreeQ por MatchQpara a forma normal.

Explicação: Pegue o sinal das diferenças da sequência. Se a sequência resultante inclui {1, -1} ou {-1,1}, há um aumento. O valor absoluto das diferenças de {1, -1} ou {-1,1} é 2 em ambos os casos.

Raspe outro byte ao quadrado da lista final em vez de pegar o valor absoluto:

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

Experimente online!

Perl, 35 bytes

Inclui +3para-p

bump.pl:

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

Correr como:

bump.pl <<< "3 1 2"

Julia 0.6 , 57 56 bytes

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

Basicamente, apenas a resposta python totalmente humana. -1 byte do usuário71546

Experimente online!

Julia 0.6 , 39 bytes

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

Estilo de recursão Lispy, também conhecido como resposta python de Dennis. Retorna truequando existe um bump; caso contrário, gera um erro. Talvez deva ter 42 bytes, já que você precisa dividi-lo ao chamar. Por exemplo, para a=[1,2,1]você ligar como f(a...). f(a)=f(a...)removeria essa necessidade, mas é mais longa. Preciso melhorar uma recursão e não gosto muito de escrever código que gera um erro.

Experimente online!