Eingang:

Eine nicht leere Folge von ganzen Zahlen größer als Null, deren Länge größer als 1 ist.

Ausgabe:

Das größte Produkt aller Elemente der längsten Teilsequenz zwischen den minimalen und maximalen Elementen der Sequenz, einschließlich sich selbst.

Hinweis:

Da die minimalen und maximalen Elemente wiederholt werden können, ist dann eine eindeutige Antwort erforderlich, um die längste mögliche Teilsequenz zu finden, an deren einem Ende sich ein minimales und am anderen Ende ein maximales Element der Sequenz befindet. Wenn es mehrere längste Teilfolgen gibt, wählen Sie die Teilfolge mit dem größten Produkt.

Beispiele:

1. Beispiel:

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

Ausgabe: 42

Erklärung: min == 1, max == 7. Es gibt 2 mögliche Untersequenzen mit min und max an den Enden: [1, 2, 2, 7]und [7, 3, 2, 1]. Ihre Länge ist gleich, also Produkte vergleichen: 7*3*2*1 == 42und 1*2*2*7 == 28. Da 42 >= 28, Antwort: 42.

2. Beispiel:

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

Ausgabe: 32

Erklärung: min == 1, max == 4. 2 Teilfolgen: [1, 2, 2, 2, 4]und [4, 3, 3, 1]. Länge von [1, 2, 2, 2, 4]ist größer als Länge von [4, 3, 3, 1]. Produkt: 1*2*2*2*4 == 32=> Antwort ist 32.

3d beispiel:

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

Ausgabe: 36

Kurze Erläuterung: min == 1, max == 4. 2 Teilfolgen: [1, 2, 3, 4]und [4, 3, 3, 1]. 1*2*3*4 == 24, 4*3*3*1 == 36, 36 >= 24=> Antwort ist 36.

Viertes Beispiel:

Eingang: [2, 2, 2]

Ausgabe: 8

Erklärung: min == 2, max == 2. 2 verschiedene Teilfolgen: [2, 2]und [2, 2, 2]. Länge von [2, 2, 2]ist größer als Länge von [2, 2]. Produkt: 2*2*2 == 8=> Antwort ist 8.

Weitere (zufällige) Beispiele:

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

Überprüfen Sie Ihre Lösung:

Hier ist Python 3 Lambda (788 Bytes) , das die Anforderung der Aufgabe erfüllt:

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)

Gewinner:

Kürzeste Lösung gewinnt. Alle Programmiersprachen werden akzeptiert.

PS: Ich freue mich auf die Erläuterungen Ihrer Lösungen

Jelly , 14 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Gelee , 15 Bytes

NMpMr/€LÐṀịµP€Ṁ

TryItOnline!

Wie?

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 Bytes

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

R 146 Bytes

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

Schwierige Herausforderung wegen der Längenanforderung. Ebenfalls ärgerlich, da das nützliche Built-in which.maxnur den Index des ersten Maximums zurückgibt, auf das es stößt, und mich dazu zwingt, which(max(x)==x)stattdessen ... dreimal zu verwenden. Naja...

Lesbar:

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 Bytes

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

Ähnlich faul, aber 33 Bytes kürzer (musste 10 Bytes hinzufügen, um das Snippet in ein Programm zu verwandeln):

1. Schleife $p/$bund $q/$cdurch das Array; Wenn $b==minund $c==max,
   fügen Sie Produkt der Teilsequenz hinzu$r[sub-sequence length]
2. Nach $rSchlüsseln sortieren .
3. Gibt den Maximalwert des letzten Elements aus.

Rufen Sie den Browser mit dem Array als GET-Parameter auf a.
Beispiel:script.php?a[]=5&a[]=7&a[]=3&a[]=2&a[]=1&a[]=2&a[]=2&a[]=7&a[]=5

Mathematica, 122 Bytes

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

Überrascht, wie lange sich das herausstellte. Generiert zunächst das kartesische Produkt aus den Erscheinungen der Minima und Maxima (gemäß Jonathan Allans Jelly-Antwort ), berechnet dann die Länge dieser Läufe und ihrer Produkte und wählt das geeignete aus, indem das letzte Element der sortierten Ergebnisse herangezogen wird.

JavaScript, 187 Bytes

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