Contribution:

Une séquence non vide d'entiers supérieurs à zéro, dont la longueur est supérieure à 1.

Sortie:

Le plus grand produit de tous les éléments de la sous-séquence la plus longue entre les éléments de séquence minimum et maximum, y compris eux-mêmes.

Remarque:

Parce que les éléments minimum et maximum peuvent être répétés, alors à une réponse définitive nécessaire pour trouver la sous-séquence la plus longue possible, à une extrémité de laquelle est un minimum et à l'autre extrémité des éléments maximum de la séquence. S'il y a plusieurs sous-séquences les plus longues, choisissez la sous-séquence avec le plus grand produit.

Exemples:

1er exemple:

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

Sortie: 42

Explication: min == 1, max == 7. Il y a 2 sous-séquences possibles avec min et max aux extrémités: [1, 2, 2, 7]et [7, 3, 2, 1]. Leur longueur est égale, donc en comparant les produits: 7*3*2*1 == 42et 1*2*2*7 == 28. Parce que 42 >= 28, réponse: 42.

2ème exemple:

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

Sortie: 32

Explication: min == 1, max == 4. 2 sous-séquences: [1, 2, 2, 2, 4]et [4, 3, 3, 1]. La longueur de [1, 2, 2, 2, 4]est supérieure à la longueur de [4, 3, 3, 1]. produit: 1*2*2*2*4 == 32=> la réponse est 32.

Exemple 3D:

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

Sortie: 36

Brève explication: min == 1, max == 4. 2 sous-séquences: [1, 2, 3, 4]et [4, 3, 3, 1]. 1*2*3*4 == 24, 4*3*3*1 == 36, 36 >= 24=> Réponse est 36.

4ème exemple:

Contribution: [2, 2, 2]

Sortie: 8

Explication: min == 2, max == 2. 2 sous-séquences différentes: [2, 2]et [2, 2, 2]. La longueur de [2, 2, 2]est supérieure à la longueur de [2, 2]. produit: 2*2*2 == 8=> la réponse est 8.

Plus d' exemples (aléatoires) :

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

Vérifiez votre solution:

Voici Python 3 lambda (788 octets) , qui satisfait l'exigence de la tâche:

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)

Gagnant:

La solution la plus courte gagnera. Tous les langages de programmation acceptés.

PS: je serai heureux des explications de vos solutions

Gelée , 14 octets

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

Essayez-le en ligne!

Comment ça marche

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

Gelée , 15 octets

NMpMr/€LÐṀịµP€Ṁ

TryItOnline!

Comment?

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 octets

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

R, 146 octets

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

Défi difficile en raison de la longueur requise. Également ennuyeux parce que la fonction intégrée utile which.maxne renvoie que l'index du premier maximum qu'il rencontre, me forçant à utiliser à la which(max(x)==x)place ... 3 fois. Tant pis...

Lisible:

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 octets

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

de même paresseux mais 33 octets plus court (a dû ajouter 10 octets pour transformer l'extrait de code en un programme):

1. Boucle $p/$bet à $q/$ctravers le tableau; si $b==minet $c==max,
   ajouter le produit de la sous-séquence à$r[sub-sequence length]
2. Trier $rpar clés.
3. Affiche la valeur maximale du dernier élément.

Appelez dans le navigateur avec un tableau comme paramètre GET a.
Exemple:script.php?a[]=5&a[]=7&a[]=3&a[]=2&a[]=1&a[]=2&a[]=2&a[]=7&a[]=5

Mathematica, 122 octets

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

Surpris combien de temps cela s'est avéré être. Génère d'abord le produit cartésien des apparences des minima et des maxima (selon la réponse Jelly de Jonathan Allan ), puis calcule les longueurs de ces analyses et de leurs produits, et sélectionne celle qui convient en prenant le dernier élément des résultats triés.

JavaScript, 187 octets

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