Memasukkan:

Urutan bilangan bulat yang tidak kosong lebih besar dari nol, yang panjangnya lebih besar dari 1.

Keluaran:

Produk terbesar dari semua elemen urutan terpanjang antara elemen minimum dan maksimum urutan termasuk mereka.

catatan:

Karena elemen minimum dan maksimum dapat diulangi, maka untuk jawaban yang pasti diperlukan untuk menemukan urutan terpanjang yang mungkin, di satu ujung yang merupakan minimum dan di ujung lainnya elemen maksimum dari urutan. Jika ada beberapa urutan terpanjang kemudian pilih urutan dengan produk terbesar.

Contoh:

Contoh 1:

Memasukkan: [5, 7, 3, 2, 1, 2, 2, 7, 5]

Keluaran: 42

Penjelasan: min == 1, max == 7. Ada 2 kemungkinan kemungkinan dengan min dan maks pada ujung: [1, 2, 2, 7]dan [7, 3, 2, 1]. Panjangnya sama, jadi membandingkan produk: 7*3*2*1 == 42dan 1*2*2*7 == 28. Karena 42 >= 28, jawabannya: 42.

Contoh 2:

Memasukkan: [1, 2, 2, 2, 4, 3, 3, 1]

Keluaran: 32

Penjelasan: min == 1, max == 4. 2 urutan: [1, 2, 2, 2, 4]dan [4, 3, 3, 1]. Panjang [1, 2, 2, 2, 4]lebih besar dari panjang [4, 3, 3, 1]. produk: 1*2*2*2*4 == 32=> jawabannya adalah 32.

Contoh 3d:

Memasukkan: [1, 2, 3, 4, 3, 3, 1]

Keluaran: 36

Penjelasan singkat: min == 1, max == 4. 2 urutan: [1, 2, 3, 4]dan [4, 3, 3, 1]. 1*2*3*4 == 24, 4*3*3*1 == 36, 36 >= 24=> Jawabannya adalah 36.

Contoh 4:

Memasukkan: [2, 2, 2]

Keluaran: 8

Penjelasan: min == 2, max == 2. 2 urutan berbeda: [2, 2]dan [2, 2, 2]. Panjang [2, 2, 2]lebih besar dari panjang [2, 2]. produk: 2*2*2 == 8=> jawabannya adalah 8.

Lebih banyak contoh (acak) :

>>>[7, 2, 3, 6, 8, 6, 2, 5, 4, 3]
288
>>>[3, 3, 8, 9, 1, 7, 7, 2, 2, 4]
9
>>>[3, 2, 6, 5, 4, 1, 8, 8, 7, 9]
4032
>>>[7, 4, 2, 8, 8, 3, 9, 9, 5, 6]
31104

Periksa solusi Anda:

Berikut adalah Python 3 lambda (788 byte) , yang memenuhi persyaratan tugas:

lambda O: __import__('functools').reduce(__import__('operator').mul,O[[[slice(O.index(max(O)),len(O)-1-O[::-1].index(min(O))+1),slice(O.index(min(O)),(len(O)-1-O[::-1].index(max(O)))+1)][__import__('functools').reduce(__import__('operator').mul,O[O.index(min(O)):(len(O)-1-O[::-1].index(max(O)))+1],1)>=__import__('functools').reduce(__import__('operator').mul,O[O.index(max(O)):len(O)-1-O[::-1].index(min(O))+1],1)],slice(O.index(min(O)),(len(O)-1-O[::-1].index(max(O)))+1),slice(O.index(max(O)),len(O)-1-O[::-1].index(min(O))+1)][(len(range(O.index(min(O)),(len(O)-1-O[::-1].index(max(O)))+1))>len(range(O.index(max(O)),len(O)-1-O[::-1].index(min(O))+1)))-(len(range(O.index(min(O)),(len(O)-1-O[::-1].index(max(O)))+1))<len(range(O.index(max(O)),len(O)-1-O[::-1].index(min(O))+1)))]],1)

Pemenang:

Solusi terpendek akan menang. Semua bahasa pemrograman diterima.

PS: Saya akan senang dengan penjelasan dari solusi Anda

Jelly , 14 byte

.ịạ/;L;P
ẆÇ€ṀṪ

Cobalah online!

Bagaimana itu bekerja

ẆÇ€ṀṪ     Main link. Argument: A (array)

Ẇ         Window; generate all substrings of A.
 ǀ       Map the helper link over the substrings.
   Ṁ      Take the maximum.
    Ṫ     Tail; select the last element.


.ịạ/;L;P  Helper link. Argument: S (array / substring)

.ị        At-index 0.5; select the last and first element of S.
  ạ/      Reduce by absolute difference.
    ;L    Append the length of S.
      ;P  Append the product of S.

Jelly , 15 byte

NMpMr/€LÐṀịµP€Ṁ

TryItOnline!

Bagaimana?

NMpMr/€LÐṀịµP€Ṁ - Main link: list of integers, L
           µ    - links to the left as a monadic chain with argument L
N               - negate elements of L
 M              - indexes of maximal elements (i.e. indexes of minimal elements of L)
   M            - indexes of maximal elements of L
  p             - Cartesian product of the min and max indexes
     /€         - reduce each list (all of which are pairs) with the dyad:
    r           -     range(a,b)  (note if a>b this is [a,a-1,...,b])
        ÐṀ      - filter keeping those with maximal
       L        -     length
          ị     - index into L (vectorises)   (get the values)
            P€  - product of a list for €ach
              Ṁ - maximum

Perl 6 , 108 byte

{max ([*] $_ for .[.grep(+.max(+*)) with (for .min,.max,.max,.min {.first($^a,:k).. .first($^b,:k,:end)})])}

R, 146 byte

z=apply(expand.grid(which(max(x<-scan())==x),which(min(x)==x)),1,function(y)c(prod(x[y[1]:y[2]]),abs(diff(y))));max(z[1,which(z[2,]==max(z[2,]))])

Tantangan rumit karena persyaratan panjang. Juga menjengkelkan karena calon yang berguna which.maxhanya mengembalikan indeks maksimum pertama yang ditemui, memaksaku untuk menggunakan which(max(x)==x)... 3 kali. Baiklah...

Dapat dibaca:

x <- scan()

maxs <- which(max(x)==x)
mins <- which(min(x)==x)
q <- expand.grid(maxs,mins)
z <- apply(q,1,function(y){
  c(prod(x[y[1]:y[2]]), abs(diff(y)))
  })

max(z[1, which(z[2, ]==max(z[2, ]))])

PHP, 189 173 166 byte

<?foreach($a=$_GET[a]as$p=>$b)foreach($a as$q=>$c)$b>min($a)|$c<max($a)?:$r[$d=abs($p-$q)+1]=array_product(array_slice($a,min($p,$q),$d));ksort($r);echo max(end($r));

sama malas tetapi 33 byte lebih pendek (harus menambahkan 10 byte untuk mengubah potongan menjadi sebuah program):

1. Loop $p/$bdan $q/$cmelalui array; jika $b==mindan $c==max,
   tambahkan produk dari sub-urutan ke$r[sub-sequence length]
2. Sortir $rmenurut kunci.
3. Cetak nilai maksimum elemen terakhir.

Panggil browser dengan array sebagai parameter GET a.
Contoh:script.php?a[]=5&a[]=7&a[]=3&a[]=2&a[]=1&a[]=2&a[]=2&a[]=7&a[]=5

Mathematica, 122 byte

(g=#;Sort[{#.{-1,1},Times@@Take[g,#]}&/@Sort/@Join@@Outer[List,Sequence@@(Union@@Position[g,#@g]&/@{Max,Min})]][[-1,-1]])&

Terkejut berapa lama ini ternyata. Pertama menghasilkan produk Cartesian dari penampilan minima dan maxima (sesuai jawaban Jonathan Allan's Jelly ), kemudian menghitung panjang run tersebut dan produk mereka, dan memilih yang sesuai dengan mengambil elemen terakhir dari hasil yang diurutkan.

JavaScript, 187 byte

f=
(l,M=Math,a=M.min(...l),z=M.max(...l),r=(m,n)=>[eval(l.slice(b=l.indexOf(m),c=l.lastIndexOf(n)+1).join`*`),M.abs(b-c)])=>(u=r(a,z),v=r(z,a),u[1]>v[1]?u[0]:v[1]>u[1]?v[0]:M.max(v[0],u[0]))


console.log([
  [5, 7, 3, 2, 1, 2, 2, 7, 5],
  [1, 2, 2, 2, 4, 3, 3, 1],
  [1, 2, 3, 4, 3, 3, 1],
  [2, 2, 2],
  [7, 2, 3, 6, 8, 6, 2, 5, 4, 3],
  [3, 3, 8, 9, 1, 7, 7, 2, 2, 4],
  [3, 2, 6, 5, 4, 1, 8, 8, 7, 9],
  [7, 4, 2, 8, 8, 3, 9, 9, 5, 6]
].map(a=>`[${a}] => ${f(a)}`).join`
`)