Estrai massimi locali

19

Dato un array di numeri interi positivi, genera un array di tutti gli elementi maggiori o uguali a quelli adiacenti. La maggior parte degli elementi avrà due elementi adiacenti; il primo e l'ultimo elemento sono casi speciali, poiché hanno solo un elemento adiacente.

Si può presumere che l'array contenga almeno due elementi.

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

Questo è code-golf , vince il codice più corto!

code-golf  array-manipulation 
— Pavel
fonte
1
@PeterTaylor Penso che il significato sia "Per il primo o l'ultimo elemento da includere nell'output, ..."
— xnor
@PeterTaylor xnor è corretto.
— Pavel,
— Peter Taylor,
— Wrzlprmft,
Posso proporre [4,3,3,4]come testcase. La mia soluzione non l'ha gestita molto bene, purtroppo.
— JAD,

Risposte:

5

Gelatina ,  13 12  11 byte

0;;0»3\f"⁸Ẏ

Un collegamento monadico che prende un elenco di numeri interi positivi e restituisce l'elenco filtrato contenente solo quelli che sono maggiori o uguali a tutti i loro vicini.

Provalo online!

12 byte precedenti :

0;INżI>0ḄNMị

13 byte precedenti :

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

Come?

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
fonte
Beh, penso che potrebbe esserci un modo per usare la riduzione in 3 ma non l'ho capito.
— Jonathan Allan,
Avevo ragione - una riduzione di 3 saggi con la massima diade, »- che ne dici di 10 però ...?
— Jonathan Allan,
8

Python , 54 byte

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

Provalo online!

L'I / O è con tuple anziché con elenchi.

Python , 57 byte

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

Provalo online!

Alt 57:

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

Haskell, 50 49 42 byte

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

Provalo online!

scanr(:)[0]fa un elenco delle code di (0:l), ciascuno con una finale 0, ad esempio, per 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]]quale è il modello abbinato agains i:j:k:_per estrarre tutte le liste con almeno 3 elementi che prendono il nome i, je k. Mantieni jse è> = ie j.

Modifica: Ørjan Johansen ha salvato 7 byte. Grazie!

— Nome del modello
fonte
2
i:j:k:_<-scanr(:)[0]$0:lè più corto. (Regolando leggermente il tails=scanr(:)[]trucco "standard" .)
— Ørjan Johansen,
@ ØrjanJohansen: oh, ho usato quel trucco prima di me, ma in qualche modo l'ho perso qui. Molte grazie!
— nimi,
4

Dyalog APL, 31 30 28 22 21 byte

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

Provalo online!

Spiegazione (non sono bravo a spiegare le cose):

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
— Zaccaria
fonte
3

JavaScript (ES6), 40 byte

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

Python 3 , 84 75 * 71 byte

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

Provalo online!

* @ LeakyNun ha salvato 9 byte usando un trucco intelligente da parte dell'operatore.

— Mr. Xcoder
fonte
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 byte

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

Provalo online!

Spiegazione

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

Soluzione precedente a 15 byte

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

Provalo online!

Spiegazione

¬                # 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
fonte
2

R, 44 byte

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

che valuta la funzione:

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

Confronta xcon c(0,x), quindi xspostato di una posizione verso destra. Si confronta anche xcon x[-1], quindi una posizione spostata a sinistra. Entrambi sono TRUEse c'è un massimo lì. &prendere l'AND di questi booleani. A causa della natura avvolgente dei vettori di R quando non hanno la stessa lunghezza, dobbiamo troncare il risultato alla lunghezza di x, che si trova prendendo sum(x|1). Quindi inseriamo il vettore booleano, prendendo solo i veri indici di xe restituendoli.

Nota, poiché queste operazioni logiche vengono eseguite con vettori di lunghezza diversa, R si lamenterà. Un sacco. Ma l'output corretto sarà presente tra gli avvisi:

> 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
fonte
1

R , 68 byte

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

Provalo online!

— Perdente Suora
fonte
pryr::f(expression)è un modo più breve per dichiarare una funzione di function(a)expression.
— JAD,
Inoltre, sum(a|1)è una scorciatoia per length(a).
— JAD,
Vedi la mia soluzione per un approccio più breve.
— JAD,
1

Stax , 10 byte

úâH◄(☼bM•Å

Esegui ed esegui il debug

Produce output come valori separati da nuova riga sull'output standard.

Disimballato, non golfato e commentato, sembra così.

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?

Esegui questo

Aggiornato: ho appena trovato una soluzione a 9 byte. Aggiornerà la spiegazione in seguito:

Stax , 9 byte

▀▓ûa¥╓╧↨⌐

Esegui ed esegui il debug

— ricorsivo
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.