¿Hay un bulto?

39

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

code-golf number array-manipulation decision-problem

— Asistente de trigo
fuente

55

Solicitud de caso de prueba: números distintos de 0-1-2-3, ¿también negativos permitidos / no permitidos?

— Urna mágica del pulpo

Caso de prueba sugerido: [1,3,3](asegura que las respuestas que usan el algoritmo de Dennis tomen el signo de los incrementos en lugar de solo usar los incrementos mismos)

— ETHproductions

1

@ETHproductions ¿No está eso ya cubierto [1,2,2]? ¿O me estoy perdiendo algo?

— Financia la demanda de Mónica el

2

@NicHartley, los deltas de [1,2,2]son los mismos que los signos de esos deltas, pero ese no es el caso [1,3,3].

— Shaggy

Respuestas:

15

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.

— Dennis
fuente

1

¿Qué es "incrementos"? ¿Qué se está incrementando y qué hace eso?

— Wheat Wizard

1

@WheatWizard Creo que este es el equivalente del comando deltas (¥) de 05AB1E: se ordena una matriz [n0, n1, n2, n3] y se empuja la matriz [n1-n0, n2-n1, n3-n2].

— Kaldo

10

JavaScript (ES6), 38 bytes

Devuelve un booleano.

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

Casos de prueba

Mostrar fragmento de código

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

Expandir fragmento

¿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.

— Arnauld
fuente

Esto arrojará en modo estricto.

— Aluan Haddad

2

@AluanHaddad Bueno, el 99% del código de golf de JS se lanzará en modo estricto solo por variables no declaradas. PPCG y codereview no se mezclan bien. : P

— Arnauld

Eso es justo, no soy muy aficionado al golf.

— Aluan Haddad

44

Entonces, ¿por comentario en él lol

— Mark C.

8

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.

— Asistente de trigo
fuente

¡Buena manera de lidiar con la lista vacía!

— Laikoni

6

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!

— Dennis
fuente

5

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.

— Luis Mendo
fuente

0||prod(...)ahorra 2 bytes. También puede omitir toda la anyparte y utilizar la definición de verdad / falsedad predeterminada para guardar 5 bytes .

— Stewie Griffin

Maldición, guardar 5 bytes hará que su solución sea más corta que la mía :( Buen uso del paquete de imágenes. No sabía que estaba en TIO.

— Stewie Griffin

1

@StewieGriffin Dado que el desafío requiere dos valores consistentes que no puedo eliminar any. Gracias por la 0||idea!

— Luis Mendo

4

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)

— plannapus
fuente

1

¡ordenado! Nota para uno mismo: recordar embedexiste. Es una lástima que rowProdsy colProdsno existe como alias en R.

— Giuseppe

1

@Giuseppe por desesperación, realmente verifiqué si existían :) pero de hecho solo rowSumsy rowMeans...

— plannapus

1

bueno, al menos mirando a través de los documentos, .colSumsrediseñará la entrada en una matriz basada en entradas adicionales que probablemente tenga una aplicación de golf en algún lugar ... ¡ahora solo tengo que encontrar una!

— Giuseppe

@Guiseppe: Eche un vistazo a las funciones en el matrixStatspaquete.

— Michael M

@MichaelM Desafortunadamente, debido a la longitud del nombre del paquete, no lo hace competitivo (57 bytes:) function(x)any(matrixStats::colProds(embed(diff(x),2)))<0. Pero para cualquier cosa que no sea golf de código, este paquete es de hecho un tesoro.

— plannapus

4

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.

— totalmente humano
fuente

l`zip3`tail l$drop 2lEs solo un pelo más corto. Me pregunto si la coincidencia de patrones es de alguna manera aún más corta.

— Lynn

3

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.

— Sean
fuente

3

Wolfram Language (Mathematica) , 40 bytes

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

Pruébalo en línea!

— alephalpha
fuente

3

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
    }
}

— benj2240
fuente

1

Yo creo que se puede utilizar |en lugar de ||, ahorrándole 1 byte.

— Yytsi

46 bytes

— Cristian Lupascu

Ahorre 1 byte con '0 <(yx) * y- = z'

— GB

3

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)

— Evan Carroll
fuente

Hola y bienvenidos al sitio. No estoy familiarizado con PostgreSQL, pero es posible que pueda reducir la cantidad de espacios en blanco que usa. En general, la mayoría de los idiomas no requieren la mayoría de los tipos de espaciado que usa.

— Wheat Wizard

@WheatWizard son los datos de muestra en la base de datos, es irrelevante.

— Evan Carroll

¿Cuál es tu código entonces? No permitimos que la entrada se inserte directamente en el código en lugar de la entrada. Si ese es el caso aquí, debe reescribirlo para que reciba información a través de un método estándar .

— Wheat Wizard

@WheatWizard desde el enlace que proporcionó, codegolf.meta.stackexchange.com/a/5341/23085

— Evan Carroll

1

Ok, si ese es el formato de entrada que está utilizando, está bien entonces. La mejor de las suertes jugando al golf aquí, es agradable ver a personas jugando al golf en los idiomas menos utilizados.

— Wheat Wizard

3

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.

— Kevin Cruijssen
fuente

1

84 bytes . Cambié el orden de iteración (bajando), cambié los dos operandos de multiplicación y luego pude eliminar uno superfluo -1.

— Olivier Grégoire

1

79 bytes: a->{int i=a.length;for(;i-->2;)i|=(a[i]-a[--i])*(a[i]-a[i-1])>>-1;return-~i|3;}(devuelve -1para casos verdaderos, 3para casos de falsey) - o, si se usa la presencia / ausencia de una excepción como valor de retorno 55 bytes:a->{for(int i=0;++i>0;)i|=(a[i-1]-a[i])*(a[i]-a[i+1]);}

— Nevay

1

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

— Nevay

3

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

— NofP
fuente

3

Puede deshacerse de las llaves {}por -2 bytes.

— Giuseppe

Además, creo que puede portar el enfoque de Stewie Griffin para 42 bytes

— Giuseppe

@Giuseppe, creo que Stewie portó mi método, con la diferencia de que el mío puede manejar adecuadamente el vector vacío como se indica en los casos de prueba. Matlab es un poco más indulgente con los vectores vacíos en comparación con R.

— NofP

c()es lo NULLque no es lo mismo que el vector vacío de enteros, integer(0)mientras que en MATLAB []es un doublevalor predeterminado, pero si desea mantenerlo de esta manera, eso es perfectamente razonable.

— Giuseppe

3

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!

— Galen Ivanov
fuente

Hola ! ¿No podría acortarse a esta forma explícita más simple 0> <./ 2 * / \ 2 - / \ (13 bytes)?

— Mathias Dolidon

@Mathias Dolidon Esto funciona en el intérprete, pero aquí en PPCG es común proporcionar una función (verbo J) si hay alguna entrada. Si el verbo es tácito, no contamos los f=.bytes de asignación . Tenga en cuenta que soy un usuario relativamente nuevo :)

— Galen Ivanov

Yo también, y me has aclarado la regla. Gracias ! :)

— Mathias Dolidon

1

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

— FrownyFrog

@ FrownyFrog Gracias! Parece que rara vez uso e. :)

— Galen Ivanov

2

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

— Oliver
fuente

2

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.

— ETHproducciones
fuente

2

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.

— Conor O'Brien
fuente

2

MATL , 8 bytes

dZSd|1>a

Pruébalo en línea!

— Stewie Griffin
fuente

2

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

— Zgarb
fuente

2

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

— Stewie Griffin
fuente

2

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

— Fatalizar
fuente

2

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

— Emigna
fuente

¿No había una alternativa de 1 byte 0‹que básicamente verifique el número para un signo negativo?

— Urna mágica del pulpo

@MagicOctopusUrn: d usa para verificar que la parte superior de la pila solo contenga [0-9], que es lo opuesto a lo que queremos aquí. Pero ahora es más inteligente y los negativos / flotantes también se cuentan como números.

— Emigna

Ahhhh ... podría haber jurado aver el negativeletrero y volver verdadero o algo así ... Pero creo que tienes razón, recuerdo tu dtruco.

— Urna mágica del pulpo

2

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

— sundar - Restablecer a Monica
fuente

1

Casco , 9 bytes

▼mεẊ-Ẋo±-

Pruébalo en línea!

Utiliza el algoritmo de Dennis.

— Erik el Outgolfer
fuente

1

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

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

Pruébalo en línea!

— Xcali
fuente

1

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!

— totalmente humano
fuente

1

58 bytes usando multiplicación en su lugar

— Shieru Asakoto

1

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

— mudkip201
fuente

1

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!

— Kelly Lowder
fuente

1

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"

— Ton Hospel
fuente

1

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!

— gggg
fuente

1

parece que el espacio después forno es necesario;)

— Shieru Asakoto

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.

Licensed under cc by-sa 3.0 with attribution required.