Dato un elenco di numeri interi, il tuo compito è produrre il secondo valore più grande nei primi k elementi, per ogni k compreso tra 2 e la lunghezza dell'elenco di input.

In altre parole, genera il secondo valore più grande per ciascun prefisso dell'input.

Puoi generare un valore arbitrario per il primo elemento (dove k = 1) o semplicemente omettere questo valore, poiché non esiste un secondo massimo per un elenco di 1 elemento. Si può presumere che ci siano almeno 2 elementi nell'input.

Il codice più corto vince.

Esempi

Input:
1 5 2 3 5 9 5 8
Output:
  1 2 3 5 5 5 8
Input:
1 1 2 2 3 3 4
Output:
  1 1 2 2 3 3
Input:
2 1 0 -1 0 1 2
Output:
  1 1 1 1 1 2

code-golf number array-manipulation

— jimmy23013
fonte

Il mio inglese non è il migliore, come viene kdeterminato?

— Liefde:

@LiefdeWen Emette un elenco contenente la risposta per ogni k.

— jimmy23013,

2

1non è, a rigor di termini, il secondo valore più grande di 1,1(secondo esempio) è il secondo valore in ordine decrescente.

— Jonathan Allan,

Forse sono solo stupido (anche se sospetto che potrei davvero iniziare il fine settimana ..), ma non sono ancora sicuro di come funzioni. Qualcuno potrebbe ELI5 l'ultimo test case per me? I primi due casi di test che posso risolvere semplicemente eseguendo il ciclo sull'elenco, determinando il minimo corrente dell'elenco, quindi rimuovendo quell'elemento (o più facilmente: ordina l'elenco e rimuovi l'ultimo elemento). Fornisce i risultati corretti per i primi due casi di test, ma ovviamente è sbagliato (e darà -1, 0, 0, 1, 1, 2per l'ultimo caso di test.)

— Kevin Cruijssen

1

@KevinCruijssen Ricorda i due numeri più grandi che hai visto. Nell'ultimo caso, inizi con 2 che è il più grande e non produci nulla / qualunque cosa dal momento che non ha senso a questo punto. Quindi si passa a 1 e 2 alla successiva iterazione, quindi si ottiene l'output 1. Questo rimane lo stesso fino a quando non si raggiunge il 2 alla fine, quindi si hanno 2 e 2 come il più grande e il secondo più grande

— FryAmTheEggman

6

05AB1E , 5 byte

ηεà\à

Provalo online!

Restituisce [](valore arbitrario) per primo.

— Erik the Outgolfer
fonte

η¦ε{¨θdovrebbe funzionare per 6 byte

— Adnan l'

@Adnan Naturalmente> _ <ha trovato comunque un modo migliore ...

— Erik the Outgolfer,

Interessante ... Z©KZ®‚¹sÃera quello che stavo pensando, non sapevo àfosse nemmeno una cosa!

— Magic Octopus Urn l'

Trovato un'altra alternativa a 5 byte . Ho usato Áθinvece.

— Mr. Xcoder, l'

5

Buccia , 9 7 byte

Salvato un byte o due grazie a @Zgarb

mȯ→hOtḣ

Restituisce 0per il primo "secondo massimo"

spiegazione

         -- implicit input, e.g          [1,5,3,6]
      ḣ  -- prefixes                     [[],[1],[1,5],[1,5,3],[1,5,3,6]]
     t   -- remove the first element     [[1],[1,5],[1,5,3],[1,5,3,6]]
mȯ       -- map the composition of 3 functions
    O    --   sort                       [[1],[1,5],[1,3,5],[1,3,5,6]]
   h     --   drop the last element      [[],[1],[1,3],[1,3,5]
  →      --   return the last element    [0,1,3,5]
         -- implicit output

Provalo online!

— H.PWiz
fonte

1

È possibile →hOinvece mappare e salvare un byte.

— Zgarb,

4

Python 2 , 54 byte

lambda x:[sorted(x[:i])[-2]for i in range(2,1+len(x))]

Provalo online!

— asta
fonte

3

JavaScript (ES6), 58 51 50 byte

Salvato 1 byte grazie a @Neil

Si aggiunge undefinedper k = 1 .

a=>a.map(e=>(b=[e,...b]).sort((a,b)=>b-a)[1],b=[])

Casi test

NB: questo frammento utilizza JSON.stringify()per la leggibilità, che - come effetto collaterale - si converte undefinedin null.

Mostra snippet di codice

let f =

a=>a.map(e=>(b=[e,...b]).sort((a,b)=>b-a)[1],b=[])

console.log(JSON.stringify(f([1, 5, 2, 3, 5, 9, 5, 8]))) // 1 2 3 5 5 5 8
console.log(JSON.stringify(f([1, 1, 2, 2, 3, 3, 4])))    // 1 1 2 2 3 3
console.log(JSON.stringify(f([2, 1, 0, -1, 0, 1, 2])))   // 1 1 1 1 1 2

Espandi frammento

— Arnauld
fonte

1

Penso che a=>a.map(e=>(b=[e,...b]).sort((a,b)=>b-a)[1],b=[])siano solo 50.

— Neil,

@Neil Nice. :-)

— Arnauld

2

Pyth , 8 byte

m@Sd_2._

Provalo online! o prova la suite di test!

Come?

Questo genera il primo elemento dell'elenco come primo valore nell'elenco, come da specifica È possibile produrre un valore arbitrario per il primo elemento .

m@Sd_2._ - Programma completo con input implicito.

m ._Q - Mappa sopra i prefissi dell'input con una variabile d.
  Sd: ordina il prefisso corrente.
 @ - Ottiene l'elemento ...
    _2 - All'indice - 2 (il secondo più alto).
           - Stampa implicitamente.

— Mr. Xcoder
fonte

2

Gelatina , 8 byte

ḣJṢ€Ṗ€Ṫ€

Provalo online!

Il primo valore sarà 0, sempre, e i seguenti numeri saranno i secondi massimi di ciascun prefisso.

Spiegazione

ḣJṢ€Ṗ€Ṫ€  Input: array A
 J        Enumerate indices, [1, 2, ..., len(A)]
ḣ         Head, get that many values from the start for each, forms the prefixes
  Ṣ€      Sort each
    Ṗ€    Pop each, removes the maximum
      Ṫ€  Tail each

— miglia
fonte

@ Challenger5 Non credo che funzioni

— miglia

@ Challenger5 Non funziona ...

— Erik the Outgolfer

@EriktheOutgolfer Oh, ok.

— Esolanging Fruit

2

Java (OpenJDK 8) , 87 86 byte

a->{int x,y=x=1<<-1;for(int c:a){if((c>x?x=c:c)>y){x=y;y=c;}System.out.print(x+" ");}}

Provalo online!

— Nevay
fonte

+1 per int x,y=x=. Non sapevo che una dichiarazione e un incarico separati potessero essere svolti nella stessa dichiarazione.

— Jakob,

2

Python 2 , 45 byte

f=lambda l:l[1:]and f(l[:-1])+[sorted(l)[-2]]

Provalo online!

Il lato destro del codice è autoesplicativo. Tuttavia, cosa mettiamo a sinistra del and? Poiché stiamo concatenando ricorsivamente parti di un elenco, abbiamo bisogno che il lato sinistro sia veritiero se lha 2 o più elementi, e altrimenti un elenco vuoto. l[1:]soddisfa bene questo criterio.

— Sisifo
fonte

1

C # (Mono) , 81 byte

using System.Linq;a=>a.Select((_,i)=>a.Take(++i).OrderBy(n=>n).Skip(i-2).First())

Provalo online!

— TheLethalCoder
fonte

1

Brachylog , 10 byte

a₀ᶠb{okt}ᵐ

Provalo online!

— Erik the Outgolfer
fonte

1

Lotto, 123 byte

@set/af=s=%1
@for %%n in (%*)do @call:c %%n
@exit/b
:c
@if %1 gtr %s% set s=%1
@if %1 gtr %f% set/as=f,f=%1
@echo %s%

— Neil
fonte

1

APL (Dyalog) , 15 byte

(2⊃⍒⊃¨⊂)¨1↓,\∘⊢

Provalo online!

— Kritixi Lithos
fonte

1

05AB1E , 5 byte

Ho trovato un altro 5 byte, molto diverso dalla soluzione di Erik . Il valore arbitrario è il primo elemento dell'elenco.

ηε{Áθ

Provalo online!

Spiegazione

ηε{Áθ  - Full program that reads implicitly from STDIN and outputs to STDOUT.

η      - Push the Prefixes of the list.
 ε     - Apply to each element (each prefix):
  {      - Sort the prefix list.
   Á     - Shift the list to the right by 1, such that the first element goes to the 
           beginning  and the second largest one becomes the last.
    θ    - Get the last element (i.e. the second largest)
         - Print implicitly.

Facciamo un esempio, per facilitare la comprensione.

Per prima cosa otteniamo l'input implicito, diciamo che lo è [1, 5, 2, 3, 5, 9, 5, 8].
Quindi, spingiamo i suoi prefissi usando η- [[1], [1, 5], [1, 5, 2], [1, 5, 2, 3], [1, 5, 2, 3, 5], [1, 5, 2, 3, 5, 9], [1, 5, 2, 3, 5, 9, 5], [1, 5, 2, 3, 5, 9, 5, 8]].
Ora, il codice mappa attraverso l'elenco e ordina ogni prefisso usando {- [[1], [1, 5], [1, 2, 5], [1, 2, 3, 5], [1, 2, 3, 5, 5], [1, 2, 3, 5, 5, 9], [1, 2, 3, 5, 5, 5, 9], [1, 2, 3, 5, 5, 5, 8, 9]].
Abbiamo poi prendiamo l'ultimo elemento e spostarlo all'inizio: [[1], [5, 1], [5, 1, 2], [5, 1, 2, 3], [5, 1, 2, 3, 5], [9, 1, 2, 3, 5, 5], [9, 1, 2, 3, 5, 5, 5], [9, 1, 2, 3, 5, 5, 5, 8]].
Naturalmente, ora il codice ottiene l'ultimo elemento di ciascun elenco secondario usando θ- [1, 1, 2, 3, 5, 5, 5, 8](il primo è il valore arbitrario.

— Mr. Xcoder
fonte

1

CJam , 16 byte

{_,,:)\f{<$-2=}}

Provalo online!

Restituisce il primo elemento per primo.

-2 grazie a Challenger5 .

— Erik the Outgolfer
fonte

{_,,:)\f{<$-2=}}è due byte più breve.

— Esolanging Fruit,

1

R , 54 49 byte

Grazie a Giuseppe -5 byte. Non conoscevo questa caratteristica di seq().

for(i in seq(x<-scan()))cat(sort(x[1:i],T)[2],"")

Provalo online!

— djhurio
fonte

1

seq(x<-scan())è più breve di alcuni byte.

— Giuseppe,

1

Japt , 12 10 byte

L'array di output è costituito dal primo elemento dell'array di input seguito dalla sequenza desiderata.

£¯YÄ n< g1

Provalo

Spiegazione

Input implicito di array U.

£

Mappa su U, dove si Ytrova l'indice corrente.

¯YÄ

Slice Uda 0a Y+1.

n<

Ordine decrescente.

g1

Ottieni il secondo elemento.

Emette implicitamente l'array risultante.

— ispido
fonte

1

MATL , 19 10 byte

Grazie a Luis Mendo per aver rasato 9 byte!

"GX@:)SP2)

Provalo qui .

Spiegazione

"GX@:)SP2)
"                  for all the values in the input
 G                 get input
  X@:)             get values up to the iteration
      SP           sort it in descending order
        2)         get the second value
                   implicit end of loop and output

— dantheman
fonte

@LuisMendo Wow! Mostra quanto so di MATL. Grazie per l'aiuto!

— DanTheMan,

1

J, 13 byte

_2&{@/:~ ::#\

Provalo online! Il primo elemento è sempre 1.

Spiegazione

_2&{@/:~ ::#\
            \  Apply to prefixes
_2&{@/:~        Sort and take second-to-last atom
     /:~         Sort upwards
_2 {             Take second-to-last atom
         ::     If there's an error (i.e only one atom)
           #     Return the length of the list (1)

Lo spazio conta.

— ravizzone
fonte

1

Ohm , 10 8 byte

-2 byte grazie a ETHproductions.

∙p»îS2~ª

Provalo online!

~~Uh, questo è strano ma non so come altro spingere un numero negativo ...~~ Non so davvero Ohm. : P

— totallyhuman
fonte

1

Va bene, 0 2-sembra molto strano ...

— Mr. Xcoder l'

1

Solo guardando i documenti (non so nulla di Ohm), potresti farlo 2~?

— ETHproductions

@TEHProductions Oh, molto meglio. Grazie!

— totalmente umano l'

0

Mathematica, 45 byte

Sort[s[[;;i]]][[-2]]~Table~{i,2,Length[s=#]}&

Provalo online!

— J42161217
fonte

0

Perl 5 , 42 + 1 (-a) = 43 byte

say((sort{$b<=>$a}@F[0..$_])[1])for 1..$#F

Provalo online!

— Xcali
fonte

0

Swift 3 , 67 byte

func g(l:[Int]){print((1..<l.count).map{l[0...$0].sorted()[$0-1]})}

Test Suite.

Swift 3 , 65 byte

{l in(1..<l.count).map{l[0...$0].sorted()[$0-1]}}as([Int])->[Int]

Test Suite.

Come eseguirli?

La prima è una funzione completa che accetta l'input come parametro di funzione e stampa il risultato. Puoi usarli esattamente come mostrato nel link di test. Ho deciso di aggiungere istruzioni, perché il secondo tipo di funzione viene usato molto raramente e la maggior parte delle persone non sa nemmeno della sua esistenza. Uso:

g(l: [1, 1, 2, 2, 3, 3, 4] )

La seconda è una funzione anonima, come le lambda. Puoi usarlo esattamente come faresti con Python, dichiarando una variabile fe chiamandola:

var f = {l in(1..<l.count).map{l[0...$0].sorted()[$0-1]}}as([Int])->[Int]

print(f([1, 1, 2, 2, 3, 3, 4]))

oppure avvolgilo tra parentesi e chiamalo direttamente ( (...)(ArrayGoesHere)):

print(({l in(1..<l.count).map{l[0...$0].sorted()[$0-1]}}as([Int])->[Int])([1, 1, 2, 2, 3, 3, 4]))

— Mr. Xcoder
fonte

0

PHP, 53 byte

for(;a&$n=$argv[++$i];rsort($a),print$a[1]._)$a[]=$n;

accetta input dagli argomenti della riga di comando. Produzione delimitata, guidata e seguita da semicola.
Corri con -nro provalo online .

Fornisce un avviso in PHP 7.1; sostituire a&con ""<per risolvere.
O utilizzare for(;++$i<$argc;rsort($a),print$a[1]._)$a[]=$argv[$i];(54 byte)

— Titus
fonte

0

Mathematica 42 byte

Indipendentemente è arrivato a una risposta molto simile a @Jenny_mathy ma più corta di 3 byte

Sort[#[[;;i]]][[-2]]~Table~{i,2,Length@#}&

Realizzato che il 1 ° max corrente richiede solo 15 byte e due chiamate di funzione !:

Max~FoldList~#&

Questo può essere fatto in modo conciso perché Maxha gli attributi Flate OneIdentitynon è veroRankedMax quale sarebbe la sostituzione logica. Sfortunatamente, la definizione di attributi o la loro modifica su funzioni esistenti occupa troppi byte, quindi l'appiattimento deve essere eseguito con altri mezzi.

Tutti gli ennesimi massimi in esecuzione possono essere trovati in 48 byte:

PadLeft[Sort/@Flatten/@FoldList[{##}&,{},#&@#]]&

— Kelly Lowder
fonte

0

Pyth, 15 byte

FNr2hlQ@_S<QN1

Provalo qui: https://pyth.herokuapp.com/?code=FNr2hlQ%40_S%3CQN1&input=%5B1%2C+5%2C+2%2C+3%2C+5%2C+9%2C+5% 2C + 8% 5D & debug = 0

Spiegazione

FNr2hlQ - Per loop con contatore 2 <= N <= lunghezza elenco

@_S<QN1 - 2 ° elemento quando i primi N elementi dell'elenco sono ordinati in ordine crescente e quindi invertiti (ordinati in ordine decrescente)

— Karan Elangovan
fonte

0

k , 13 byte

{x(>x)1}'1_,\

Provalo online!

           ,\ /sublists of increasing lengths (scan concat)
         1_   /remove the first sublist
{      }'     /for each sublist:
  (>x)        /    indices to permute sublist into largest to smallest
      1       /    get second index
 x            /    get sublist[that index]

— zgrep
fonte

0

Ottava, 51 byte

@(a){[~,I]=cummax(a);a(I(2:end))=-inf;cummax(a)}{3}

- Un valore arbitrario restituito per il primo elemento.

Provalo online!

— rahnema1
fonte

0

JavaScript (ES6), 43 51 byte

Modifica: aggiunti 8 byte poiché si desidera l'ordinamento numerico. :(

a=>a.map((_,b)=>a.slice(0,b+1).sort((a,b)=>b-a)[1])

Mantenendo questo qui, tuttavia, poiché è più breve a condizione che si desideri un ordinamento lessicografico:

a=>a.map((_,b)=>a.slice(0,b+1).sort()[b-1])

Entrambe le espressioni producono undefined per il primo elemento.

Codice di prova

Mostra snippet di codice

const golfed =

a=>a.map((_,b)=>a.slice(0,b+1).sort((a,b)=>b-a)[1])

const inputs = [
  [1, 5, 2, 3, 5, 9, 5, 8],
  [1, 1, 2, 2, 3, 3, 4],
  [2, 1, 0, -1, 0, 1, 2]
];
console.log(inputs.map(x => golfed(x)));
// [ [ undefined, 1, 2, 3, 5, 5, 5, 8 ],
//   [ undefined, 1, 1, 2, 2, 3, 3 ],
//   [ undefined, 1, 1, 1, 1, 1, 2 ] ]

Espandi frammento

— Aaron Hill
fonte

Nota che avrei preferito commentare semplicemente il post JS esistente se non fosse stato per il sistema di reputazione.

— Aaron Hill,

Benvenuti in PPCG! Non mi piace neanche la soglia dei commenti da 50 ripetitori, ma immagino che ne abbiano bisogno per impedire agli spammer di commentare. Ad ogni modo, penso che ciò fallirà se l'ingresso contiene un numero a due cifre come 10, come .sort()ordinamento lessicografico di default (cioè 1,10,100,11,12,13, ..., 2,20,21, ...). Dovresti includere (a,b)=>a-bo simili per ordinarli in base al numero.

— ETHproductions

Grazie, @ETHproductions. Ho aggiornato per l'ordinamento numerico, il che significa che questo non è più abbastanza buono. Oh bene.

— Aaron Hill,

0

Clojure, 56 byte

#(for[i(drop 2(reductions conj[]%))](nth(sort-by - i)1))

Forse c'è un modo migliore per generare quei prefissi.

— NikoNyrh
fonte

Esecuzione secondo massimo di un elenco

Esempi

05AB1E , 5 byte

Buccia , 9 7 byte

spiegazione

Python 2 , 54 byte

JavaScript (ES6), 58 51 50 byte

Casi test

Pyth , 8 byte

Come?

Gelatina , 8 byte

Spiegazione

Java (OpenJDK 8) , 87 86 byte

Python 2 , 45 byte

C # (Mono) , 81 byte

Brachylog , 10 byte

Lotto, 123 byte

APL (Dyalog) , 15 byte

05AB1E , 5 byte

Spiegazione

CJam , 16 byte

R , 54 49 byte

Japt , 12 10 byte

Spiegazione

MATL , 19 10 byte

Spiegazione

J, 13 byte

Spiegazione

Ohm , 10 8 byte

Mathematica, 45 byte

Perl 5 , 42 + 1 (-a) = 43 byte

Swift 3 , 67 byte

Swift 3 , 65 byte

Come eseguirli?

PHP, 53 byte

Mathematica 42 byte

Pyth, 15 byte

Spiegazione

k , 13 byte

Ottava, 51 byte

JavaScript (ES6), 43 51 byte

Codice di prova

Clojure, 56 byte