Dada una lista de enteros, su tarea es generar el segundo valor más grande en los primeros k elementos, para cada k entre 2 y la longitud de la lista de entrada.

En otras palabras, muestre el segundo valor más grande para cada prefijo de la entrada.

Puede generar un valor arbitrario para el primer elemento (donde k = 1), o simplemente omitir este valor, ya que no hay un segundo máximo para una lista de 1 elemento. Puede suponer que hay al menos 2 elementos en la entrada.

El código más corto gana.

Ejemplos

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

05AB1E , 5 bytes

ηεà\à

Pruébalo en línea!

Devuelve [](valor arbitrario) para el primero.

Casco , 9 7 bytes

Guardado un byte o dos gracias a @Zgarb

mȯ→hOtḣ

Devoluciones 0para el primer "segundo máximo"

Explicación

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

Pruébalo en línea!

Python 2 , 54 bytes

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

Pruébalo en línea!

JavaScript (ES6), 58 51 50 bytes

Guardado 1 byte gracias a @Neil

Anexa undefinedpara k = 1 .

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

Casos de prueba

NB: este fragmento se utiliza JSON.stringify()para facilitar la lectura, que, como efecto secundario, se convierte undefineden null.

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

Pyth , 8 bytes

m@Sd_2._

Pruébalo en línea! o prueba el Test Suite!

¿Cómo?

Esto genera el primer elemento de la lista como el primer valor de la lista, según la especificación . Puede generar un valor arbitrario para el primer elemento .

m@Sd_2._ - Programa completo con entrada implícita.

m ._Q - Mapa sobre los prefijos de la entrada con una variable d.
  Sd: ordena el prefijo actual.
 @ - Obtiene el elemento ...
    _2 - En el índice - 2 (el segundo más alto).
           - Imprimir implícitamente.

Jalea , 8 bytes

ḣJṢ€Ṗ€Ṫ€

Pruébalo en línea!

El primer valor será 0, siempre, y los siguientes números serán los segundos máximos de cada prefijo.

Explicación

ḣ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

Java (OpenJDK 8) , 87 86 bytes

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+" ");}}

Pruébalo en línea!

Python 2 , 45 bytes

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

Pruébalo en línea!

El lado derecho del código se explica por sí mismo. Sin embargo, ¿qué ponemos a la izquierda de la and? Debido a que estamos concatenando partes de una lista de forma recursiva, necesitamos que el lado izquierdo sea verdadero si ltiene 2 o más elementos, y una lista vacía de lo contrario. l[1:]satisface este criterio muy bien.

C # (Mono) , 81 bytes

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

Pruébalo en línea!

Brachylog , 10 bytes

a₀ᶠb{okt}ᵐ

Pruébalo en línea!

Lote, 123 bytes

@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%

APL (Dyalog) , 15 bytes

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

Pruébalo en línea!

05AB1E , 5 bytes

Encontré otro 5-byter, muy diferente de la solución de Erik . El valor arbitrario es el primer elemento de la lista.

ηε{Áθ

Pruébalo en línea!

Explicación

ηε{Áθ  - 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.

Tomemos un ejemplo, para que sea más fácil de entender.

• Primero obtenemos la entrada implícita, digamos que es [1, 5, 2, 3, 5, 9, 5, 8].

• Luego, empujamos sus prefijos 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]].

• Ahora, el código se asigna a través de la lista y clasifica cada prefijo 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]].

• Entonces tomamos el último elemento y moverlo al principio: [[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]].

• Por supuesto, ahora el código obtiene el último elemento de cada sublista usando θ- [1, 1, 2, 3, 5, 5, 5, 8](el primero es el valor arbitrario.

CJam , 16 bytes

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

Pruébalo en línea!

Devuelve el primer elemento para el primero.

-2 gracias a Challenger5 .

R , 54 49 bytes

Gracias a Giuseppe -5 bytes. No conocía esta característica deseq() .

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

Pruébalo en línea!

Japt , 12 10 bytes

La matriz de salida consta del primer elemento en la matriz de entrada seguido de la secuencia deseada.

£¯YÄ n< g1

Pruébalo

Explicación

Entrada implícita de matriz U.

£

Mapa encima U, donde Yestá el índice actual.

¯YÄ

Rebanada Ude 0a Y+1.

n<

Orden descendiente.

g1

Obtén el segundo elemento.

Salida implícita de la matriz resultante.

MATL , 19 10 bytes

¡Gracias a Luis Mendo por reducir 9 bytes!

"GX@:)SP2)

Pruébalo aquí .

Explicación

"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

J, 13 bytes

_2&{@/:~ ::#\

Pruébalo en línea!El primer elemento es siempre 1.

Explicación

_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)

El espacio importa.

Ohm , 10 8 bytes

-2 bytes gracias a ETHproductions.

∙p»îS2~ª

Pruébalo en línea!

Uh, esto es extraño, pero no sé cómo empujar un número negativo ... Realmente no sé Ohm. :PAG

Mathematica, 45 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Swift 3 , 67 bytes

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

Banco de pruebas.

Swift 3 , 65 bytes

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

Banco de pruebas.

¿Cómo ejecutar estos?

La primera es una función completa que toma la entrada como parámetro de función e imprime el resultado. Puede usarlos exactamente como se muestra en el enlace de prueba. Sin embargo, decidí agregar instrucciones, porque el segundo tipo de función se usa muy raramente y la mayoría de las personas ni siquiera saben de su existencia. Uso:

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

La segunda es una función anónima, como lambdas. Puede usarlo exactamente como lo haría con Python, declarando una variable fy llamándola:

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

o envuélvelo entre paréntesis y llámalo directamente ( (...)(ArrayGoesHere)):

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

PHP, 53 bytes

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

toma datos de los argumentos de la línea de comandos. Salida delimitada, liderada y rastreada por semicola.
Ejecutar -nro probarlo en línea .

Produce una advertencia en PHP 7.1; reemplazar a&con ""<para arreglar.
O use for(;++$i<$argc;rsort($a),print$a[1]._)$a[]=$argv[$i];(54 bytes)

Mathematica 42 Bytes

Independientemente llegó a una respuesta muy similar a @Jenny_mathy pero 3 bytes más corta

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

¡Me di cuenta de que el primer máximo de ejecución solo toma 15 bytes y dos llamadas a funciones !:

Max~FoldList~#&

Esto se puede hacer de manera concisa porque Maxtiene los atributos Flaty OneIdentityeso no es cierto paraRankedMax cual sería el reemplazo lógico. Desafortunadamente, definir atributos o modificarlos en funciones existentes ocupa demasiados bytes, por lo que el aplanamiento debe hacerse por otros medios.

Todos los enésimos máximos en ejecución se pueden encontrar en 48 bytes:

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

Pyth, 15 bytes

FNr2hlQ@_S<QN1

Pruébelo aquí: 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 y depuración = 0

Explicación

FNr2hlQ - Para bucle con contador 2 <= N <= longitud de la lista

@_S<QN1 - Segundo elemento cuando los primeros N elementos de la lista se ordenan en orden ascendente y luego se invierten (ordenados en orden descendente)

k , 13 bytes

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

Pruébalo en línea!

           ,\ /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]

Octava, 51 bytes

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

- Un valor arbitrario devuelto para el primer elemento.

Pruébalo en línea!

JavaScript (ES6), 43 51 bytes

Editar: Se agregaron 8 bytes ya que se desea la ordenación numérica. :(

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

Sin embargo, mantener este aquí, ya que es más corto, siempre que uno quiera ordenar lexicográficamente:

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

Ambas expresiones producen undefined para el primer elemento.

Código de prueba

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

Clojure, 56 bytes

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

Tal vez hay una mejor manera de generar esos prefijos.