Dato un elenco di numeri interi positivi, determinare se esiste un elemento maggiore dei suoi due vicini o inferiore ai suoi due vicini (un "bump"). Per essere chiari un bump non può mai essere il primo o l'ultimo elemento dell'elenco perché hanno un solo vicino.

Il tuo programma dovrebbe generare uno di due valori coerenti, ciascuno corrispondente a un elenco senza dossi o a un elenco con dossi. Quali siano i valori non è importante che tu possa sceglierli tu stesso.

Questo è code-golf, quindi le risposte verranno classificate in byte con un numero inferiore di byte migliori.

Casi test

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

— Mago del grano
fonte

5

Test Case Request: numeri diversi da 0-1-2-3, anche i negativi sono ammessi / non ammessi?

— Magic Octopus Urn

Caso di prova suggerito: [1,3,3](assicura che le risposte usando l'algoritmo di Dennis prendano il segno degli incrementi piuttosto che usare semplicemente gli incrementi stessi)

— ETHproductions

1

@ETHproductions Non è già coperto da [1,2,2]? Oppure mi sfugge qualcosa?

— Finanzia la causa di Monica il

2

@NicHartley, i delta di [1,2,2]sono gli stessi dei segni di quei delta, ma non è così [1,3,3].

— Shaggy,

15

Gelatina , 5 byte

IṠIỊẠ

Restituisce 0 se c'è un bump, 1 in caso contrario.

Provalo online!

Come funziona

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
fonte

1

Che cos'è "Incrementi?". Cosa viene incrementato e cosa fa?

— Wheat Wizard

1

@WheatWizard Penso che questo sia l'equivalente del comando delta (¥) di 05AB1E: viene popolato un array [n0, n1, n2, n3] e viene spinto l'array [n1-n0, n2-n1, n3-n2].

— Kaldo,

10

JavaScript (ES6), 38 byte

Restituisce un valore booleano.

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

Casi test

Mostra snippet di codice

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

Expand snippet

Come?

Usiamo a per memorizzare il valore precedente di n . Impostiamo x su 1 se a <n , -1 se a> n o 0 se a = n . E testiamo se old_x * x <0 , che è possibile solo se ( old_x = 1 e x = -1 ) o ( old_x = -1 e x = 1 ).

Poiché x è inizializzato nella funzione di callback anonimo di some () , è costretto a NaN durante la prima iterazione, il che rende falsa la verifica.

— Arnauld
fonte

Questo lancerà in modalità rigorosa.

— Aluan Haddad,

2

@AluanHaddad Bene, il 99% del codice golfizzato da JS verrà lanciato in modalità rigorosa solo a causa di variabili non dichiarate. PPCG e codereview non si mescolano bene. : P

— Arnauld,

È giusto, non sono molto per il golf.

— Aluan Haddad,

4

Allora perché commentarlo lol

— Mark C.

8

Haskell , 42 byte

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

Provalo online!

Spiegazione

Innanzitutto abbiamo la funzione fche accetta una funzione binaria e un elenco e applica la funzione binaria a ogni coppia adiacente nell'elenco.

Quindi la nostra funzione principale si applica f(-)all'elenco di input. Questo calcola l'elenco delle differenze. Quindi applichiamo f(*)all'elenco per moltiplicare ogni coppia adiacente. Infine chiediamo se qualsiasi coppia è inferiore a zero.

Un numero nell'elenco finale può essere negativo solo se è il prodotto di un numero negativo e positivo dall'elenco differenze. Pertanto, al fine di produrre una voce negativa (e quindi restituire vero) l'elenco originale deve passare da crescente a decrescente o viceversa, ovvero deve avere un bump.

— Mago del grano
fonte

Bel modo di gestire la lista vuota!

— Laikoni,

6

Python 2 , 43 byte

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

Restituisce True se c'è un bump, errori se non c'è. ( consentito per impostazione predefinita )

Provalo online!

— Dennis
fonte

5

Ottava con pacchetto immagini, 34 32 byte

2 byte salvati grazie a @StewieGriffin !

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

Provalo online!

Spiegazione

Calcola le differenze consecutive, le dispone in blocchi scorrevoli di lunghezza 2, ottiene il prodotto di ciascun blocco e verifica se tale prodotto è negativo.

— Luis Mendo
fonte

0||prod(...)salva 2 byte. È inoltre possibile saltare l'intera anyparte e utilizzare la definizione di verità / falsa predefinita per salvare 5 byte .

— Stewie Griffin,

Accidenti, il salvataggio di 5 byte renderà la tua soluzione più breve della mia :( Ottimo uso del pacchetto di immagini. Non sapevo che fosse su TIO.

— Stewie Griffin,

1

@StewieGriffin Poiché la sfida richiede due valori coerenti, non posso rimuoverli any. Grazie per l' 0||idea!

— Luis Mendo,

4

R, 48 byte

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

Provalo online!

Come funziona passo per passo usando c (1,4,1,4) come esempio:

> 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

Come bonus, ecco una soluzione di lunghezza e concetto simili usando il pacchetto zoo:

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

— plannapus
fonte

1

! pulito Nota per sé: ricordare embedesiste. E 'un peccato che rowProdse colProdsnon esiste come alias a R.

— Giuseppe

1

@Giuseppe per disperazione ho effettivamente verificato se esistessero :) ma in effetti solo rowSumse rowMeans...

— plannapus,

1

beh, almeno guardando i documenti, .colSumsrimodelleremo l'input in una matrice basata su input aggiuntivi che probabilmente ha un'applicazione da golf da qualche parte .... ora devo solo trovarne uno!

— Giuseppe,

@Guiseppe: dai un'occhiata alle funzioni nel matrixStatspacchetto.

— Michael M,

@MichaelM Sfortunatamente a causa della lunghezza del nome del pacchetto non lo rende competitivo (57 byte:) function(x)any(matrixStats::colProds(embed(diff(x),2)))<0. Ma per qualsiasi cosa diversa dal code golf, questo pacchetto è davvero un tesoro.

— plannapus,

4

Haskell , 33 byte

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

Provalo online!

True se c'è un dosso, errori se non c'è.

— totallyhuman
fonte

l`zip3`tail l$drop 2lè solo un pelo più corto. Mi chiedo se il pattern matching sia in qualche modo ancora più breve?

— Lynn,

3

Perl 6 , 39 byte

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

Provalo online!

$_è l'argomento elenco di questa funzione anonima. .[1..*]è lo stesso elenco, ma con il primo elemento eliminato. Zcmpcomprime le due liste insieme cmpall'operatore, risultando in una lista di Ordervalori. Ad esempio, per un elenco di input 1, 2, 2, 2, 1ciò comporterebbe l'elenco More, Same, Same, Less.

Ora dobbiamo solo sapere se quell'elenco contiene due elementi adiacenti More, Lesso Less, More. Il trucco che ho usato è di convertire l'elenco in una stringa delimitata da spazi ~, quindi verificare se contiene sottostringa re Lo s M. (Il primo non può essere giustoe L perché Sametermina anche con una "e".)

L'operatore di corrispondenza intelligente restituisce un Matchoggetto (se la corrispondenza ha avuto esito positivo) o Nil(in caso contrario), quindi soconverte qualsiasi valore in un valore booleano.

— Sean
fonte

3

Wolfram Language (Mathematica) , 40 byte

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

Provalo online!

— alephalpha
fonte

3

Ruby , 55 46 byte

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

Provalo online!

Un lambda che accetta un array e ritorna booleano.

-9 byte: sostituisci (x<y&&y>z)||(x>y&&y<z)con (y-x)*(y-z)>0(grazie 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
fonte

1

Io credo che si può usare |al posto di ||, risparmiando 1 byte.

— Yytsi,

46 byte

— Cristian Lupascu,

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

— GB

3

PostgreSQL 173 byte

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
fonte

Ciao e benvenuto nel sito. Non ho familiarità con PostgreSQL ma potresti essere in grado di ridurre la quantità di spazi bianchi che usi. In generale la maggior parte delle lingue non richiede la maggior parte dei tipi di spaziatura che usi.

— Wheat Wizard

@WheatWizard sono i dati di esempio nel database, è irrilevante.

— Evan Carroll,

Qual è il tuo codice allora? Non consentiamo che l'input venga inserito direttamente nel codice anziché nell'input. Se questo è il caso, dovresti riscriverlo in modo che richieda input tramite un metodo standard .

— Wheat Wizard

@WheatWizard dal link che hai fornito, codegolf.meta.stackexchange.com/a/5341/23085

— Evan Carroll

1

Ok se questo è il formato di input che stai usando va bene allora. Buona fortuna a giocare a golf qui, è bello vedere le persone giocare a golf in lingue meno comunemente usate.

— Wheat Wizard

3

Java 8, 108 104 101 86 84 79 72 byte

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

-2 byte grazie a @ OlivierGrégoire .
-13 byte grazie a @Nevay .

Provalo online.

— Kevin Cruijssen
fonte

1

84 byte . Ho cambiato l'ordine di iterazione (scendendo), ho scambiato i due operandi di moltiplicazione e quindi ho potuto rimuovere un superfluo -1.

— Olivier Grégoire,

1

79 byte: a->{int i=a.length;for(;i-->2;)i|=(a[i]-a[--i])*(a[i]-a[i-1])>>-1;return-~i|3;}(ritorna -1per casi veritieri, 3per casi falsi) - oppure, se si utilizza la presenza / assenza di un'eccezione come valore di ritorno 55 byte:a->{for(int i=0;++i>0;)i|=(a[i-1]-a[i])*(a[i]-a[i+1]);}

— Nevay

1

72 byte: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 byte

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

Provalo online!

Salvato 2 byte grazie a Giuseppe

— NOFP
fonte

3

È possibile eliminare le parentesi graffe {}per -2 byte.

— Giuseppe,

additionally, I think that you can port Stewie Griffin's approach for 42 bytes

— Giuseppe

@Giuseppe, I think Stewie ported my method, with the difference that mine can properly handle the empty vector as listed in the test cases. Matlab is a bit more lenient with empty vectors compared to R.

— NofP

c() is NULL which is not the same as the empty vector of integers, integer(0), whereas in MATLAB [] is a double by default, but if you want to keep it this way, that's perfectly reasonable.

— Giuseppe

3

J, 16 15 bytes

-1 byte thanks to FrownyFrog

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

C'è un dosso?

Casi test

Gelatina , 5 byte

Come funziona

JavaScript (ES6), 38 byte

Casi test

Come?

Haskell , 42 byte

Spiegazione

Python 2 , 43 byte

Ottava con pacchetto immagini, 34 32 byte

Spiegazione

R, 48 byte

Haskell , 33 byte

Perl 6 , 39 byte

Wolfram Language (Mathematica) , 40 byte

Ruby , 55 46 byte

PostgreSQL 173 byte

Java 8, 108 104 101 86 84 79 72 byte

R , 58 56 byte

J, 16 15 bytes

Original: 16 bytes

Japt, 11 bytes

Japt, 9 bytes

Attache, 39 bytes

Explanation

MATL, 8 bytes

Husk, 7 bytes

Explanation

Octave, 33 bytes

Explanation:

Brachylog, 10 bytes

Explanation

05AB1E, 7 bytes

Brachylog, 10 bytes

Husk, 9 bytes

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

Python 2, 60 bytes

Python 2, 63 bytes

Pyt, 11 7 bytes

Old way (11 bytes):

Wolfram Language (Mathematica), 37 36 bytes

Perl, 35 bytes

Julia 0.6, 57 56 bytes

Julia 0.6, 39 bytes

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