Đưa ra một danh sách các số nguyên, nhiệm vụ của bạn là xuất giá trị lớn thứ hai trong các phần tử k đầu tiên , cho mỗi k giữa 2 và độ dài của danh sách đầu vào.

Nói cách khác, xuất giá trị lớn thứ hai cho mỗi tiền tố của đầu vào.

Bạn có thể xuất giá trị tùy ý cho phần tử đầu tiên (trong đó k = 1) hoặc chỉ cần bỏ qua giá trị này, vì không có giá trị tối đa thứ hai cho danh sách 1 phần tử. Bạn có thể giả sử có ít nhất 2 yếu tố trong đầu vào.

Mã ngắn nhất sẽ thắng.

Ví dụ

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 byte

ηεà\à

Hãy thử trực tuyến!

Trả về [](giá trị tùy ý) cho lần đầu tiên.

Chồng , 9 7 byte

Đã lưu một hoặc hai byte nhờ @Zgarb

mȯ→hOtḣ

Trả về 0"tối đa thứ hai" đầu tiên

Giải thích

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

Hãy thử trực tuyến!

Python 2 , 54 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 58 51 50 byte

Đã lưu 1 byte nhờ @Neil

Áp undefineddụng cho k = 1 .

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

Các trường hợp thử nghiệm

NB: Đoạn mã này sử dụng JSON.stringify()cho khả năng đọc, mà - như một tác dụng phụ - chuyển đổi undefinedthành 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

Bình thường , 8 byte

m@Sd_2._

Hãy thử trực tuyến! hoặc dùng thử Test Suite!

Làm sao?

Điều này xuất ra phần tử đầu tiên của danh sách làm giá trị đầu tiên trong danh sách, theo thông số kỹ thuật Bạn có thể xuất giá trị tùy ý cho phần tử đầu tiên .

m@Sd_2._ - Chương trình đầy đủ với đầu vào ẩn.

m ._Q - Ánh xạ qua các tiền tố của đầu vào với một biến d.
  Sd - Sắp xếp tiền tố hiện tại.
 @ - Lấy phần tử ...
    _2 - Tại chỉ mục - 2 (cao thứ hai).
           - In ngầm.

Thạch , 8 byte

ḣJṢ€Ṗ€Ṫ€

Hãy thử trực tuyến!

Giá trị đầu tiên sẽ là 0, luôn luôn và các số sau sẽ là mức tối đa thứ hai của mỗi tiền tố.

Giải trình

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

Hãy thử trực tuyến!

Python 2 , 45 byte

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

Hãy thử trực tuyến!

Phía bên phải của mã là tự giải thích. Tuy nhiên, những gì chúng ta đặt bên trái của and? Bởi vì chúng tôi đang ghép các phần của một danh sách theo cách đệ quy, chúng tôi cần bên trái phải trung thực nếu lcó 2 hoặc nhiều phần tử và một danh sách trống khác. l[1:]đáp ứng tiêu chí này độc đáo

C # (Mono) , 81 byte

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

Hãy thử trực tuyến!

Brachylog , 10 byte

a₀ᶠb{okt}ᵐ

Hãy thử trực tuyến!

Hàng loạt, 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%

APL (Dyalog) , 15 byte

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

Hãy thử trực tuyến!

05AB1E , 5 byte

Tìm thấy 5 -terter khác, rất khác với giải pháp của Erik . Giá trị tùy ý là yếu tố đầu tiên của danh sách.

ηε{Áθ

Hãy thử trực tuyến!

Giải trình

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

Hãy lấy một ví dụ, để dễ hiểu hơn.

• Đầu tiên chúng ta có đầu vào ngầm, giả sử nó [1, 5, 2, 3, 5, 9, 5, 8].

• Sau đó, chúng tôi đẩy tiền tố của nó bằng cách sử dụng η- [[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]].

• Bây giờ, mã ánh xạ qua danh sách và sắp xếp từng tiền tố bằng cách sử dụng {- [[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]].

• Sau đó chúng tôi lấy phần tử cuối cùng và chuyển nó về đầu : [[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]].

• Tất nhiên, bây giờ mã nhận phần tử cuối cùng của mỗi danh sách con bằng cách sử dụng θ- [1, 1, 2, 3, 5, 5, 5, 8](cái đầu tiên là giá trị tùy ý.

CJam , 16 byte

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

Hãy thử trực tuyến!

Trả về phần tử đầu tiên cho đầu tiên.

-2 nhờ Challenger5 .

R , 54 49 byte

Nhờ Giuseppe -5 byte. Tôi không biết tính năng này của seq().

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

Hãy thử trực tuyến!

Japt , 12 10 byte

Mảng đầu ra bao gồm phần tử đầu tiên trong mảng đầu vào theo sau là chuỗi mong muốn.

£¯YÄ n< g1

Kiểm tra nó

Giải trình

Đầu vào ngầm định của mảng U.

£

Bản đồ trên U, Ychỉ số hiện tại.

¯YÄ

Lát Utừ 0đến Y+1.

n<

Sắp xếp giảm dần.

g1

Lấy phần tử thứ hai.

Ngẫu nhiên xuất ra mảng kết quả.

MATL , 19 10 byte

Cảm ơn Luis Mendo đã cạo sạch 9 byte!

"GX@:)SP2)

Hãy thử nó ở đây .

Giải trình

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

_2&{@/:~ ::#\

Hãy thử trực tuyến! Phần tử đầu tiên luôn là 1.

Giải trình

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

Các vấn đề không gian.

Ồ , 10 8 byte

-2 byte nhờ vào ETHproductions.

∙p»îS2~ª

Hãy thử trực tuyến!

Uh, điều này thật kỳ quặc nhưng tôi không biết làm cách nào khác để đẩy số âm ... Tôi thực sự không biết Ohm. : P

Toán học, 45 byte

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

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Swift 3 , 67 byte

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

Phòng thử nghiệm.

Swift 3 , 65 byte

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

Phòng thử nghiệm.

Làm thế nào để chạy những cái này?

Cái đầu tiên là một hàm hoàn chỉnh lấy đầu vào làm tham số hàm và in kết quả. Bạn có thể sử dụng chúng chính xác như được hiển thị trong liên kết thử nghiệm. Tôi đã quyết định thêm hướng dẫn, bởi vì loại chức năng thứ hai rất hiếm khi được sử dụng và hầu hết mọi người thậm chí không biết đến sự tồn tại của nó. Sử dụng:

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

Cái thứ hai là một hàm ẩn danh, giống như lambdas. Bạn có thể sử dụng nó chính xác như bạn làm Python, khai báo một biến fvà gọi nó:

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

hoặc bọc nó giữa các dấu ngoặc và gọi nó trực tiếp ( (...)(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 byte

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

lấy đầu vào từ các đối số dòng lệnh. Đầu ra được phân định, dẫn và theo dấu chấm phẩy.
Chạy với -nrhoặc thử trực tuyến .

Đưa ra một cảnh báo trong PHP 7.1; thay thế a&với ""<việc sửa chữa.
Hoặc sử dụng for(;++$i<$argc;rsort($a),print$a[1]._)$a[]=$argv[$i];(54 byte)

Toán học 42 byte

Độc lập đi đến một câu trả lời rất giống với @Jenny_mathy nhưng ngắn hơn 3 byte

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

Nhận ra rằng tối đa chạy đầu tiên chỉ mất 15 byte và hai lệnh gọi hàm!:

Max~FoldList~#&

Điều này có thể được thực hiện rất chính xác vì Maxcó các thuộc tính Flatvà OneIdentitynhưng điều đó không đúng vớiRankedMax sự thay thế logic. Thật không may, việc xác định các thuộc tính hoặc sửa đổi chúng trên các hàm hiện có chiếm quá nhiều byte, do đó việc làm phẳng phải được thực hiện bằng các phương tiện khác.

Tất cả các mức tối đa chạy thứ n có thể được tìm thấy trong 48 byte:

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

Bình thường, 15 byte

FNr2hlQ@_S<QN1

Hãy dùng thử tại đây: 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 & gỡ lỗi = 0

Giải trình

FNr2hlQ - Đối với vòng lặp có bộ đếm 2 <= N <= chiều dài danh sách

@_S<QN1 - Phần tử thứ 2 khi các phần tử N đầu tiên của danh sách được sắp xếp theo thứ tự tăng dần và sau đó đảo ngược (được sắp xếp theo thứ tự giảm dần)

k , 13 byte

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

Hãy thử trực tuyến!

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

Octave, 51 byte

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

- Một giá trị tùy ý trả về cho phần tử đầu tiên.

Hãy thử trực tuyến!

JavaScript (ES6), 43 51 byte

Chỉnh sửa: Đã thêm 8 byte kể từ khi sắp xếp số. :(

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

Tuy nhiên, giữ cái này ở đây, vì nó ngắn hơn cung cấp một người muốn đặt hàng từ điển:

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

Cả hai biểu thức sản xuất undefined cho phần tử đầu tiên.

Mã kiểm tra

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 byte

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

Có lẽ có một cách tốt hơn để tạo ra các tiền tố đó.