การป้อนข้อมูล:

ลำดับที่ไม่ว่างของจำนวนเต็มมากกว่าศูนย์ความยาวซึ่งมากกว่า 1

เอาท์พุท:

ผลิตภัณฑ์ที่ใหญ่ที่สุดขององค์ประกอบทั้งหมดของการเรียงลำดับที่ยาวที่สุดระหว่างองค์ประกอบขั้นต่ำและสูงสุดของลำดับรวมถึงตัวเอง

บันทึก:

เนื่องจากองค์ประกอบขั้นต่ำและสูงสุดสามารถทำซ้ำได้ดังนั้นจึงจำเป็นต้องหาคำตอบที่ชัดเจนเพื่อหาองค์ประกอบที่เป็นไปได้ที่ยาวที่สุดที่ปลายด้านหนึ่งซึ่งเป็นค่าต่ำสุดและที่ส่วนอื่น ๆ ของลำดับสูงสุด หากมีหลายองค์ประกอบที่ยาวที่สุดให้เลือกส่วนประกอบที่มีผลิตภัณฑ์ที่ใหญ่ที่สุด

ตัวอย่าง:

ตัวอย่างที่ 1:

การป้อนข้อมูล: [5, 7, 3, 2, 1, 2, 2, 7, 5]

เอาท์พุท: 42

คำอธิบาย: min == 1, max == 7. มี 2 subsequences ไปได้ด้วยนาทีและสูงสุดที่ปลายคือและ[1, 2, 2, 7] [7, 3, 2, 1]ความยาวของพวกเขาคือเท่ากันดังนั้นการเปรียบเทียบผลิตภัณฑ์และ7*3*2*1 == 42 1*2*2*7 == 28เพราะ42 >= 28คำตอบ: 42.

ตัวอย่างที่ 2:

การป้อนข้อมูล: [1, 2, 2, 2, 4, 3, 3, 1]

เอาท์พุท: 32

คำอธิบาย: min == 1, max == 4. 2 subsequences: และ[1, 2, 2, 2, 4] [4, 3, 3, 1]ความยาวของมีค่ามากกว่าความยาวของ[1, 2, 2, 2, 4] [4, 3, 3, 1]ผลิตภัณฑ์: 1*2*2*2*4 == 32=> 32คำตอบคือ

ตัวอย่าง 3 มิติ:

การป้อนข้อมูล: [1, 2, 3, 4, 3, 3, 1]

เอาท์พุท: 36

คำอธิบายสั้น ๆ : min == 1 , max == 4. 2 subsequences: และ[1, 2, 3, 4] , , => คำตอบคือ[4, 3, 3, 1]1*2*3*4 == 244*3*3*1 == 3636 >= 2436

ตัวอย่างที่ 4:

การป้อนข้อมูล: [2, 2, 2]

เอาท์พุท: 8

คำอธิบาย: min == 2, max == 2. 2 subsequences ที่แตกต่างกันและ[2, 2] [2, 2, 2]ความยาวของ[2, 2, 2][2, 2]มีค่ามากกว่าความยาวของ ผลิตภัณฑ์: 2*2*2 == 8=> 8คำตอบคือ

มากกว่า (สุ่ม) :

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

ตรวจสอบทางออกของคุณ:

นี่คือ Python 3 แลมบ์ดา(788 ไบต์)ซึ่งตอบสนองความต้องการของงาน:

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)

ผู้ชนะ:

ทางออกที่สั้นที่สุดจะเป็นผู้ชนะ ทุกภาษาการเขียนโปรแกรมได้รับการยอมรับ

PS: ฉันยินดีที่จะอธิบายการแก้ปัญหาของคุณ

เยลลี่ขนาด 14 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร

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

เยลลี่ 15 ไบต์

NMpMr/€LÐṀịµP€Ṁ

TryItOnline!

อย่างไร?

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

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

R, 146 ไบต์

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

ความท้าทายหากินเนื่องจากความต้องการความยาว ยังน่ารำคาญเพราะบิวด์อินที่มีประโยชน์which.maxจะส่งกลับเฉพาะดัชนีสูงสุดอันดับแรกที่พบเท่านั้นซึ่งบังคับให้ฉันใช้which(max(x)==x)แทน ... 3 ครั้ง Ohwell ...

อ่านได้:

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

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

สันหลังยาวคล้าย ๆ กัน แต่สั้นกว่า 33 ไบต์ (ต้องเพิ่ม 10 ไบต์เพื่อเปลี่ยนข้อมูลย่อยเป็นโปรแกรม):

1. วนซ้ำ$p/$bและ$q/$cผ่านอาร์เรย์ ถ้า$b==minและ$c==max,
   เพิ่มสินค้าย่อยลำดับ$r[sub-sequence length]
2. จัดเรียง$rตามกุญแจ
3. พิมพ์ค่าสูงสุดขององค์ประกอบสุดท้าย

โทรในเบราว์เซอร์กับอาร์เรย์เป็น GET aพารามิเตอร์
ตัวอย่าง:script.php?a[]=5&a[]=7&a[]=3&a[]=2&a[]=1&a[]=2&a[]=2&a[]=7&a[]=5

Mathematica, 122 ไบต์

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

แปลกใจว่ามันจะนานแค่ไหน ขั้นแรกสร้างผลิตภัณฑ์คาร์ทีเซียนของรูปลักษณ์ของ minima และ maxima (ตามคำตอบ Jelly ของ Jonathan Allan ) จากนั้นคำนวณความยาวของการวิ่งเหล่านั้นและผลิตภัณฑ์ของพวกเขาและเลือกรายการที่เหมาะสมโดยนำองค์ประกอบสุดท้ายของผลลัพธ์ที่เรียง

JavaScript, 187 ไบต์

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