Y a-t-il une bosse?

39

À partir d’une liste d’entiers positifs, il faut déterminer s’il existe un élément supérieur ou égal à ses deux voisins ou inférieur à ses deux voisins (un "sursaut"). Pour être clair, une bosse ne peut jamais être le premier ou le dernier élément de la liste car ils n'ont qu'un seul voisin.

Votre programme doit générer l'une des deux valeurs cohérentes correspondant chacune à une liste sans relief ou à une liste avec relief. Quelles que soient les valeurs n'a pas d'importance, vous pouvez les choisir vous-même.

C'est du code-golf donc les réponses seront notées en octets, moins d'octets étant meilleurs.

Cas de 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
code-golf  number  array-manipulation  decision-problem 
— Assistant de blé
source
5
Demande de test: numéros autres que 0-1-2-3, également négatifs autorisés / interdits?
— Urne Magic Octopus
Cas de test suggéré: [1,3,3](s'assure que les réponses utilisant l'algorithme de Dennis prennent le signe des incréments plutôt que d'utiliser simplement les incréments eux-mêmes)
— ETHproductions
1
@ETHproductions N'est-ce pas déjà couvert par [1,2,2]? Ou est-ce que je manque quelque chose?
— Le procès de Monica
2
@NicHartley, les deltas de [1,2,2]sont les mêmes que les signes de ces deltas mais ce n'est pas le cas avec [1,3,3].
— Shaggy

Réponses:

15

Gelée , 5 octets

IṠIỊẠ

Renvoie 0 s'il y a une bosse, 1 sinon.

Essayez-le en ligne!

Comment ça marche

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
source
1
Qu'est-ce que "Incréments?". Qu'est-ce qui est incrémenté et qu'est-ce que cela fait?
— Wheat Wizard
1
@WheatWizard Je pense que ceci est l'équivalent de la commande deltas (¥) de 05AB1E: un tableau [n0, n1, n2, n3] est affiché et le tableau [n1-n0, n2-n1, n3-n2] est poussé.
— Kaldo
10

JavaScript (ES6), 38 octets

Retourne un booléen.

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

Cas de test

Afficher l'extrait de code

Comment?

Nous utilisons a pour stocker la valeur précédente de n . Nous fixons x à 1 si a <n , -1 si a> n ou 0 si a = n . Et nous testons si old_x * x <0 , ce qui n’est possible que si ( old_x = 1 et x = -1 ) ou ( old_x = -1 et x = 1 ).

Puisque x est initialisé à la fonction de rappel anonyme de some () , il est forcé à NaN lors de la première itération, ce qui rend le test faux.

— Arnauld
source
Cela jettera en mode strict.
— Aluan Haddad
2
@AluanHaddad Eh bien, 99% du code golfé de JS jettera en mode strict uniquement à cause de variables non déclarées. PPCG et codereview ne font pas bon ménage. : P
— Arnauld
C'est juste, je ne suis pas trop pour le golf.
— Aluan Haddad
4
Alors pourquoi le commenter lol
— Mark C.
8

Haskell , 42 octets

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

Essayez-le en ligne!

Explication

Nous avons d’abord la fonction fqui prend une fonction binaire et une liste et applique la fonction binaire à chaque paire adjacente de la liste.

Ensuite, notre fonction principale s'applique f(-)à la liste de saisie. Ceci calcule la liste de différence. Nous appliquons ensuite f(*)à la liste pour multiplier chaque paire adjacente. Enfin, nous demandons si une paire est inférieure à zéro.

Un nombre dans la liste de fin ne peut être négatif que s'il est le produit d'un nombre négatif et positif de la liste de différences. Ainsi, pour produire une entrée négative (puis renvoyer true), la liste d'origine doit passer de croissant à décroissant ou inversement, c’est-à-dire qu’elle doit présenter une bosse.

— Assistant de blé
source
Belle façon de gérer la liste vide!
— Laikoni
5

Octave avec paquet d'images, 34 32 octets

2 octets sauvés grâce à @StewieGriffin !

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

Essayez-le en ligne!

Explication

Calcule les différences consécutives, les arrange en blocs coulissants de longueur 2, obtient le produit de chaque bloc et teste si un tel produit est négatif.

— Luis Mendo
source
0||prod(...)enregistre 2 octets. Vous pouvez également ignorer la totalité de la anypartie et utiliser la définition par défaut vérité / fausseté pour économiser 5 octets .
— Stewie Griffin
Bon sang, économiser 5 octets fera que votre solution sera plus courte que la mienne :( Belle utilisation du paquet d’image. Je ne savais pas que c’était sur TIO.
— Stewie Griffin
1
@StewieGriffin Étant donné que le défi nécessite deux valeurs cohérentes, je ne peux pas les supprimer any. Merci pour l' 0||idée!
— Luis Mendo
4

R, 48 octets

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

Essayez-le en ligne!

Comment cela fonctionne pas à pas en utilisant c (1,4,1,4) comme exemple:

> 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

En prime, voici une solution de longueur et de concept similaires utilisant le package zoo:

function(x)any(zoo::rollapply(diff(x),2,prod)<0)
— planificateur
source
1
soigné! Note to self: se souvenir embedexiste. C'est dommage rowProdset colProdsn'existe pas comme alias dans R.
— Giuseppe
1
@ Giuseppe en désespoir de cause, j’ai vérifié s’ils existaient :) mais en fait, juste rowSumset rowMeans...
— planifié le
1
Eh bien, au moins, à travers la documentation, vous .colSumsallez réorganiser les entrées dans une matrice basée sur des entrées supplémentaires qui a probablement une application de golf quelque part ... maintenant, je dois juste en trouver une!
— Giuseppe
@Guiseppe: Regardez les fonctions du matrixStatspaquet.
— Michael M
@MichaelM Malheureusement, en raison de la longueur du nom du paquet, cela ne le rend pas compétitif (57 octets:) function(x)any(matrixStats::colProds(embed(diff(x),2)))<0. Mais pour quelque chose d'autre que le code golf, ce paquet est vraiment un trésor.
— Plannapus
4

Haskell , 33 octets

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

Essayez-le en ligne!

True s'il y a une bosse, des erreurs s'il n'y en a pas.

— totalement humain
source
l`zip3`tail l$drop 2lest juste un cheveu plus court. Je me demande si la correspondance des modèles est encore plus courte?
— Lynn
3

Perl 6 , 39 octets

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

Essayez-le en ligne!

$_est l'argument de liste de cette fonction anonyme. .[1..*]est la même liste, mais avec le premier élément supprimé. ZcmpZip les deux listes avec l' cmpopérateur, résultant en une liste de Ordervaleurs. Par exemple, pour une liste d'entrée, 1, 2, 2, 2, 1cela donnerait la liste More, Same, Same, Less.

Il suffit maintenant de savoir si cette liste contient deux éléments adjacents More, Lessou Less, More. L’astuce que j’ai utilisée est de convertir la liste en une chaîne délimitée par des espaces ~, puis de vérifier si elle contient une sous re L- chaîne ou une chaîne.s M . (Le premier ne peut pas être simplement e Lparce qu'il Samese termine également par un "e".)

L'opérateur de correspondance intelligente renvoie un Matchobjet (si la correspondance est réussie) ou Nil(si ce n'est pas le cas), il soconvertit donc ce qu'il est en valeur booléenne.

— Sean
source
3

Ruby , 55 46 octets

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

Essayez-le en ligne!

Un lambda acceptant un tableau et retournant un booléen.

-9 octets: remplacer (x<y&&y>z)||(x>y&&y<z)par (y-x)*(y-z)>0(merci à 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
source
1
Je pense que vous pouvez utiliser |au lieu de ||, vous économisant 1 octet.
— Yytsi
— Cristian Lupascu
Économisez 1 octet avec '0 <(yx) * y- = z'
— GB
3

PostgreSQL 173 octets

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
source
Bonjour et bienvenue sur le site. Je ne connais pas bien PostgreSQL, mais vous pourrez peut-être réduire la quantité d’espace que vous utilisez. En général, la plupart des langues n'exigent pas la plupart des types d'espacement que vous utilisez.
— Assistant de blé
@ WheatWizard, ce sont les exemples de données dans la base de données, ce n'est pas pertinent.
— Evan Carroll
Quel est ton code alors? Nous n'autorisons pas l'entrée à être insérée directement dans le code à la place de l'entrée. Si tel est le cas ici, vous devriez le réécrire pour qu'il prenne en entrée via une méthode standard .
— Wheat Wizard
@WheatWizard à partir du lien que vous avez fourni, codegolf.meta.stackexchange.com/a/5341/23085
— Evan Carroll
1
Ok, si c'est le format d'entrée que vous utilisez, c'est bien. Bonne chance au golf ici, il est agréable de voir des gens jouer dans des langues moins répandues.
— Wheat Wizard
3

Java 8, 108 104 101 86 84 79 72 octets

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

-2 octets grâce à @ OlivierGrégoire .
-13 octets grâce à @Nevay .

Essayez-le en ligne.

— Kevin Cruijssen
source
1
84 bytes. I changed the iteration order (going down), swapped the two multiplication operands and then could remove a superfluous -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;} (returns -1 for truthy cases, 3 for falsey cases) - or, if using the presence/absence of an exception as return value 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)

Try it online!

Saved 2 bytes thanks to Giuseppe

— NofP
source
3
You can get rid of the braces {} for -2 bytes.
— 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-/\]

Try it online!

Original: 16 bytes

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

2-/\] - differences of each adjacent items

2*/\ - products of each adjacent items

[:<./ - the minimum

0> - is negative?

Try it online!

— Galen Ivanov
source
Hello ! Could this not be shortened to this simpler explicit form 0><./2*/\2-/\ (13 bytes) ?
— Mathias Dolidon
@Mathias Dolidon This works in the interpreter but here in PPCG it's common to provide a function (J verb) if there is some input. If the verb is tacit one, we don't count the assignment f=. bytes. Please have in mind that I'm relatively new user :)
— Galen Ivanov
So am I, and you've clarified the rule for me. Thanks ! :)
— Mathias Dolidon
1
1 e.0>2*/\2-/\]
— FrownyFrog
@ FrownyFrog Thank you! It seems that I rarely use e. :)
— Galen Ivanov
2

Attache, 39 bytes

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

Try it online!

Pretty happy with how this turned out.

Explanation

This is a composition of four functions:

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

Delta gets the differences between elements. =

Then, Sign is applied to each difference, giving us an array of 1s, 0s, and -1s. =

Then, Slices&2 gives all slices of length two from the array, giving all pairs of differences.

Finally, Any&:&{_*~?Sum[__]} is equivalent to, for input x:

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

This searches for elements which sum to zero but are not zero. If any such pair of elements exist, then there is a bump.

— Conor O'Brien
source
2

Husk, 7 bytes

V<0Ẋ*Ẋ-

Try it online!

Explanation

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
source
2

Octave, 33 bytes

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

Try it online!

Explanation:

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

Brachylog, 10 bytes

s₃.¬≤₁∧¬≥₁

Try it online!

Succeeds (true.) if there is a bump, and fails (false.) if there is no bump.

Explanation

This is fairly readable already:

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

05AB1E, 7 bytes

¥ü‚P0‹Z

Try it online!

Explanation

¥         # 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
source
Wasn't there a 1-byte alternative to 0‹ that basically checks the number for a negative sign?
— Magic Octopus Urn
@MagicOctopusUrn: d used to check that top of stack only contained [0-9], which is the opposite of what we want here. But now it's more intelligent and negative/floats are also counted as numbers.
— Emigna
Ahhhh... coulda sworn a saw the negative sign and returned true or something... But I think you're right, I'm remembering your d trick.
— Magic Octopus Urn
2

Brachylog, 10 bytes

s₃s₂ᶠ-ᵐ×<0

Try it online!

Not nearly as neat and elegant as @Fatalize's existing 10 byte answer, but it works! 

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 - Reinstate Monica
source
1

Wolfram Language (Mathematica), 37 36 bytes

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

Gives the opposite of the test case answers (False and True reversed). Prepend a ! to switch to the normal form.

OR 

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

Also reversed output, so replace FreeQ with MatchQ for normal form.

Explanation: Take the sign of the differences of the sequence. Iff the resulting sequence includes {1,-1} or {-1,1} there is a bump. The absolute value the differences of {1,-1} or {-1,1} is 2 in either case.

Shave off another byte by squaring the final list instead of taking the absolute value:

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

Try it online!

— Kelly Lowder
source
1

Perl, 35 bytes

Includes +3 for -p

bump.pl:

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

Run as:

bump.pl <<< "3 1 2"
— Ton Hospel
source
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]))

Basically just totallyhuman's python answer. -1 byte from user71546

Try it online!

Julia 0.6, 39 bytes

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

Lispy recursion style, aka Dennis's python answer. Returns true when a bump exists, otherwise throws an error. This should maybe be 42 bytes since you have to splat it when calling. Eg for a=[1,2,1] you call as f(a...). f(a)=f(a...) would remove that need, but is longer. I need to get better a recursion, and I don't really like writing code that throws an error.

Try it online!

— gggg
source
1
seems the space after for is not necessary ;)
— Shieru Asakoto
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.