Bestimmen Sie anhand einer Liste positiver Ganzzahlen, ob es ein Element gibt, das entweder größer als seine zwei Nachbarn oder kleiner als seine zwei Nachbarn ist (ein "Stoß"). Um klar zu sein, kann eine Erhebung niemals das erste oder letzte Element der Liste sein, da sie nur einen Nachbarn hat.

Ihr Programm sollte einen von zwei konsistenten Werten ausgeben, die entweder einer Liste ohne Unebenheiten oder einer Liste mit Unebenheiten entsprechen. Was die Werte sind, ist unwichtig. Sie können sie selbst auswählen.

Dies ist Codegolf, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes besser sind.

Testfälle

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

Gelee , 5 Bytes

IṠIỊẠ

Gibt 0 zurück, wenn eine Unebenheit vorliegt, 1, wenn nicht.

Probieren Sie es online!

Wie es funktioniert

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 Byte

Gibt einen Booleschen Wert zurück.

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

Testfälle

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

Wie?

Wir verwenden a , um den vorherigen Wert von n zu speichern . Wir setzen x auf 1, wenn a <n , -1, wenn a> n oder 0, wenn a = n . Und wir testen, ob old_x * x <0 ist , was nur möglich ist, wenn ( old_x = 1 und x = -1 ) oder ( old_x = -1 und x = 1 ).

Da x mit der anonymen Rückruffunktion von some () initialisiert wird , wird es während der ersten Iteration zu NaN gezwungen , wodurch der Test falsch wird.

Haskell , 42 Bytes

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

Probieren Sie es online!

Erläuterung

Zuerst haben wir die Funktion f, die eine Binärfunktion und eine Liste annimmt und die Binärfunktion auf jedes benachbarte Paar in der Liste anwendet.

Dann gilt unsere Hauptfunktion für f(-)die Eingabeliste. Dies berechnet die Differenzliste. Wir wenden dann f(*)auf die Liste an, um jedes benachbarte Paar zu multiplizieren. Zuletzt fragen wir, ob ein Paar kleiner als Null ist.

Eine Zahl in der Endeliste kann nur negativ sein, wenn sie das Produkt einer negativen und positiven Zahl aus der Differenzliste ist. Um also einen negativen Eintrag zu erzeugen (und dann true zurückzugeben), muss die ursprüngliche Liste von aufsteigend auf absteigend umgeschaltet werden oder umgekehrt, das heißt, sie muss eine Unebenheit aufweisen.

Python 2 , 43 Bytes

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

Gibt True zurück, wenn es eine Beule gibt, Fehler, wenn es keine gibt. ( standardmäßig erlaubt )

Probieren Sie es online!

Oktave mit Bildpaket, 34 32 Bytes

2 Bytes gespart dank @StewieGriffin !

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

Probieren Sie es online!

Erläuterung

Berechnet aufeinanderfolgende Differenzen, ordnet sie in Gleitblöcken der Länge 2 an, ermittelt das Produkt jedes Blocks und prüft, ob ein solches Produkt negativ ist.

R, 48 Bytes

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

Probieren Sie es online!

So geht es Schritt für Schritt am Beispiel von c (1,4,1,4):

> 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

Als Bonus gibt es hier eine Lösung von ähnlicher Länge und Konzept mit Paket 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

Probieren Sie es online!

True Wenn es eine Beule gibt, Fehler, wenn es keine gibt.

Perl 6 , 39 Bytes

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

Probieren Sie es online!

$_ist das Listenargument für diese anonyme Funktion. .[1..*]ist die gleiche Liste, aber mit dem ersten Element gelöscht. ZcmpZippt die beiden Listen zusammen mit dem cmpOperator, wodurch eine Liste mit OrderWerten erstellt wird. Bei einer Eingabeliste 1, 2, 2, 2, 1würde dies beispielsweise zu einer Liste führen More, Same, Same, Less.

Jetzt müssen wir nur noch wissen, ob diese Liste zwei benachbarte Elemente enthält More, Lessoder Less, More. Der Trick, den ich verwendet habe, besteht darin, die Liste mit in eine durch Leerzeichen getrennte Zeichenfolge zu konvertieren ~und dann zu testen, ob sie entweder eine Teilzeichenfolge re Loder eine Teilzeichenfolge enthält s M. (Das erste kann nicht nur sein, e Lweil es Sameauch mit einem "e" endet.)

Der Operator für intelligente Übereinstimmungen gibt entweder ein MatchObjekt zurück (wenn die Übereinstimmung erfolgreich war) oder Nil(wenn dies nicht soder Fall war). Er konvertiert also alles , was es ist, in einen booleschen Wert.

Wolfram Language (Mathematica) , 40 Byte

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

Probieren Sie es online!

Ruby , 55 46 Bytes

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

Probieren Sie es online!

Ein Lambda, das ein Array akzeptiert und einen Booleschen Wert zurückgibt.

-9 Bytes: Ersetzen (x<y&&y>z)||(x>y&&y<z)durch (y-x)*(y-z)>0(dank 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 dank @ OlivierGrégoire .
-13 Bytes dank @Nevay .

Probieren Sie es online aus.

R , 58 56 Bytes

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

Probieren Sie es online!

2 Bytes dank Giuseppe gespeichert

J , 16-15 Bytes

-1 Byte dank FrownyFrog

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

Probieren Sie es online!

Original: 16 Bytes

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

2-/\] - Unterschiede der jeweils benachbarten Gegenstände

2*/\ - Produkte der jeweils angrenzenden Artikel

[:<./ - das Minimum

0> - ist negativ?

Probieren Sie es online!

Japt , 11 Bytes

-5 Bytes dank @ETHproductions

ä- mÌäa d>1

Probieren Sie es online! | Testfälle

Dies verwendet Dennis ' Algorithmus

Japt , 9 Bytes

ä- ä* d<0

Probieren Sie es online!

Ein Mashup von Olivers Antwort mit dem Ansatz mehrerer anderer Antworten.

Attache , 39 Bytes

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

Probieren Sie es online!

Ziemlich zufrieden damit, wie sich das herausstellte.

Erläuterung

Dies ist eine Zusammensetzung von vier Funktionen:

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

DeltaRuft die Unterschiede zwischen Elementen ab. =

Dann Signwird auf jeden Unterschied angewendet, wodurch wir ein Array von 1s, 0s und -1s erhalten. =

Slices&2Geben Sie dann alle Slices der Länge zwei aus dem Array an und geben Sie alle Differenzenpaare an.

Schließlich Any&:&{_*~?Sum[__]}ist äquivalent zu, für die Eingabe x:

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

Dies sucht nach Elementen, die sich zu Null summieren, aber nicht Null sind. Wenn ein solches Elementpaar existiert, gibt es eine Unebenheit.

MATL , 8 Bytes

dZSd|1>a

Probieren Sie es online!

Schale , 7 Bytes

V<0Ẋ*Ẋ-

Probieren Sie es online!

Erläuterung

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

Oktave , 33 Bytes

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

Probieren Sie es online!

Erläuterung:

@(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₃.¬≤₁∧¬≥₁

Probieren Sie es online!

Erfolgreich ( true.), wenn es eine Beule gibt, und fehlgeschlagen ( ), wenn es false.keine Beule gibt.

Erläuterung

Das ist schon ziemlich lesbar:

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

05AB1E , 7 Bytes

¥ü‚P0‹Z

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Nicht annähernd so ordentlich und elegant wie die 10-Byte-Antwort von @ Fatalize, aber es funktioniert!

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

Schale , 9 Bytes

▼mεẊ-Ẋo±-

Probieren Sie es online!

Verwendet Dennis 'Algorithmus.

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

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

Probieren Sie es 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:]))

Probieren Sie es online!

Ziemlich das Gleiche, dachte es wäre allerdings kürzer ...

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

Probieren Sie es online!

Pyt , 11 7 Bytes

₋ʁ*0<Ʃ±

Gibt 1 aus, wenn eine Erhebung vorliegt, andernfalls 0

Probieren Sie es online!

Port of Wheat Wizard's Haskell Antwort

Alter Weg (11 Bytes):

₋±₋Å1≤ĐŁ↔Ʃ=

Probieren Sie es online!

Gibt False zurück, wenn eine Unebenheit vorliegt, andernfalls True

Port of Dennis 'Jelly Antwort

Wolfram Language (Mathematica) , 37-36 Bytes

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

Gibt das Gegenteil der Testfallantworten (Falsch und Richtig umgekehrt). Stellen Sie a voran !, um zur normalen Form zu wechseln.

ODER

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

Auch umgekehrt Ausgang, so ersetzen FreeQmit MatchQfür Normalform.

Erklärung: Nehmen Sie das Vorzeichen der Unterschiede der Reihenfolge. Wenn die resultierende Sequenz {1, -1} oder {-1,1} enthält, gibt es eine Unebenheit. Der absolute Wert der Differenzen von {1, -1} oder {-1,1} ist in beiden Fällen 2.

Rasiere ein weiteres Byte ab, indem du die endgültige Liste quadrierst, anstatt den absoluten Wert zu nehmen:

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

Probieren Sie es online!

Perl, 35 Bytes

Beinhaltet +3für-p

bump.pl:

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

Rennen wie:

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

Grundsätzlich nur totalhumans Python Antwort. -1 Byte von user71546

Probieren Sie es online!

Julia 0,6 , 39 Bytes

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

Lispy-Rekursionsstil, alias Dennis 'Python-Antwort. Gibt zurück, truewenn eine Beule vorhanden ist, andernfalls wird ein Fehler ausgegeben. Das sollten vielleicht 42 Bytes sein, da Sie es beim Aufruf aufteilen müssen. ZB für a=[1,2,1]dich als anrufen f(a...). f(a)=f(a...)würde diesen Bedarf beseitigen, ist aber länger. Ich muss eine Rekursion verbessern, und ich mag es nicht wirklich, Code zu schreiben, der einen Fehler auslöst.

Probieren Sie es online!