Bei einer gegebenen Liste von Ganzzahlen besteht Ihre Aufgabe darin, den zweitgrößten Wert in den ersten k Elementen für jedes k zwischen 2 und der Länge der Eingabeliste auszugeben .

Mit anderen Worten, geben Sie den zweitgrößten Wert für jedes Präfix der Eingabe aus.

Sie können einen beliebigen Wert für das erste Element ausgeben (wobei k = 1 ist) oder diesen Wert einfach weglassen, da es für eine Liste mit 1 Element kein zweites Maximum gibt. Sie können davon ausgehen, dass die Eingabe mindestens zwei Elemente enthält.

Kürzester Code gewinnt.

Beispiele

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

ηεà\à

Probieren Sie es online!

Gibt als []erstes (beliebiger Wert) zurück.

Schale , 9 7 Bytes

Dank @Zgarb ein oder zwei Bytes gespeichert

mȯ→hOtḣ

Rückgabe 0für das erste "zweite Maximum"

Erklärung

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

Probieren Sie es online!

Python 2 , 54 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 58 51 50 Bytes

1 Byte dank @Neil gespeichert

Fügt undefinedfür k = 1 hinzu .

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

Testfälle

Hinweis: Diese Code - Schnipsel Anwendungen JSON.stringify()zur besseren Lesbarkeit, die - als Nebeneffekt - Konvertiten undefinedzu 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._

Probieren Sie es online! oder Probieren Sie die Test Suite!

Wie?

Dies gibt das erste Element der Liste als ersten Wert in der Liste gemäß der Spezifikation aus. Sie können einen beliebigen Wert für das erste Element ausgeben .

m@Sd_2._ - Volles Programm mit impliziter Eingabe.

m ._Q - Mappe über die Präfixe der Eingabe mit einer Variablen d.
  Sd - Sortiert das aktuelle Präfix.
 @ - Liefert das Element ...
    _2 - Bei Index - 2 (der zweithöchste).
           - Implizit drucken.

Gelee , 8 Bytes

ḣJṢ€Ṗ€Ṫ€

Probieren Sie es online!

Der erste Wert ist immer 0, und die folgenden Zahlen sind das zweite Maximum jedes Präfixes.

Erläuterung

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

Probieren Sie es online!

Python 2 , 45 Bytes

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

Probieren Sie es online!

Die rechte Seite des Codes ist selbsterklärend. Was setzen wir aber links von der and? Da wir Teile einer Liste rekursiv verketten, muss die linke Seite wahr sein, wenn lzwei oder mehr Elemente vorhanden sind, und ansonsten eine leere Liste. l[1:]erfüllt dieses Kriterium gut.

C # (Mono) , 81 Bytes

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

Probieren Sie es online!

Brachylog , 10 Bytes

a₀ᶠb{okt}ᵐ

Probieren Sie es online!

Batch, 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↓,\∘⊢

Probieren Sie es online!

05AB1E , 5 Bytes

Fand ein anderes 5-Byte, ganz anders als Eriks Lösung . Der beliebige Wert ist das erste Element der Liste.

ηε{Áθ

Probieren Sie es online!

Erläuterung

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

Nehmen wir ein Beispiel, um es verständlicher zu machen.

• Zuerst bekommen wir die implizite Eingabe, sagen wir es ist [1, 5, 2, 3, 5, 9, 5, 8] .

• Dann pushen wir seine Präfixe mit η-[[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]] .

• Der Code durchsucht nun die Liste und sortiert jedes Präfix mit {-[[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]] .

• Wir nehmen dann das allerletzte Element und verschieben es an den Anfang: [[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]] .

• Natürlich bekommt der Code jetzt das letzte Element jeder Unterliste mit θ- [1, 1, 2, 3, 5, 5, 5, 8](das erste ist der beliebige Wert).

CJam , 16 Bytes

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

Probieren Sie es online!

Gibt das erste Element für first zurück.

-2 dank Challenger5 .

R , 54 49 Bytes

Dank an Giuseppe -5 Bytes. Ich kannte dieses Feature von nicht seq().

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

Probieren Sie es online!

Japt , 12 10 Bytes

Das Ausgabearray besteht aus dem ersten Element im Eingabearray, gefolgt von der gewünschten Sequenz.

£¯YÄ n< g1

Probier es aus

Erläuterung

Implizite Eingabe eines Arrays U.

£

Karte über U, wo Yist der aktuelle Index.

¯YÄ

In Scheiben schneiden Uvon 0bis Y+1.

n<

Absteigend sortieren.

g1

Holen Sie sich das zweite Element.

Das resultierende Array implizit ausgeben.

MATL , 19 10 Bytes

Danke an Luis Mendo für das Rasieren von 9 Bytes!

"GX@:)SP2)

Probieren Sie es hier aus .

Erläuterung

"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&{@/:~ ::#\

Probieren Sie es online! Das erste Element ist immer 1.

Erläuterung

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

Der Raum ist wichtig.

Ohm , 10 8 Bytes

-2 Bytes dank ETHproductions.

∙p»îS2~ª

Probieren Sie es online!

Äh, das ist seltsam, aber ich weiß nicht, wie ich sonst eine negative Zahl drücken soll ... Ich weiß nicht wirklich , Ohm. : P

Mathematica, 45 Bytes

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

Probieren Sie es online!

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

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

Probieren Sie es online!

Schnelle 3 , 67 Bytes

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

Test Suite.

Schnelle 3 , 65 Bytes

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

Test Suite.

Wie führe ich diese aus?

Die erste Funktion ist eine vollständige Funktion, die die Eingabe als Funktionsparameter verwendet und das Ergebnis ausgibt. Sie können sie genau wie im Testlink gezeigt verwenden. Ich habe mich jedoch dazu entschlossen, Anweisungen hinzuzufügen, da die zweite Art von Funktion sehr selten verwendet wird und die meisten Leute nicht einmal von ihrer Existenz wissen. Verwendung:

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

Die zweite Funktion ist eine anonyme Funktion wie Lambdas. Sie können es genauso verwenden, wie Sie es tun würden. Python deklariert eine Variable fund ruft sie auf:

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

oder in eckige Klammern setzen und direkt aufrufen ( (...)(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;

Nimmt Eingaben von Befehlszeilenargumenten entgegen. Ausgabe durch Semikola begrenzt, vor- und nachgeführt.
Laufen Sie mit -nroder versuchen Sie es online .

Gibt eine Warnung in PHP 7.1 aus; ersetzen a&mit ""<zu reparieren.
Oder verwenden Sie for(;++$i<$argc;rsort($a),print$a[1]._)$a[]=$argv[$i];(54 Bytes)

Mathematica 42 Bytes

Unabhängig kam zu einer Antwort, die @Jenny_mathy sehr ähnlich, aber 3 Bytes kürzer ist

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

Es wurde erkannt, dass das 1. laufende Maximum nur 15 Bytes und zwei Funktionsaufrufe benötigt !:

Max~FoldList~#&

Dies kann so kurz gemacht werden, weil Maxes die Attribute hat Flatund OneIdentitydas gilt nicht fürRankedMax die der logische Ersatz wäre. Leider nimmt das Definieren oder Ändern von Attributen für vorhandene Funktionen viel zu viele Bytes in Anspruch, sodass die Reduzierung auf andere Weise erfolgen muss.

Alle n-ten laufenden Maxes können in 48 Bytes gefunden werden:

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

Pyth, 15 Bytes

FNr2hlQ@_S<QN1

Probieren Sie es hier aus: 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

Erläuterung

FNr2hlQ - Für Schleife mit Zähler 2 <= N <= Listenlänge

@_S<QN1 - 2. Element, wenn die ersten N Elemente der Liste in aufsteigender Reihenfolge sortiert und dann umgekehrt werden (in absteigender Reihenfolge sortiert)

k , 13 Bytes

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

Probieren Sie es 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]

Oktave, 51 Bytes

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

- Ein beliebiger Wert, der für das erste Element zurückgegeben wird.

Probieren Sie es online!

JavaScript (ES6), 43 51 Bytes

Bearbeiten: 8 Bytes hinzugefügt, da eine numerische Sortierung gewünscht wird. :(

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

Behalten Sie diese hier, da sie kürzer ist, vorausgesetzt, Sie möchten eine lexikografische Reihenfolge:

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

Beide Ausdrücke erzeugen undefined für das erste Element.

Code testen

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

Vielleicht gibt es eine bessere Möglichkeit, diese Präfixe zu generieren.