รับรายการของจำนวนเต็มงานของคุณคือการส่งออกค่าที่ใหญ่ที่สุดที่สองในองค์ประกอบkแรกสำหรับแต่ละkระหว่าง 2 และความยาวของรายการอินพุต

กล่าวอีกนัยหนึ่งเอาท์พุทค่าที่ใหญ่เป็นอันดับสองสำหรับแต่ละคำนำหน้าของอินพุต

คุณสามารถส่งออกค่าตามอำเภอใจสำหรับองค์ประกอบแรก (โดยที่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 ไบต์

ηεà\à

ลองออนไลน์!

ผลตอบแทน[](ค่าโดยพลการ) สำหรับครั้งแรก

Husk , 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 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ@Neil

ผนวกundefinedสำหรับk = 1

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

กรณีทดสอบ

การใช้ข้อมูลโค้ดนี้: NB JSON.stringify()สำหรับการอ่านซึ่ง - เป็นผลข้างเคียง - แปลงไปundefinednull

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มีองค์ประกอบ 2 รายการขึ้นไปและรายการว่างเปล่าเป็นอย่างอื่น l[1:]ตอบสนองเกณฑ์นี้ได้เป็นอย่างดี

C # (Mono) , 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 byter, มากแตกต่างจากวิธีการแก้ปัญหาของเอริค ค่าโดยพลการเป็นองค์ประกอบแรกของรายการ

ηε{Áθ

ลองออนไลน์!

คำอธิบาย

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

ลองออนไลน์!

ส่งคืนองค์ประกอบแรกสำหรับครั้งแรก

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

Slice Uจากไป0Y+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 bytes

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

รับอินพุตจากอาร์กิวเมนต์บรรทัดรับคำสั่ง เอาท์พุทคั่นนำและตามรอยโดย semicola
ทำงานด้วย-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@#}&

รับรู้ว่าการทำงานสูงสุดครั้งที่ 1 ใช้เวลาเพียง 15 ไบต์และการเรียกใช้ฟังก์ชันสองครั้ง!:

Max~FoldList~#&

สิ่งนี้สามารถสรุปได้อย่างชัดเจนเพราะMaxมีคุณสมบัติFlatและOneIdentityไม่เป็นความจริงRankedMaxที่จะเป็นการทดแทนแบบตรรกะ น่าเสียดายที่การกำหนดคุณลักษณะหรือปรับเปลี่ยนพวกเขาในฟังก์ชั่นที่มีอยู่ใช้จำนวนไบต์มากเกินไปดังนั้นการแบนจะต้องทำโดยวิธีอื่น

maxs ที่ทำงานทั้งหมดที่ n สามารถพบได้ใน 48 ไบต์:

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 และการแก้ปัญหา = 0

คำอธิบาย

FNr2hlQ - สำหรับลูปที่มีตัวนับ 2 <= N <= ความยาวของรายการ

@_S<QN1 - องค์ประกอบที่ 2 เมื่อองค์ประกอบ 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))

อาจมีวิธีที่ดีกว่าในการสร้างคำนำหน้าเหล่านั้น