Dada una lista de enteros positivos, determine si hay un elemento que sea mayor que sus dos vecinos o menor que sus dos vecinos (una "protuberancia"). Para ser claros, una protuberancia nunca puede ser el primer o el último elemento de la lista porque solo tienen un vecino.

Su programa debería generar uno de dos valores consistentes, cada uno correspondiente a una lista sin protuberancias o una lista con protuberancias. Los valores no son importantes, puede elegirlos usted mismo.

Este es el código de golf, por lo que las respuestas se puntuarán en bytes, con menos bytes mejor.

Casos de prueba

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

Jalea , 5 bytes

IṠIỊẠ

Devuelve 0 si hay una protuberancia, 1 si no.

Pruébalo en línea!

Cómo 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

Devuelve un booleano.

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

Casos de prueba

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

¿Cómo?

Usamos a para almacenar el valor anterior de n . Hemos establecido x a 1 si un <n , -1 si a> n o 0 si a = n . Y probamos si old_x * x <0 , que solo es posible si ( old_x = 1 y x = -1 ) o ( old_x = -1 y x = 1 ).

Debido a que x se inicializa a la función de devolución de llamada anónima de some () , se coacciona a NaN durante la primera iteración, lo que hace que la prueba sea falsa.

Haskell , 42 bytes

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

Pruébalo en línea!

Explicación

Primero tenemos la función fque toma una función binaria y una lista y aplica la función binaria a cada par adyacente en la lista.

Entonces nuestra función principal se aplica f(-)a la lista de entrada. Esto calcula la lista de diferencias. Luego aplicamos f(*)a la lista para multiplicar cada par adyacente. Por último, preguntamos si algún par es menor que cero.

Un número en la lista final solo puede ser negativo si es el producto de un número negativo y positivo de la lista de diferencias. Por lo tanto, para producir una entrada negativa (y luego devolver verdadero) la lista original debe cambiar de creciente a decreciente o viceversa, es decir, debe tener una protuberancia.

Python 2 , 43 bytes

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

Devuelve True si hay una protuberancia, errores si no la hay. ( permitido por defecto )

Pruébalo en línea!

Octava con paquete de imágenes, 34 32 bytes

¡2 bytes guardados gracias a @StewieGriffin !

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

Pruébalo en línea!

Explicación

Calcula diferencias consecutivas, las organiza en bloques deslizantes de longitud 2, obtiene el producto de cada bloque y prueba si alguno de estos productos es negativo.

R, 48 bytes

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

Pruébalo en línea!

Cómo funciona paso a paso usando c (1,4,1,4) como ejemplo:

> 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 beneficio adicional, aquí hay una solución de longitud y concepto similar usando el paquete 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

Pruébalo en línea!

True si hay una protuberancia, errores si no la hay.

Perl 6 , 39 bytes

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

Pruébalo en línea!

$_es el argumento de la lista para esta función anónima. .[1..*]es la misma lista, pero con el primer elemento descartado. Zcmpcomprime las dos listas junto con el cmpoperador, lo que da como resultado una lista de Ordervalores. Por ejemplo, para una lista de entrada, 1, 2, 2, 2, 1esto daría como resultado la lista More, Same, Same, Less.

Ahora solo necesitamos saber si esa lista contiene dos elementos adyacentes More, Lesso Less, More. El truco que utilicé es convertir la lista a una cadena delimitada por espacios ~, luego probar si contiene subcadena re Lo s M. (El primero no puede ser solo e Lporque Sametambién termina con una "e").

El operador de coincidencia inteligente devuelve un Matchobjeto (si la coincidencia tuvo éxito) o Nil(si no lo hizo), por solo que convierte lo que sea en un valor booleano.

Wolfram Language (Mathematica) , 40 bytes

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

Pruébalo en línea!

Ruby , 55 46 bytes

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

Pruébalo en línea!

Una lambda que acepta una matriz y devuelve un valor booleano.

-9 bytes: reemplazar (x<y&&y>z)||(x>y&&y<z)con (y-x)*(y-z)>0(gracias a 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 gracias a @ OlivierGrégoire .
-13 bytes gracias a @Nevay .

Pruébalo en línea.

R , 58 56 bytes

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

Pruébalo en línea!

Guardado 2 bytes gracias a Giuseppe

J , 16 15 bytes

-1 byte gracias a FrownyFrog

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

Pruébalo en línea!

Original: 16 bytes

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

2-/\] - diferencias de cada elemento adyacente

2*/\ - productos de cada artículo adyacente

[:<./ - el mínimo

0> - es negativo?

Pruébalo en línea!

Japt , 11 bytes

-5 bytes gracias a @ETHproductions

ä- mÌäa d>1

Pruébalo en línea! El | Casos de prueba

Esto usa el algoritmo de Dennis

Japt , 9 bytes

ä- ä* d<0

Pruébalo en línea!

Un mashup de la respuesta de Oliver con el enfoque utilizado por varias otras respuestas.

Adjunto , 39 bytes

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

Pruébalo en línea!

Muy contento con cómo resultó esto.

Explicación

Esta es una composición de cuatro funciones:

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

DeltaObtiene las diferencias entre los elementos. =

Luego, Signse aplica a cada diferencia, dándonos una matriz de 1s, 0sy -1s. =

Luego, Slices&2da todos los cortes de longitud dos de la matriz, dando todos los pares de diferencias.

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

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

Esto busca elementos que suman cero pero no son cero. Si existe un par de elementos de este tipo, entonces hay una protuberancia.

MATL , 8 bytes

dZSd|1>a

Pruébalo en línea!

Casco , 7 bytes

V<0Ẋ*Ẋ-

Pruébalo en línea!

Explicación

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

Octava , 33 bytes

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

Pruébalo en línea!

Explicación:

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

s₃.¬≤₁∧¬≥₁

Pruébalo en línea!

Tiene éxito ( true.) si hay una protuberancia, y falla ( false.) si no hay una protuberancia.

Explicación

Esto ya es bastante legible:

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

05AB1E , 7 bytes

¥ü‚P0‹Z

Pruébalo en línea!

Explicación

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

s₃s₂ᶠ-ᵐ×<0

Pruébalo en línea!

No es tan ordenado y elegante como la respuesta de 10 bytes existente de @ Fatalize, ¡pero 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

Casco , 9 bytes

▼mεẊ-Ẋo±-

Pruébalo en línea!

Utiliza el algoritmo de Dennis.

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

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

Pruébalo en línea!

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

Pruébalo en línea!

Más o menos lo mismo, aunque pensé que sería más corto ...

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

Pruébalo en línea!

Pyt , 11 7 bytes

₋ʁ*0<Ʃ±

Salidas 1 si hay una protuberancia, 0 de lo contrario

Pruébalo en línea!

Respuesta de Haskell del mago del puerto de trigo

Antigua forma (11 bytes):

₋±₋Å1≤ĐŁ↔Ʃ=

Pruébalo en línea!

Devuelve False si hay una protuberancia, True de lo contrario

Port of Dennis 'Jelly respuesta

Wolfram Language (Mathematica) , 37 36 bytes

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

Da lo contrario de las respuestas de los casos de prueba (Falso y Verdadero invertido). Anteponer un! para cambiar a la forma normal.

O

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

También se invierte la salida, así que reemplace FreeQcon MatchQla forma normal.

Explicación: Tome el signo de las diferencias de la secuencia. Si la secuencia resultante incluye {1, -1} o {-1,1} hay una protuberancia. El valor absoluto de las diferencias de {1, -1} o {-1,1} es 2 en cualquier caso.

Elimine otro byte al cuadrar la lista final en lugar de tomar el valor absoluto:

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

Pruébalo en línea!

Perl, 35 bytes

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

Básicamente, la respuesta de Python totalmente humana. -1 byte del usuario 71546

Pruébalo en línea!

Julia 0.6 , 39 bytes

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

Estilo de recursión de Lispy, también conocido como la respuesta en pitón de Dennis. Devuelve truecuando existe una protuberancia, de lo contrario arroja un error. Tal vez debería ser de 42 bytes, ya que debe salpicarlo al llamar. Por ejemplo, para a=[1,2,1]llamar como f(a...). f(a)=f(a...)eliminaría esa necesidad, pero es más larga. Necesito mejorar una recursión, y realmente no me gusta escribir código que arroje un error.

Pruébalo en línea!