给定一个整数列表，您的任务是输出前k个元素中的第二个最大值，对于2到输入列表长度之间的每个k。

换句话说，为输入的每个前缀输出第二个最大值。

您可以为第一个元素输出任意值（其中k = 1），也可以忽略此值，因为1个元素的列表没有第二个最大值。您可以假设输入中至少包含2个元素。

最短的代码胜出。

例子

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个字节

ηεà\à

在线尝试！

首先返回[]（任意值）。

外壳，9 7个字节

@Zgarb节省了一两个字节

mȯ→hOtḣ

返回0第一个“第二个最大值”

讲解

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

在线尝试！

Python 2，54个字节

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

在线尝试！

JavaScript（ES6），58 51 50字节

@Neil节省了1个字节

追加undefined为K = 1。

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

测试用例

注意：此代码段JSON.stringify()用于提高可读性，作为副作用，它会转换undefined为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个字节

m@Sd_2._

在线尝试！或尝试测试套件！

怎么样？

根据规范，这将列表的第一个元素输出为列表中的第一个值。您可以为第一个元素输出任意值。

m@Sd_2._-带有隐式输入的完整程序。

m ._Q-用变量d映射输入的前缀。
  Sd-对当前前缀进行排序。
 @-获取元素...
    _2-索引为2（第二高）。
           -隐式打印。

果冻，8字节

ḣJṢ€Ṗ€Ṫ€

在线尝试！

第一个值始终为0，随后的数字为每个前缀的第二个最大值。

说明

ḣ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字节

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

在线尝试！

Python 2，45个字节

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

在线尝试！

代码的右侧是不言自明的。但是，我们在左边放什么and呢？因为我们要递归连接列表的各个部分，所以如果l有两个或更多元素，则需要左侧为真，否则为空列表。l[1:]很好地满足了这个标准。

C＃（单声道），81个字节

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

在线尝试！

Brachylog，10个字节

a₀ᶠb{okt}ᵐ

在线尝试！

批处理，123字节

@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字节

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

在线尝试！

05AB1E，5个字节

找到了另一个5乘，与Erik的解决方案完全不同。任意值是列表的第一个元素。

ηε{Áθ

在线尝试！

说明

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

让我们举个例子，使其更容易理解。

• 首先，我们得到隐式输入，假设它是[1, 5, 2, 3, 5, 9, 5, 8]。

• 然后，使用η- 推送其前缀[[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]]。

• 现在，代码遍历列表，并使用{-对每个前缀进行排序[[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]]。

• 然后，我们将最后一个元素移到开头：[[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]]。

• 当然，现在代码使用θ- 获得每个子列表的最后一个元素[1, 1, 2, 3, 5, 5, 5, 8]（第一个是任意值）。

CJam，16字节

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

在线尝试！

返回第一个元素为first。

-2感谢Challenger5。

R，54 49字节

感谢Giuseppe -5个字节。我不知道该功能seq()。

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

在线尝试！

Japt，12个 10字节

输出数组由输入数组中的第一个元素组成，后跟所需的序列。

£¯YÄ n< g1

测试一下

说明

数组的隐式输入U。

£

映射到U，Y当前索引在哪里。

¯YÄ

切片U从0到Y+1。

n<

降序排列。

g1

获取第二个元素。

隐式输出结果数组。

MATL，19 10字节

感谢Luis Mendo节省了9个字节！

"GX@:)SP2)

在这里尝试。

说明

"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个字节

_2&{@/:~ ::#\

在线尝试！第一个元素始终为1。

说明

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

空间很重要。

欧姆，10 8字节

-2个字节归功于ETHproductions。

∙p»îS2~ª

在线尝试！

嗯，这很奇怪，但我不知道怎么回事，推动负数......我并不真的知道欧姆。：P

Mathematica，45个字节

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

在线尝试！

Perl 5，42 +1（-a）= 43字节

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

在线尝试！

迅捷 3，67字节

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

测试套件。

Swift 3，65个字节

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

测试套件。

如何运行这些？

第一个是一个完整的函数，它将输入作为函数参数并打印结果。您可以完全按照测试链接中所示使用它们。但是我决定添加指令，因为很少使用第二种类型的函数，而且大多数人甚至都不知道它的存在。用法：

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

第二个是匿名函数，例如lambdas。您可以像在Python中一样使用它，声明一个变量f并调用它：

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

或将其包装在方括号之间，然后直接调用（(...)(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字节

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

从命令行参数获取输入。输出由定界分隔，领先和落后。
运行-nr或在线尝试。

在PHP 7.1中产生警告；替换a&与""<要修复。
或使用for(;++$i<$argc;rsort($a),print$a[1]._)$a[]=$argv[$i];（54个字节）

Mathematica 42字节

独立得出的答案非常类似于@Jenny_mathy，但短了3个字节

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

意识到第一次运行最大值仅占用15个字节和两个函数调用！：

Max~FoldList~#&

可以如此简洁地完成此操作，因为Max具有属性Flat，OneIdentity但对于RankedMax逻辑替换而言这。不幸的是，定义属性或在现有函数上对其进行修改会占用太多字节，因此必须通过其他方式进行展平。

可以在48个字节中找到所有第n个运行最大值：

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

Pyth，15个字节

FNr2hlQ@_S<QN1

在这里尝试：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

说明

FNr2hlQ -对于带有计数器2的循环<= N <=列表长度

@_S<QN1 -当列表的前N个元素按升序排序然后颠倒（按降序排序）时的第二个元素

k，13个字节

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

在线尝试！

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

八度，51字节

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

-返回第一个元素的任意值。

在线尝试！

JavaScript（ES6），43 51字节

编辑： 由于需要数字排序，因此增加了8个字节。 :(

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

不过，将其保留在这里，因为如果希望按字典顺序进行排序，它会更短：

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

这两个表达式都产生undefined第一个元素。

测试码

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个字节

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

也许有更好的方法来生成这些前缀。