न्यूनतम और अधिकतम के बीच सबसे लंबे परिणाम का सबसे बड़ा उत्पाद खोजें

Question

इनपुट:

शून्य से अधिक पूर्णांकों का एक गैर-रिक्त अनुक्रम, जिसकी लंबाई 1 से अधिक है।

आउटपुट:

अनुक्रम सहित न्यूनतम और अधिकतम तत्वों के बीच सबसे लंबे समय तक परिणाम के सभी तत्वों का सबसे बड़ा उत्पाद।

ध्यान दें:

क्योंकि न्यूनतम और अधिकतम तत्वों को दोहराया जा सकता है, फिर एक निश्चित उत्तर के लिए सबसे लंबे समय तक संभवता को खोजने के लिए आवश्यक है, जिसके एक छोर पर एक न्यूनतम और दूसरे छोर पर अनुक्रम के अधिकतम तत्व हैं। यदि कई सबसे लंबे परिणाम हैं तो सबसे बड़े उत्पाद के साथ बाद का चयन करें।

उदाहरण:

पहला उदाहरण:

इनपुट: [5, 7, 3, 2, 1, 2, 2, 7, 5]

आउटपुट: 42

स्पष्टीकरण: min == 1, max == 7। न्यूनतम और अधिकतम छोरों पर 2 संभावित अनुवर्ती हैं: [1, 2, 2, 7]और [7, 3, 2, 1]। उनकी लंबाई बराबर है, इसलिए उत्पादों की तुलना करना: 7*3*2*1 == 42और 1*2*2*7 == 28। क्योंकि 42 >= 28, उत्तर 42:।

दूसरा उदाहरण:

इनपुट: [1, 2, 2, 2, 4, 3, 3, 1]

आउटपुट: 32

स्पष्टीकरण: min == 1, max == 4। 2 परिणाम: [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 परिणाम: [1, 2, 3, 4]और [4, 3, 3, 1]। 1*2*3*4 == 24, 4*3*3*1 == 36, 36 >= 24=> जवाब है 36।

चौथा उदाहरण:

इनपुट: [2, 2, 2]

आउटपुट: 8

स्पष्टीकरण: min == 2, max == 2। 2 अलग अनुवर्ती: [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

अपना समाधान जांचें:

यहाँ पायथन 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)

विजेता:

सबसे छोटा समाधान जीत जाएगा। सभी प्रोग्रामिंग भाषाओं को स्वीकार किया।

पुनश्च: मुझे आपके समाधानों के स्पष्टीकरण से प्रसन्नता होगी

Answer 1

जेली , 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.

Answer 2

जेली , 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

Answer 3

पर्ल 6 , 108 बाइट्स

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

Answer 4

आर, 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)इसके बजाय: कई बार उपयोग करने के लिए मजबूर किया जाता है। ओह अच्छा...

पठनीय:

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

Answer 5

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

Answer 6

गणितज्ञ, 122 बाइट्स

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

हैरानी की बात है कि यह कब तक निकला। पहले मिनीमा और मैक्सिमा ( जोनाथन एलन के जैली जवाब के अनुसार ) के दिखावे के कार्टेशियन उत्पाद को उत्पन्न करता है, फिर उन रन और उनके उत्पादों की लंबाई की गणना करता है, और हल किए गए परिणामों के अंतिम तत्व को लेते हुए उपयुक्त का चयन करता है।

Answer 7

जावास्क्रिप्ट, 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`
`)