Étant donné un tableau d'entiers positifs, affichez un tableau de tous les éléments supérieurs ou égaux aux éléments adjacents. La plupart des éléments auront deux éléments adjacents; le premier et le dernier élément sont des cas spéciaux, car ils n'ont qu'un seul élément adjacent.

Vous pouvez supposer que le tableau contient au moins deux éléments.

Cas de test:

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]

C'est le code-golf , le code le plus court gagne!

Gelée ,  13 12  11 octets

0;;0»3\f"⁸Ẏ

Un lien monadique prenant une liste d'entiers positifs et renvoyant la liste filtrée contenant uniquement ceux qui sont supérieurs ou égaux à tous leurs voisins.

Essayez-le en ligne!

12 octets précédents :

0;INżI>0ḄNMị

13 octets précédents :

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

Comment?

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 octets

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

Essayez-le en ligne!

Les E / S utilisent des tuples plutôt que des listes.

Python , 57 octets

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

Essayez-le en ligne!

Alt 57:

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

Mathematica 22 octets

Pick[#,MaxDetect@#,1]&

Haskell, 50 49 42 octets

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

Essayez-le en ligne!

scanr(:)[0]fait une liste des queues de (0:l), chacune avec une finale 0, par exemple pour 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]]qui est le modèle identifié agains i:j:k:_pour extraire toutes les listes avec au moins 3 éléments qui sont nommés i, jet k. Gardez jsi son> = iet j.

Edit: Ørjan Johansen a enregistré 7 octets. Merci!

Dyalog APL, 31 30 28 22 21 octets

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

Essayez-le en ligne!

Explication (je ne suis pas bon pour expliquer les choses):

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 octets

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

Essayez-le en ligne!

JavaScript (ES6), 40 octets

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

Python 3 , 84 75 * 71 octets

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

Essayez-le en ligne!

* @ LeakyNun a économisé 9 octets en utilisant une astuce d'opérateur astucieux.

Gelée , 15 octets

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

Essayez-le en ligne!

05AB1E , 15  14  13 octets

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

Essayez-le en ligne!

Explication

ü‹             # 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

Solution précédente de 15 octets

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

Essayez-le en ligne!

Explication

¬                # 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 octets

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

qui évalue à la fonction:

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

Par rapport xà c(0,x), donc avec xune position décalée vers la droite. Se compare également xà x[-1], donc une position décalée vers la gauche. Ces deux sont TRUEs'il y a un maximum là-bas. &pour prendre le ET de ces booléens. En raison de la nature enveloppante des vecteurs de R lorsqu'ils ne sont pas de la même longueur, nous devons tronquer le résultat à la longueur de x, qui est trouvée en prenant sum(x|1). On branche ensuite le vecteur booléen, en ne prenant que les vrais indices de xet en retournant cela.

Notez que parce que ces opérations logiques sont effectuées avec des vecteurs de longueur inégale, R se plaindra. Beaucoup. Mais la sortie correcte sera là au milieu des avertissements:

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

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

Essayez-le en ligne!

2 octets de moins que la solution JAD . diffcalcule les différences successives; puis ne conservez que les entrées supérieures aux deux voisins.

Pyth , 20 octets

-.b*YqYeSN.:++0Q03Q0

A jouer au golf ...

Suite de tests.

R , 68 octets

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

Essayez-le en ligne!

PHP , 67 octets

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

Essayez-le en ligne!

Rétine , 51 octets

\d+
$*
^

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

%`1

Essayez-le en ligne

q, 39 octets

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

Stax , 10 octets

úâH◄(☼bM•Å

Exécuter et déboguer

Il produit la sortie sous forme de valeurs séparées par des sauts de ligne sur la sortie standard.

Déballé, non golfé et commenté, il ressemble à ceci.

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?

Exécutez celui-ci

Mise à jour: Je viens de trouver une solution à 9 octets. Met à jour l'explication plus tard:

Stax , 9 octets

▀▓ûa¥╓╧↨⌐

Exécuter et déboguer

Perl 5 -a , 37 octets

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

Essayez-le en ligne!