Tamsayıların bir listesi verildiğinde, göreviniz ilk k öğelerindeki ikinci en büyük değeri , her k için 2 ile giriş listesinin uzunluğu arasında çıktı almaktır.

Başka bir deyişle, girdinin her öneki için ikinci en büyük değeri girin.

İlk eleman için rasgele bir değer çıktısı alabilirsiniz (burada k = 1) veya 1 elemanlık bir liste için ikinci bir maksimum olmadığından bu değeri atlayabilirsiniz. Girişte en az 2 öğe olduğunu varsayabilirsiniz.

En kısa kod kazanır.

Örnekler

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 bayt

ηεà\à

Çevrimiçi deneyin!

[]İlk olarak (rasgele değer) döndürür .

Kabuk , 9 7 bayt

@Zgarb sayesinde bir veya iki bayt kaydetti

mȯ→hOtḣ

0İlk "ikinci maksimum" değerini döndürür

Açıklama

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

Çevrimiçi deneyin!

Python 2 , 54 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 58 51 50 bayt

@Neil sayesinde 1 bayt kaydedildi

K = 1undefined için eklenir .

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

Test senaryoları

Not: Bu pasaj, JSON.stringify()yan etki olarak dönüştürülen okunabilirlik undefinediçin kullanılır 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 bayt

m@Sd_2._

Çevrimiçi deneyin! veya Test Suite'i deneyin!

Nasıl?

Bu, özelliğe göre listenin ilk öğesini listedeki ilk değer olarak verir. İlk öğe için isteğe bağlı bir değer çıktısı alabilirsiniz .

m@Sd_2._ - Örtük girdili tam program.

m ._Q - d değişkeniyle girişin öneklerini eşleyin.
  Sd - Geçerli öneki sıralar.
 @ - Öğeyi alır ...
    _2 - İndekste - 2 (en yüksek ikinci).
           - Örtük olarak yazdırın.

Jöle , 8 bayt

ḣJṢ€Ṗ€Ṫ€

Çevrimiçi deneyin!

İlk değer her zaman 0 olur ve aşağıdaki sayılar her ön ekin ikinci maksimumları olur.

açıklama

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

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

Çevrimiçi deneyin!

Python 2 , 45 bayt

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

Çevrimiçi deneyin!

Kodun sağ tarafı açıklayıcıdır. Ancak, soluna ne koyarız and? Bir listenin bölümlerini yinelemeli olarak birleştirdiğimiz için l, 2 veya daha fazla öğeye sahipse sol tarafın doğru olması ve aksi takdirde boş bir listeye ihtiyacımız vardır. l[1:]bu kriteri iyi karşılar.

C # (Mono) , 81 bayt

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

Çevrimiçi deneyin!

Brachylog , 10 bayt

a₀ᶠb{okt}ᵐ

Çevrimiçi deneyin!

Toplu, 123 bayt

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

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

Çevrimiçi deneyin!

05AB1E , 5 bayt

Erik'in çözümünden çok farklı bir 5 bayt daha buldum . Rasgele değer listenin ilk öğesidir.

ηε{Áθ

Çevrimiçi deneyin!

açıklama

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

Anlaşmayı kolaylaştırmak için bir örnek alalım.

• İlk olarak örtük girdiyi alıyoruz, diyelim [1, 5, 2, 3, 5, 9, 5, 8].

• Sonra biz kullanarak önekleri itmek η- [[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]].

• Şimdi, kod listeyi eşler ve {- ile her öneki sıralar [[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]].

• Sonra en son eleman alıp başına hareket: [[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]].

• Tabii ki, şimdi kod θ- kullanarak her alt listenin son öğesini alır [1, 1, 2, 3, 5, 5, 5, 8](ilki rastgele değerdir.

CJam , 16 bayt

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

Çevrimiçi deneyin!

İlk öğe için ilk öğeyi döndürür.

-2 Challenger5 sayesinde .

R , 54 49 bayt

Giuseppe -5 bayt teşekkürler . Ben bu özelliğini bilmiyordum seq().

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

Çevrimiçi deneyin!

Japt , 12 10 bayt

Çıkış dizisi, giriş dizisindeki ilk öğeden sonra istenen diziden oluşur.

£¯YÄ n< g1

Dene

açıklama

Örtülü dizi girişi U.

£

Harita üzerinde U, Ygeçerli dizin nerede .

¯YÄ

Dilim Ugelen 0etmek Y+1.

n<

Azalan şekilde sırala.

g1

İkinci unsuru alın.

Ortaya çıkan diziyi dolaylı olarak çıktılar.

Matl , 19 10 bayt

9 byte'ı tıraş ettiği için Luis Mendo'ya teşekkürler!

"GX@:)SP2)

Dene Burada .

açıklama

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

_2&{@/:~ ::#\

Çevrimiçi deneyin!İlk eleman daima 1'dir.

açıklama

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

Alan önemlidir.

Ohm , 10 8 bayt

ETHproductions sayesinde -2 bayt.

∙p»îS2~ª

Çevrimiçi deneyin!

Ah, ... Bu garip ama negatif bir sayı itmek başka nasıl bilmiyorum ben yok gerçekten Ohm biliyorum. : P

Mathematica, 45 bayt

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

Swift 3 , 67 bayt

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

Test odası.

Swift 3 , 65 bayt

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

Test odası.

Bunları nasıl çalıştırırım?

Birincisi, girdiyi işlev parametresi olarak alan ve sonucu basan eksiksiz bir işlevdir. Bunları tam olarak test bağlantısında gösterildiği gibi kullanabilirsiniz. Yine de talimatlar eklemeye karar verdim, çünkü ikinci tip fonksiyon çok nadiren kullanılıyor ve çoğu insan varlığını bile bilmiyor. Kullanımı:

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

İkincisi, lambdalar gibi anonim bir işlevdir. Bir değişkeni bildirip fçağırmak için tam olarak yaptığınız gibi Python kullanabilirsiniz :

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

veya parantez arasına sarın ve doğrudan çağırın ( (...)(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 bayt

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

komut satırı bağımsız değişkenlerinden girdi alır. Çıktı sınırlandırılmış, kurşun ve noktalı virgül tarafından izlenir.
Birlikte çalışın-nr veya çevrimiçi deneyin .

PHP 7.1'de bir uyarı verir; düzeltmek için a&ile değiştirin ""<.
Veya kullanın for(;++$i<$argc;rsort($a),print$a[1]._)$a[]=$argv[$i];(54 bayt)

Mathematica 42 Bayt

Bağımsız olarak @Jenny_mathy çok benzer bir cevap geldi ama 3 bayt daha kısa

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

İlk çalıştırma maksimum değerinin yalnızca 15 bayt ve iki işlev çağrısı aldığını fark etti !:

Max~FoldList~#&

Bu çok kısaca yapılabilir Max, çünkü nitelikleri vardır Flatve OneIdentitybu doğru değildirRankedMax bu mantıksal yerine geçecek olan . Ne yazık ki nitelikleri tanımlamak veya mevcut işlevler üzerinde değiştirmek çok fazla bayt gerektirir, bu nedenle düzleştirme başka yollarla yapılmalıdır.

Tüm n. Çalışma maksimumları 48 baytta bulunabilir:

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

Pyth, 15 bayt

FNr2hlQ@_S<QN1

Burada deneyin: 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 ve ayıklama = 0

açıklama

FNr2hlQ - Sayaç 2'ye sahip döngü için <= N <= liste uzunluğu

@_S<QN1 - Listenin ilk N öğesi artan sırada ve sonra ters çevrildiğinde (azalan sırada sıralanmış) 2. öğe

k , 13 bayt

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

Çevrimiçi deneyin!

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

Oktav, 51 bayt

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

- İlk öğe için rastgele bir değer döndürüldü.

Çevrimiçi deneyin!

JavaScript (ES6), 43 51 bayt

Düzenleme: Sayısal sıralama istendiğinden 8 bayt eklendi. :(

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

Bununla birlikte, burada tutmak, sözlükbilimsel düzen istiyorsa daha kısa olduğu için:

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

Her iki ifade undefinedde ilk öğe için üretilir.

Test kodu

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 bayt

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

Belki de bu önekleri oluşturmanın daha iyi bir yolu vardır.