সর্বনিম্ন এবং সর্বোচ্চের মধ্যে দীর্ঘতম অনুচ্ছেদের বৃহত্তম পণ্যটি সন্ধান করুন

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]। product: 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]। product: 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)পরিবর্তে আমাকে 3 বার ব্যবহার করতে বাধ্য করে । আচ্ছা ভালো...

রিডেবল:

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

পিএইচপি, 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,
   উপ-অনুক্রমের পণ্য যুক্ত করুন add$r[sub-sequence length]
2. $rকী অনুসারে বাছাই করুন ।
3. শেষ উপাদানটির সর্বাধিক মান মুদ্রণ করুন।

জিইটি প্যারামিটার হিসাবে অ্যারের সাথে ব্রাউজারে কল করুন 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`
`)