Geben Sie bei einem Array positiver Ganzzahlen ein Array aller Elemente aus, die größer oder gleich den benachbarten sind. Die meisten Elemente haben zwei benachbarte Elemente. Das erste und das letzte Element sind Sonderfälle, da sie nur ein benachbartes Element haben.

Sie können davon ausgehen, dass das Array mindestens zwei Elemente enthält.

Testfälle:

Input               | Output
[4,2,6,12,4,5,4,3]  | [4,12,5]
[1,2]               | [2]
[1,2,3,2,1]         | [3]
[3,2,1,2,3]         | [3,3]
[4,4]               | [4,4]
[2,4,4,4,1]         | [4,4,4]
[2,3,3,4]           | [3,4]
[4,3,3,4]           | [4,4]

Das ist Code-Golf , der kürzeste Code gewinnt!

Jelly ,  13 12  11 Bytes

0;;0»3\f"⁸Ẏ

Ein monadischer Link, der eine Liste positiver Ganzzahlen erstellt und die gefilterte Liste zurückgibt, die nur diejenigen enthält, die größer oder gleich allen Nachbarn sind.

Probieren Sie es online!

Vorherige 12 Byter :

0;INżI>0ḄNMị

Vorherige 13 Byter :

0;;0ṡ3M€ċ€2Tị

Wie?

0;;0»3\f"⁸Ẏ - Link: list of positive integers, A
0;          - a zero concatenated with A
  ;0        - concatenate a zero
     3\     - 3-wise reduce with:
    »       -   maximum (yields a list of the maximums in each overlapping window of 3)
         ⁸  - chain's left argument, A
        "   - zip with:
       f    -   filter keep (i.e. keep the maximal if it is [in] the [length 1 list 
            -                     of the] respective original element)
          Ẏ - flatten by one level

Python , 54 Bytes

f=lambda l,*p:l and l[:p<=l[:1]>=l[1:2]]+f(l[1:],l[0])

Probieren Sie es online!

I / O ist eher mit Tupeln als mit Listen.

Python , 57 Bytes

f=lambda l,p=0:l and l[:[p]<=l[:1]>=l[1:2]]+f(l[1:],l[0])

Probieren Sie es online!

Alt 57:

f=lambda l,p=0:l and l[l<[max(p,*l[:2])]:1]+f(l[1:],l[0])

Mathematica 22 Bytes

Pick[#,MaxDetect@#,1]&

Haskell, 50 49 42 Bytes

f l=[j|i:j:k:_<-scanr(:)[0]$0:l,k<=j,i<=j]

Probieren Sie es online!

scanr(:)[0]stellt eine Liste von den Schwänzen (0:l), die jeweils mit einem letzten 0, beispielsweise für l = [4,3,3,4]: [[0,4,3,3,4,0],[4,3,3,4,0],[3,3,4,0],[3,4,0],[4,0],[0]]die agains Muster abgestimmt ist , i:j:k:_alle Listen zu extrahieren , mit mindestens 3 Elementen , die genannt werden i, jund k. Behalten Sie, jwenn sein> = iund j.

Edit: Ørjan Johansen hat 7 Bytes gespeichert. Vielen Dank!

Dyalog APL, 31 30 28 22 21 Byte

{⍵/⍨(⌈/=2⌷⊢)¨3,/∊0⍵0}

Probieren Sie es online!

Erklärung (Ich kann Dinge nicht gut erklären):

0⍵0       - [0,input,0]   (it looks like a face!)
∊         - flatten
3,/       - split into overlapping sections of length 3.
(⌈/=2⌷⊢)¨ - Whether the middle element is the maximum (applied to every section)
⍵/⍨       - index

Haskell , 40 Bytes

p%(h:t)=[h|h>=p,[h+1]>t]++h%t
_%e=e
(0%)

Probieren Sie es online!

JavaScript (ES6), 40 Byte

a=>a.filter((e,i)=>!(e<a[i-1]|e<a[i+1]))

Python 3 , 84 75 * 71 Bytes

lambda l,k=[0]:[j for x,j in enumerate(l)if(k+l+k)[x+2]<=j>=(k+l+k)[x]]

Probieren Sie es online!

* @ LeakyNun sparte 9 Bytes mit einem cleveren Operator-Trick.

Gelee , 15 Bytes

2ị⁼Ṁ
0;;0ṡ3Ç€Tị

Probieren Sie es online!

05AB1E , 15  14  13 Bytes

ü‹0¸«sĆÁü›+_Ï

Probieren Sie es online!

Erläuterung

ü‹             # pairwise comparison for less than
  0¸«          # append 0
     s         # swap input to top of stack
      Ć        # enclose, append the head of the list
       Á       # rotate right
        ü›     # pairwise comparison for greater than
          +    # add the two boolean lists
           _   # logical negate
            Ï  # keep only elements of input that are true in the resulting list

Vorherige 15-Byte-Lösung

¬s¤)˜Œ3ùεZQ1è}Ï

Probieren Sie es online!

Erläuterung

¬                # get head of input
 s¤              # get tail of input
   )˜            # wrap stack in flattened list
                 # produces the input list with the first and last element duplicated
     Œ3ù         # push sublists of length 3
        ε        # apply transformation on each triple
         ZQ      # ... check each element for equality to the max
          1è     # ... get the middle element
            }    # end transform
             Ï   # keep only elements of input that are true in the resulting list

R, 44 Bytes

pryr::f(x[(x>=c(0,x)&x>=x[-1])[1:sum(x|1)]])

was zur Funktion auswertet:

function (x) 
x[(x >= c(0, x) & x >= x[-1])[1:sum(x | 1)]]

Verglichen xmit c(0,x), also mit xeiner Position nach rechts verschoben. Auch im Vergleich xzu x[-1], also eine Position nach links verschoben. Dies sind beide, TRUEwenn es dort ein Maximum gibt. &das UND dieser Booleschen zu nehmen. Wegen der Umhüllungsnatur der Vektoren von R, wenn sie nicht die gleiche Länge haben, müssen wir das Ergebnis um die Länge von kürzen x, die durch take ermittelt wird sum(x|1). Dann fügen wir den Booleschen Vektor ein, nehmen nur die wahren Indizes von xund geben diese zurück.

Da diese logischen Operationen mit Vektoren ungleicher Länge durchgeführt werden, wird sich R beschweren. Viel. Die korrekte Ausgabe wird jedoch inmitten der Warnungen angezeigt:

> pryr::f(x[(x>=c(0,x)&x>=x[-1])[1:sum(x|1)]])(c(4,2,6,12,4,5,4,3))
[1]  4 12  5
Warning messages:
1: In x >= c(0, x) :
  longer object length is not a multiple of shorter object length
2: In x >= x[-1] :
  longer object length is not a multiple of shorter object length
3: In x >= c(0, x) & x >= x[-1] :
  longer object length is not a multiple of shorter object length

R , 42 Bytes

function(x)x[c(d<-diff(x),0)<=0&c(0,d)>=0]

Probieren Sie es online!

2 Bytes kürzer als die JAD-Lösung . diffberechnet aufeinanderfolgende Differenzen; Bewahren Sie dann nur die Einträge auf, die größer als beide Nachbarn sind.

Pyth , 20 Bytes

-.b*YqYeSN.:++0Q03Q0

Golfen ...

Testsuite.

R , 68 Bytes

function(a)a[a==sapply(1:length(a),function(i)max(c(0,a,0)[i+0:2]))]

Probieren Sie es online!

PHP , 67 Bytes

for(;$g=$argv[+$i];$l=$g)$g<$l|$g<$argv[++$i]?:$r[]=$g;print_r($r);

Probieren Sie es online!

Netzhaut , 51 Bytes

\d+
$*
^

M!`(?<=(^|1+) )(\1\d*)\b(?! 1\2)
^¶

%`1

Probieren Sie es online aus

q, 39 Bytes

{x where x = -1 _ next 3 mmax x,last x}

Stax , 10 Bytes

úâH◄(☼bM•Å

Führen Sie es aus und debuggen Sie es

Die Ausgabe erfolgt als durch Zeilenumbrüche getrennte Werte in der Standardausgabe.

Ausgepackt, ungolfed und kommentiert sieht es so aus.

f       filter each value in input using the rest of the program; implicitly printing kept values
  x0|S  input pre- and post-pended with zero
  3B    split into batches of 3
  i@    get the i-th batch, where i is the iteration index
  |M=   is the current value equal to the max from the batch?

Führen Sie dieses aus

Aktualisiert: Ich habe gerade eine 9-Byte-Lösung gefunden. Wird die Erklärung später aktualisieren:

Stax , 9 Bytes

▀▓ûa¥╓╧↨⌐

Führen Sie es aus und debuggen Sie es

Perl 5 -a , 37 Bytes

map{$_>=$F[++$i]&$_>=$p&&say;$p=$_}@F

Probieren Sie es online!