Đầu vào:

Một dãy số nguyên không rỗng lớn hơn 0, độ dài của nó lớn hơn 1.

Đầu ra:

Sản phẩm lớn nhất của tất cả các yếu tố của chuỗi dài nhất giữa các yếu tố tối thiểu và tối đa của chuỗi bao gồm cả chính chúng.

Chú thích:

Bởi vì các phần tử tối thiểu và tối đa có thể được lặp lại, sau đó đến một câu trả lời xác định cần thiết để tìm ra phần tử dài nhất có thể, ở một đầu của nó là phần tử tối thiểu và ở phần cuối tối đa khác của chuỗi. Nếu có nhiều chuỗi con dài nhất thì hãy chọn chuỗi con với sản phẩm lớn nhất.

Ví dụ:

Ví dụ thứ nhất:

Đầu vào: [5, 7, 3, 2, 1, 2, 2, 7, 5]

Đầu ra: 42

Giải thích: min == 1, max == 7. Có 2 chuỗi con có thể có tối thiểu và tối đa ở cuối: [1, 2, 2, 7]và [7, 3, 2, 1]. Chiều dài của chúng là bằng nhau, vì vậy so sánh các sản phẩm: 7*3*2*1 == 42và 1*2*2*7 == 28. Bởi vì 42 >= 28, trả lời : 42.

Ví dụ thứ 2:

Đầu vào: [1, 2, 2, 2, 4, 3, 3, 1]

Đầu ra: 32

Giải thích: min == 1, max == 4. 2 phần sau: [1, 2, 2, 2, 4]và [4, 3, 3, 1]. Chiều dài [1, 2, 2, 2, 4]lớn hơn chiều dài [4, 3, 3, 1]. sản phẩm: 1*2*2*2*4 == 32=> câu trả lời là 32.

Ví dụ 3d:

Đầu vào: [1, 2, 3, 4, 3, 3, 1]

Đầu ra: 36

Giải thích ngắn: min == 1, max == 4. 2 phần sau: [1, 2, 3, 4]và [4, 3, 3, 1]. 1*2*3*4 == 24, 4*3*3*1 == 36, 36 >= 24=> Câu trả lời là 36.

Ví dụ thứ 4:

Đầu vào: [2, 2, 2]

Đầu ra: 8

Giải thích: min == 2, max == 2. 2 phần sau khác nhau: [2, 2]và [2, 2, 2]. Chiều dài [2, 2, 2]lớn hơn chiều dài [2, 2]. sản phẩm: 2*2*2 == 8=> câu trả lời là 8.

Thêm ví dụ (ngẫu nhiên) :

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

Kiểm tra giải pháp của bạn:

Dưới đây là Python 3 lambda (788 byte) , đáp ứng yêu cầu của nhiệm vụ:

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)

Người chiến thắng:

Giải pháp ngắn nhất sẽ giành chiến thắng. Tất cả các ngôn ngữ lập trình được chấp nhận.

Tái bút: Tôi sẽ rất vui khi được giải thích về các giải pháp của bạn

Thạch , 14 byte

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

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

Làm thế nào nó hoạt động

ẆÇ€ṀṪ     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.

Thạch , 15 byte

NMpMr/€LÐṀịµP€Ṁ

Dùng thử trực tuyến!

Làm sao?

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

Thử thách khó khăn vì yêu cầu chiều dài. Cũng khó chịu vì nội dung hữu ích which.maxsẽ chỉ trả về chỉ số của mức tối đa đầu tiên mà nó gặp phải, buộc tôi phải sử dụng which(max(x)==x)thay vì ... 3 lần. Ồ ...

Có thể đọc được

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

tương tự lười biếng nhưng ngắn hơn 33 byte (phải thêm 10 byte để biến đoạn mã thành chương trình):

1. Vòng lặp $p/$bvà $q/$cthông qua các mảng; nếu $b==minvà $c==max,
   thêm sản phẩm của chuỗi con vào$r[sub-sequence length]
2. Sắp xếp $rtheo các phím.
3. In giá trị tối đa của phần tử cuối cùng.

Gọi trong trình duyệt với mảng là tham số GET a.
Thí dụ:script.php?a[]=5&a[]=7&a[]=3&a[]=2&a[]=1&a[]=2&a[]=2&a[]=7&a[]=5

Toán học, 122 byte

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

Ngạc nhiên bao lâu điều này hóa ra. Đầu tiên tạo ra sản phẩm của Cartesian về sự xuất hiện của cực tiểu và cực đại (theo câu trả lời Jelly của Jonathan Allan ), sau đó tính độ dài của các lần chạy đó và các sản phẩm của chúng, và chọn một sản phẩm phù hợp bằng cách lấy yếu tố cuối cùng của kết quả được sắp xếp.

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