Extraire les maxima locaux

19

É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!

code-golf  array-manipulation 
— Pavel
source
1
@PeterTaylor Je pense que ce que cela signifie est "Pour que le premier ou le dernier élément soit inclus dans la sortie, ..."
— xnor
@PeterTaylor xnor est correct.
— Pavel
— Peter Taylor
— Voir
Puis-je proposer [4,3,3,4]comme testcase. Malheureusement, ma solution ne l'a pas très bien géré.
— JAD

Réponses:

5

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
— Jonathan Allan
source
Eh bien, je pense qu'il y a peut-être un moyen d'utiliser la réduction à 3, mais je n'ai pas trouvé de solution.
— Jonathan Allan
J'avais raison - une réduction de 3 points avec la dyade maximale, »- que diriez-vous de 10 cependant ..?
— Jonathan Allan
8

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])
— xnor
source
7

Mathematica 22 octets

Pick[#,MaxDetect@#,1]&
— Kelly Lowder
source
1
Soit dit en passant, cela fonctionnerait également sur des tableaux de dimension supérieure.
— Kelly Lowder
6

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!

— nimi
source
2
i:j:k:_<-scanr(:)[0]$0:lest plus court. (Ajuster légèrement l' tails=scanr(:)[]astuce "standard" .)
— Ørjan Johansen
@ ØrjanJohansen: oh, j'ai utilisé cette astuce avant moi-même, mais je l'ai ratée ici. Merci beaucoup!
— nimi
4

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
— Zacharý
source
3

JavaScript (ES6), 40 octets

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

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.

— M. Xcoder
source
lambda l,k=[0]:[l[i]for i in range(len(l))if(k+l+k)[i+2]<=l[i]>=(k+l+k)[i]]
— Leaky Nun
2

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

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
— JAD
source
1

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!

— Leaky Nun
source
pryr::f(expression)est un moyen plus court de déclarer une fonction que function(a)expression.
— JAD
Est également sum(a|1)un raccourci pour length(a).
— JAD
Voir ma solution pour une approche plus courte.
— JAD
1

q, 39 octets

{x where x = -1 _ next 3 mmax x,last x}
— skeevey
source
Je n'ai jamais entendu parler de cette langue auparavant. Savez-vous où je peux l'essayer ou le télécharger?
— Pavel
Bien sûr, kx.com , docs: code.kx.com
— skeevey
1

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

— récursif
source
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.