অ-সংলগ্ন আইটেমগুলির সাথে সর্বাধিক সংখ্যক যোগফল qu

23

পরিচিতি:

এই দুটি এসও প্রশ্নের দ্বারা অনুপ্রাণিত (একই শ্রেণীর কোনও সন্দেহ নেই): সংযুক্ত উপাদান জাভা এবং কোনও অ্যারের অ-সংলগ্ন উপাদানগুলির সর্বাধিক যোগফল ছাড়াই সর্বাধিক যোগফলের সাববারে উপাদানগুলি মুদ্রণ করুন ।

চ্যালেঞ্জ:

পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে, সর্বাধিক যোগফলের সাথে অ-সংলগ্ন উপাদানগুলির সমন্বয়ে একটি অনুক্রম আউটপুট করুন। এখানে কয়েকটি উদাহরণ:

  • [1,2,3,-1,-3,2,5]0-ভিত্তিক সূচকগুলিতে [1,3,5](যোগফলের সাথে 9) ফলাফল হবে [0,2,6]।
  • [4,5,4,3]0-ভিত্তিক সূচকগুলিতে (যোগফল সহ ) বা 0-ভিত্তিক সূচকগুলিতে ( [4,4]যোগফলের যোগফল 8) এর ফলাফলও তৈরি হয় ।[0,2][5,3]8[1,3]
  • [5,5,10,100,10,5]স্থাপিত হবে [5,100,5](একটি সমষ্টি সঙ্গে 110পারেন 0 ভিত্তিক সূচকের কোণে) [0,3,5]বা [1,3,5]।

উপরের এই উদাহরণগুলির মধ্যে সর্বাধিক গুরুত্বপূর্ণ, উপাদানগুলি সূচকগুলি একে অপর থেকে কমপক্ষে 2 টি পৃথক। যদি আমরা উদাহরণটিকে [5,5,10,100,10,5]আরও গভীরতার সাথে দেখি: আমাদের নীচের সম্ভাব্য অনুচ্ছেদটি অ-সংলগ্ন আইটেমগুলি সহ রয়েছে; এটির নীচে তাদের সূচকগুলি সহ; এর নিচে তাদের অঙ্কের সাথে:

[[5],[10],[100],[10],[5],[5],[100,5],[10,5],[10,10],[5,5],[5,10],[5,100],[5,5],[5,10],[5,100],[5,10],[5,100,5],[5,100,5],[5,10,5],[5,10,10]]   // non-adjacent subsequences
[[5],[ 4],[  3],[ 2],[1],[0],[  3,5],[ 2,5],[ 2, 4],[1,5],[1, 4],[1,  3],[0,5],[0, 4],[0,  3],[0, 2],[1,  3,5],[0,  3,5],[0, 2,5],[0, 2, 4]]   // at these 0-based indices
[  5,  10,  100,  10,  5,  5,    105,    15,     20,   10,    15,    105,   10,    15,    105,    15,      110,      110,      20,       25]   // with these sums
                                                                                                            ^         ^                        // and these two maximums

যেহেতু সর্বাধিক পরিমাণ হয় 110, [5,100,5]ফলস্বরূপ আমরা আউটপুট ।

চ্যালেঞ্জ বিধি:

  • আপনাকে সূচক + মানের কী-মান জোড়গুলি আউটপুট দেওয়ার অনুমতি দেওয়া হয়। সুতরাং আপনার পরিবর্তে [5,100,5]আউটপুট [[0,5],[3,100],[5,5]]বা [[1,5],[3,100],[5,5]]ফলাফল হিসাবে (বা [[1,5],[4,100],[6,5]]/ [[2,5],[4,100],[6,5]]যখন 1-ভিত্তিক সূচক 0-ভিত্তিক পরিবর্তে ব্যবহৃত হয়))
    • যদি আপনি কী-মানযুক্ত জোড় ব্যবহার করেন তবে সেগুলি বিপরীত বা এলোমেলো ক্রমেও হতে পারে, যেহেতু এটি স্পষ্ট যা সংযুক্ত সূচির কারণে কোন মানগুলি বোঝায়।
    • মান ব্যতীত কেবল সূচকগুলি আউটপুট করার অনুমতি নেই। এটি হয় মানগুলি, বা মান / সূচকগুলি কী-মান জোড় হিসাবে আউটপুট করা উচিত (বা আপনার পছন্দ অনুসারে ভাষাতে কী-মান জোড়গুলি সম্ভব না হলে একই আকারের 'কী' এবং 'মানের' জন্য দুটি পৃথক তালিকা) output
  • আপনাকে কেবলমাত্র একের পরিবর্তে সর্বাধিক যোগফলের সাথে সমস্ত সম্ভাব্য উপসর্গ আউটপুট করার অনুমতি দেওয়া হয়েছে।
  • উদাহরণস্বরূপ আপনি দেখতে পাচ্ছেন, ইনপুট-তালিকায় নেতিবাচক এবং নকল মানগুলিও থাকতে পারে। আপনি ধরে নিতে পারেন ইনপুট-পূর্ণসংখ্যাগুলি [−999,999] ।
  • আউটপুট-তালিকা খালি হতে পারে না এবং সর্বদা কমপক্ষে একটি উপাদান থাকা আবশ্যক (যদি একটি তালিকার মধ্যে কেবল নেতিবাচক মান থাকে তবে একক সর্বনিম্ন নেতিবাচক মান সম্বলিত একটি তালিকা ফলস্বরূপ আউটপুট হবে - শেষ দুটি পরীক্ষার কেস দেখুন)।
  • যদি একটি সম্ভাব্য আউটপুট থাকে তবে একাধিক পৃথক সূচকের জন্য, এটি উভয়কেই ডুপ্লিকেট মনে হলেও আউটপুট করার অনুমতি দেয়। (যেমন উপরের উদাহরণটি, [[5,100,5],[5,100,5]]উভয়ই সম্ভাব্য সূচক-সংমিশ্রণের জন্য আউটপুট দিতে পারে )।

পরীক্ষার কেস:

Input:                   Possible outputs:       At 0-based indices:     With sum:

[1,2,3,-1,-3,2,5]        [1,3,5]                 [0,2,6]                 9
[4,5,4,3]                [4,4]/[5,3]             [0,2]/[1,3]             8
[5,5,10,100,10,5]        [5,100,5]               [0,3,5]/[1,3,5]         110
[10]                     [10]                    [0]                     10
[1,1,1]                  [1,1]                   [0,2]                   2
[-3,7,4,-2,4]            [7,4]                   [1,4]                   11
[1,7,4,-2]               [7]                     [1]                     7
[1,2,-3,-4,5,6,-7]       [2,6]                   [1,5]                   8
[800,-31,0,0,421,726]    [800,726]/[800,0,726]   [0,5]/[0,3,5]/[0,2,5]   1526
[-1,7,8,-5,40,40]        [8,40]                  [2,4]/[2,5]             48
[-5,-18,-3,-1,-10]       [-1]                    [3]                     -1
[0,-3,-41,0,-99,-2,0]    [0]/[0,0]/[0,0,0]       [0]/[3]/[6]/[0,3]/
                                                  [0,6],[3,6]/[0,3,6]    0
code-golf  number  array-manipulation  integer 
— কেভিন ক্রুইজসেন
সূত্র
যদি একাধিক অভিন্ন সেট থাকে (তবে বিভিন্ন সূচক থেকে) তাদের সবগুলি তালিকা করে দেওয়া কি ঠিক আছে? যেমন [5,100,5]আপনার তৃতীয় উদাহরণের জন্য দুবার।
— নিক কেনেডি
1
powersetউপগ্রহের একটি সেট এটি না? তবে দেখে মনে হচ্ছে আপনি উপসর্গের একটি সেট ফেরত দিচ্ছেন? [4,5,4,3] এর ফলে [4,4] এর ফলাফল আসে যেখানে [4,4] স্পষ্টত কোনও সেট নয়।
— শেষ হওয়া ডেটা
1
@ আর্নল্ড হ্যাঁ, মানগুলি যদি তাদের সূচকের সাথে মূল-মান জোড় হয় তবে এটি স্পষ্ট হয় যে ইনডেক্সে কোন সূচকযুক্ত মান বোঝানো হয়, তাই সেগুলি যে কোনও ক্রমে হতে পারে। চ্যালেঞ্জের বর্ণনায় এটিও সম্পাদনা করবে।
— কেভিন ক্রুইজসেন
2
কেবল নিশ্চিত হওয়া: সূচকগুলি আউটপুট করা কোনও বিকল্প নয়, তাই না?
— শেগি
1
শাস্ত্রীয় শব্দটি হ'ল "উপসর্গ" । যদিও এটি একই রকমের সংলগ্ন উপসাগরগুলির কথা চিন্তা করে মানুষের সমস্যা has আমি যদি বলি "সাবসেট" যদি আমরা এখানে সেটগুলি নিয়ে প্রকৃতপক্ষে কাজ করি তবে এটি অবশ্যই সিকোয়েন্সগুলি হয় - আদেশের বিষয়গুলি এবং নকলগুলি অনুমোদিত allowed
— ব্যবহারকারী 2357112 মনিকা

উত্তর:

6

হুশ , 11 বাইট

►Σ†!¹mü≈tṖŀ

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

►Σ†!¹mü≈tṖŀ  Implicit input, say L=[4,5,3,4].
          ŀ  Indices: [1,2,3,4]
         Ṗ   Powerset: [[],[1],[2],[1,2],..,[1,2,3,4]]
        t    Tail (remove the empty list): [[1],[2],[1,2],..,[1,2,3,4]]
     m       For each,
      ü      de-duplicate by
       ≈     differing by at most 1.
             For example, [1,2,4] becomes [1,4].
  †          Deep map
   !¹        indexing into L: [[4],[5],[4],..,[5,4],[4,3]]
►            Maximum by
 Σ           sum: [5,4]
— Zgarb
সূত্র
6

হাস্কেল , 60 বাইট

snd.([]%)
r%(h:t)=max(r%t)$(r++[h])%drop 1t
r%_=(sum r<$r,r)

এটি অনলাইন চেষ্টা করুন!

সহায়ক ফাংশনটি %প্রথম উপাদানটিকে অন্তর্ভুক্ত করে এবং দ্বিতীয়টি বাদ দেয় বা প্রথম উপাদানটি এড়িয়ে যায় কিনা তা বেছে নেওয়ার জন্য পুনরাবৃত্তভাবে শাখা করে। এটি সমস্ত ফলাফলের সর্বাধিক লাগে, যা দ্বিগুণ যারা প্রথম উপাদানটির যোগফল, এবং যার দ্বিতীয় উপাদানটি সম্পর্কিত তালিকা যা আউটপুট জন্য বের করা হয়।

খালি তালিকাটি যদি ক্ষুদ্রতম কৌশল থাকে তবে তা নিষ্ক্রিয় করা হয়েছে এই নিয়মটি পরিচালনা করার জন্য, আমরা লেখার sum r<$rপরিবর্তে একটি সুন্দর কৌশল করি sum r.এটি একটি তালিকা তৈরি করে, যার উপাদানগুলি সমস্ত sum rএবং দৈর্ঘ্যের দৈর্ঘ্য r। এই ভাবে, যখন আমরা সর্বোচ্চ চয়ন, আমরা কোনো তালিকা একটি খালি উপর অগ্রাধিকার r, কিন্তু অন্যথায় তুলনা প্রথম উপাদান যার উপর নির্ভর করে sum r।

— xnor
সূত্র
6

আর , 136 125 বাইট

function(l,G=unlist(Map(combn,list(y<-seq(a=l)),y,c(function(x)'if'(all(diff(x)>1),l[x],-Inf)),F),F))G[which.max(Map(sum,G))]

এটি অনলাইন চেষ্টা করুন!

-6 বাইটস ডিজিগ এমএলকে ধন্যবাদ , যিনি ঘটনাক্রমে আমাকেও ছাড়িয়েছিলেন ।

listসূচক দ্বারা প্রথমে অভিধানের সাথে সংযোগ ভাঙার হিসাবে সংক্ষিপ্ততম অনুচ্ছেদটি ফেরৎ দেয় ।

ব্রুট-ফোর্স সমস্ত সূচী অনুচ্ছেদ তৈরি করে, তারপরে Filterতাদের জন্য যারা অ-সংলগ্ন, অর্থাত্, যেখানে all(diff(x)>1)। তারপর সাব-সেট নির্বাচন [মধ্যে l, এই সূচকের ব্যবহার নির্বাচন [[প্রথমটি যেখানে সমষ্টি সর্বোচ্চ আছে ( which.max)।

আমি নিশ্চিত যে আমি এটি লিখেছি যে এটি প্রথম আর উত্তর যা ব্যবহার করে Filter! দু: খিত, Filterঅসম্পূর্ণ, আশ্চর্যজনক যে আমি এটি কখনও ব্যবহার করি নি ...

— : Giuseppe
সূত্র
130
— 8
@ ডিজিএম সমস্ত ধন্যবাদ!
— জিউস্পে
5

05 এ বি 1 ই , 14 বাইট

কেভিন ক্রুইজসেনকে ধন্যবাদ 1 বাইট সংরক্ষিত

ā<æʒĆ¥≠W}èΣO}θ

এটি অনলাইন চেষ্টা করুন! বা টেস্ট স্যুট হিসাবে

ব্যাখ্যা

ā<               # push [0 ... len(input)-1]
  æ              # compute powerset
   ʒ    }        # filter, keep lists where:
      ≠W         # no element is 1 in the
     ¥           # deltas
    Ć            # of the list with the head appended
         è       # index into the input with each
          ΣO}    # sort by sum
             θ   # take the last element
— Emigna
সূত্র
আপনি খুশি নাও হতে পারেন তবে এটি আমার প্রাথমিক সমাধানের চেয়ে 4 বাইট কম। ;) আর তুমি গলফ 1 এর আরও বেশি পরিবর্তন করতে ¤ªকরতে Ć।
— কেভিন ক্রুইজসেন
@ কেভিন ক্রুজসেন: ওহ হ্যাঁ! কিছু কারণে আমি নিজেকে বোঝাতে পেরেছিলাম শেষে আমার একটি পুনরাবৃত্ত উপাদান প্রয়োজন। ধন্যবাদ!
— এমিগানা
5

ব্র্যাচল্যাগ (ভি 2), 14 বাইট

{~ba~c∋₁ᵐ}ᶠ+ᵒt

এটি অনলাইন চেষ্টা করুন!

কার্য জমা; বাম থেকে ইনপুট, যথারীতি ডান থেকে আউটপুট। খুব ধীর; একটি পাঁচ-উপাদান তালিকা টিআইওতে পরীক্ষার জন্য সম্ভবত সর্বাধিক।

{~ba~c∋₁ᵐ}ᶠ+ᵒt
 ~b              Prepend an arbitrary element to the input
   a             Take a prefix or suffix of the resulting list
    ~c           Ordered partition into contiguous sublists
      ∋₁         Take the second element
        ᵐ          of each sublist
{        }ᶠ      Find all possible ways to do this
           +ᵒ    Sort by sum
             t   Take the greatest

উপসর্গগুলি থেকে আমরা প্রাপ্ত ফলাফলগুলি ভুল নয়, তবে আকর্ষণীয়ও নয়; প্রত্যয় গ্রহণের মাধ্যমে সমস্ত সম্ভাব্য ফলাফল উত্পন্ন হয় (যা সম্ভবত তালিকাটি নিজেই রয়েছে তবে খালি থাকতে পারে না), তবে "প্রত্যয়" ব্র্যাচ্ল্যাগে "উপসর্গ বা প্রত্যয়" এর চেয়ে বেশি ভার্জোজ, তাই আমি সংস্করণটির সাথে চলেছি (এবং কম) দক্ষ তবে এখনও সঠিক)। মূল ধারণাটি হ'ল প্রতিটি উপাদানের জন্য আমরা আউটপুট তালিকার জন্য চাই, সংক্ষিপ্ত সাবলিস্টে বিভাজনের জন্য সেই উপাদানটি এবং উপাদানটিকে একই সাবলিস্টে রাখার আগে (কারণ উপাদানটি দ্বিতীয়সাবলিস্টের উপাদান), সুতরাং পর পর দুটি ফল উপাদান উপস্থিত হতে পারে না। অন্যদিকে, এটি মোটামুটি পরিষ্কার যে পর পর দুটি উপাদান ছাড়াই যে কোনও তালিকা ফলাফলটিতে উপস্থিত হতে পারে। সুতরাং একবার আমাদের সমস্ত সম্ভাব্য প্রার্থীর তালিকাগুলি পরে, আমরা কেবলমাত্র তাদের সকলের যোগফল নিতে পারি এবং দেখতে দেখতে কোনটি বৃহত্তম।

— ais523
সূত্র
3

জাভাস্ক্রিপ্ট (ES6),  138 132 130 129  126 বাইট

কী-মান যুক্তগুলি আউটপুট করে।

a=>a.reduce((a,x,i)=>[...a,...a.map(y=>[[x,i],...y])],[[]]).map(m=a=>a.some(s=p=([v,i])=>p-(s=~~s+v,p=i)<2)|s<m||(r=a,m=s))&&r

এটি অনলাইন চেষ্টা করুন!

ধাপ 1

[বনামএকটিঠতোমার দর্শন লগ করাই,আমিএনঘইএক্স]

a.reduce((a, x, i) => // for each value x at position i:
  [                   //   update a[] to a new array consisting of:
    ...a,             //     all previous entries
    ...a.map(y =>     //     for each value y in a[]:
      [[x, i], ...y]  //       append [x, i], followed by all original entries
    )                 //     end of map()
  ],                  //   end of new array
  [[]]                //   start with a = [[]]
)                     // end of reduce()

ধাপ ২

মিR

.map(m =              // initialize m to a non-numeric value
  a =>                // for each entry a[] in the powerset:
  a.some(s = p =      //   initialize s and p to non numeric values
    ([v, i]) =>       //   for each value v and each index i in a[]:
    p - (             //     compute p - i
      s = ~~s + v,    //     add v to s
      p = i           //     update p to i
    ) < 2             //     if p - i is less than 2, yield true
  ) |                 //   end of some()
  s < m ||            //   unless some() was truthy or s is less than m,
  (r = a, m = s)      //   save a[] in r[] and update m to s
) && r                // end of map(); return r[]
— Arnauld
সূত্র
3

হাস্কেল, 81 80 বাইট

snd.maximum.map((,)=<<sum).tail.f
f(a:b:c)=f(b:c)++map(a:)(f c)
f a=[]:map(:[])a

এটি অনলাইন চেষ্টা করুন!

fপরবর্তী উপাদান ( f(b:c)) এড়িয়ে যাওয়া বা এটি ব্যবহার করে এবং পরবর্তী ( map(a:)(f c)) এড়িয়ে যাওয়া এবং বাকীটিতে পুনরাবৃত্তভাবে কাজ করে সমস্ত বৈধ উপসর্গ তৈরি করে । ফলাফলের জন্য, সমস্ত অনুচ্ছেদ তৈরি করুন ( f), খালি উপসর্গটি (যা তালিকায় প্রথমে ঘটে tail:) ফেলে দিন, (<sum>,<subsequence>)( map((,)=<<sum)) জোড় তৈরি করুন, সর্বাধিক (জোড়কে অভিধানের সাথে তুলনা করা হয়) -> maximum) এবং যোগফলটি ( snd) রেখে দিন।

সম্পাদনা করুন: -1 বাইট @ লিন ধন্যবাদ।

— nimi
সূত্র
1
map(:[])a(pure<$>a)^^ এর চেয়ে কম বাইট
— লিন
3

জে , 47 বাইট

>@{:@(<@#~/:+/@#~)1(-#~0=1 1+/@E."1-)[:i.&.#.=~

এটি অনলাইন চেষ্টা করুন!

-7 বাইট ধন্যবাদ ফ্রাউনফ্রোগের জন্য

মূল

জে , 54 বাইট

[:(>@{:@/:+/&>)]<@#~"1[:(#~0=1 1+/@E."1])[:#:@}.@i.2^#

এটি অনলাইন চেষ্টা করুন!

— দুর্ভাগ্যআনয়নকারী
সূত্র
1
47
— ফ্রাউনফ্রোগ
আপনাকে অনেক ধন্যবাদ @ ফ্রাউনফ্রোগ
— জোনা
3

টি-এসকিউএল, 122 119 118 বাইট

ইনপুট একটি টেবিল পরিবর্তনশীল।

এই ক্যোয়ারীটি টেবিল ভেরিয়েবল থেকে সমস্ত উপাদানকে বেছে নিয়েছে এবং এগুলি উচ্চ-অবস্থানের মানগুলির সাথে সমস্ত অ-সংলগ্ন উপাদানগুলির সাথে একত্রিত করে এবং এই মানগুলির সর্বোচ্চ যোগফলের জন্য উত্পন্ন পাঠ্য দেখায়।

WITH C(y,j,v)as(SELECT*,x*1FROM @
UNION ALL
SELECT y+','+x,i,v+x
FROM @ JOIN C ON~-i>j)SELECT
TOP 1y FROM C ORDER BY-v

অনলাইনে অনাবৃত চেষ্টা করুন

— t-clausen.dk
সূত্র
2

পাইথ, 19 বাইট

esDm@LQdtf!q#1.+TyU

এটি এখানে অনলাইনে চেষ্টা করুন , বা এখানে সমস্ত পরীক্ষার কেস একবারে যাচাই করুন ।

esDm@LQdtf!q#1.+TyUQ   Implicit: Q=eval(input())
                       Trailing Q inferred
                  UQ   Generate range [0-len(Q))
                 y     Take the powerset of the above
         f             Filter keep elements of the above, as T, using:
              .+T        Take differences of consecutive elements of T
           q#1           Keep those differences equal to 1
          !              Logical NOT - empty lists evaluate to true, populated ones to false
                       Result of the filter is those sets without consecutive numbers
        t              Drop the first element (empty set)
   m                   Map the remaining sets, as d, using:
     L d                 For each element of d...
    @ Q                  ... get the element in Q with that index
 sD                    Order the sets by their sum
e                      Take the last element, implicit print
— সোক
সূত্র
2

গাইয়া , 24 বাইট

e:w;ċz⟨ọ1>¦ẏ⟩⁇‼⁇E‡ev2%Σ⌠

এটি অনলাইন চেষ্টা করুন!

উফ! E‡কিছু অদ্ভুত জিনিস আছে ... ডকুমেন্টেশন অনুযায়ী, এটি করা উচিত মত "দেওয়া দৈর্ঘ্য কিছু iতালিকার সেট Xএবং দৈর্ঘ্য jসূচকের সেট Y, এর বিনিময়ে X[i][Y[j]]", কিন্তু এর পরিবর্তে আয় [X[i][Y[j]] X[i][Y[-j]]যেখানে নেতিবাচক ইন্ডেক্স সম্পূরক প্রতিনিধিত্ব করে, তাই আমরা যা করতে হবে ev2%করতে আমরা যা চাই কেবল তা নিষ্কাশন করুন।

e				| eval as a list l
 :				| dup
  w				| wrap as a list
   ;				| push l again
    ċ				| push [1..len(l)]
     z				| push all subsets of [1..len(l)] -- index powerset.
      ⟨      ⟩⁇			| filter this for:
       ọ			| deltas
        1>¦			| are greater than 1
           ẏ			| all (all deltas greater than 1)
	       ‼⁇		| filter for non-empty lists
		 E‡		| table extract elements. Given l and index set i, this pushes
				| [l[i] l[setdiff(1..l,i)]] for some reason
		   ev2%		| get the l[i] only by unlisting, reversing, and taking every other element
		       Σ⌠	| Get the one with the maximum sum
— : Giuseppe
সূত্র
কৌতূহলের বাইরে, আউটপুটটির কেন ]]একের পরিবর্তে দুটি অনুচ্ছেদে রয়েছে ?
— কেভিন ক্রুইজসেন
@ কেভিন ক্রুইজসেন দোভাষীর আরও একটি মজাদার তকমা; সমস্ত তালিকাগুলি এর মতো মুদ্রিত হয়, সুতরাং [[1] [2]]মুদ্রিত হয়ে যায় [[1]] [2]]]]যা তালিকার আউটপুটটি পড়তে / ডিবাগ করা শক্ত করে তোলে।
— জিউসেপ
আমি মনে করি এটি re.sub(" ?$","]",result)ইন্টারপ্রেটারে প্রকাশের কারণে যা এর পরিবর্তে হওয়া উচিত re.sub(" +$","]",result)তবে আমার অজগরটি খুব খারাপ।
— জিউসেপ
2

ওল্ফ্রাম ভাষা (গণিত) , 70 63 বাইট a

MaximalBy[Select[q=Rest@Subsets@#,!FreeQ[q,#~Riffle~_]&],Tr,1]&

এটি অনলাইন চেষ্টা করুন!

উচ্চ স্তরের অনুসন্ধান

          Select[q=Rest@Subsets@#,                     ]        (*choose nonempty subsets of the input such that*)
                                  !FreeQ[q,          ]&         (*there exists a subset of the input which matches*)
                                           #~Riffle~_           (*this list, with an item inserted between adjacent elements*)
MaximalBy[                                              ,Tr,1]& (*and return one with the greatest total*)

,1অজান্তেই অবৈধ সেটগুলি না ফেরানোর জন্য প্রয়োজনীয় (অন্যথায়, উদাহরণস্বরূপ, একটি ইনপুট এর {1,1,1}ফলাফলের ফলাফল হতে পারে {{1,1},{1,1},{1,1}})

— attinat
সূত্র
1

হাস্কেল , 300 168 বাইট

import Data.List
h[]=1>2
h(x:y)=fst$foldl(\a c->((fst a)&&(c-snd a>1),c))(1<2,x)y
z=snd.last.sortOn fst.map((,)=<<sum.snd).filter(h.fst).map unzip.subsequences.zip[0..]

এটি অনলাইন চেষ্টা করুন!

-132 বাইটগুলি @ নিমির সমস্ত প্রতিক্রিয়ার জন্য ধন্যবাদ :)

মূল

অব্যক্ত (মূল)

import Data.List
import Data.Function

f :: [Int] -> [(Int, Int)] -- attach indices for later use
f [] = []
f xs = zip xs [0..length xs]

g :: [[(Int, Int)]] -> [([Int], [Int])] -- rearrange into list of tuples
g [] = []
g (x:xs) = (map fst x, map snd x) : g xs

h :: [Int] -> Bool -- predicate that checks if the indices are at least 2 apart from each other
h [] = False
h (x:xs) = fst $ foldl (\acc curr -> ((fst acc) && (curr - snd acc > 1), curr)) (True, x) xs
j :: [([Int], [Int])] -> [([Int], [Int])] -- remove sets that don't satisfy the condition
j xs = filter (\(elements, indices) -> h indices) xs

k :: [([Int], [Int])] -> [(Int, ([Int], [Int]))] -- calculate some of elements
k xs = map (\(elements, indices) -> (foldl1 (+) elements, (elements, indices))) xs

l :: [(Int, ([Int], [Int]))] -> ([Int], [Int]) -- grab max
l xs = snd $ last $ sortBy (compare `on` fst) xs

z -- put things together
```
— বাগ
সূত্র
1
কিছু টিপস: উপাদানগুলি এবং তার সূচকগুলি ফিরুন জোড়গুলির মধ্যে ফিরে আসা f: এর f x=zip[0..length x]xফলে fহয়ে যায় f=zip[0..]। gঠিক হয় g=map unzip। ফিল্টার করার জন্য ফাংশনটি jহ'ল h.fst(<- উল্টানো জোড়া!)। j=filter(h.fst)। foldl1+থেকে kহয় sumএবং একটি pointfree যুগল তৈরীর সঙ্গে k=map((,)=<<sum.snd)। sortBy(...)দ্বারা প্রতিস্থাপিত হতে পারে sortOn fst: l=snd.last.sortOn fst। অবশেষে আপনি যখন একবারে সমস্ত ফাংশন ব্যবহার করছেন, আপনি সেগুলি একটি একক পয়েন্টফ্রি এক্সপ্রেশনে ইনলাইন করতে পারেন:z=snd.last.sortOn fst.map((,)=<<sum.snd).filter(h.fst).map unzip.subsequences.zip[0..]
— নিমি
— নিমি
ওহ, এবং Data.Functionআর আমদানি করার দরকার নেই।
— নিমি
এটি দুর্দান্ত, প্রতিক্রিয়াটির জন্য ধন্যবাদ :)
— বাগ
পরবর্তী h: আমরা অ-সংলগ্ন উপাদানগুলির সন্ধান করছি, সংলগ্ন সূচকগুলির পার্থক্য অবশ্যই হওয়া উচিত >1। zipWith(-)=<<tailপার্থক্যের একটি তালিকা তৈরি করে, তবে খালি তালিকার জন্য ব্যর্থ হয়, সুতরাং tailএ subsequencesথেকে পরিত্রাণ পেতে আমাদের আরও একটি অতিরিক্ত প্রয়োজন । আবার ইনলাইন। এটি অনলাইন চেষ্টা করুন!
— নিমি
1

কাঠকয়লা , 46 বাইট

≔⟦υ⟧ηＦθ«≔υζ≔Ｅη⁺κ⟦ι⟧υ≔⁺ζηη»≔Φ⁺υηιη≔ＥηΣιζＩ§η⌕ζ⌈ζ

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা:

≔⟦υ⟧η

ভেরিয়েবলটি uখালি তালিকার সাথে পূর্বনির্ধারিত। এটি নির্ধারিত একটি তালিকায় রাখা হয়েছে h। এই ভেরিয়েবলগুলি সংগ্রহকারী হিসাবে কাজ করে। usublists যে ইনপুট এর সর্বশেষ উপাদান অন্তর্ভুক্ত রয়েছে qযখন hsublists যে নেই (ইনপুটের পরবর্তী উপাদান সংযোজন জন্য উপযুক্ত এবং সেইজন্য হয়) রয়েছে।

Ｆθ«

ইনপুটটির উপাদানগুলির উপর লুপ করুন।

≔υζ

পূর্ববর্তী উপাদান থাকা সাবলিস্টগুলির তালিকা সংরক্ষণ করুন।

≔Ｅη⁺κ⟦ι⟧υ

পূর্ববর্তী উপাদানটি ধারণ করে না এমন সমস্ত সাবলিস্টগুলিতে নিন, বর্তমান উপাদানটি সংযোজন করুন এবং ফলাফলটি বর্তমান উপাদানটিকে অন্তর্ভুক্তকারী সাবলিস্টগুলির তালিকা হিসাবে সংরক্ষণ করুন। ( Pushতালিকাটি ক্লোন করার প্রয়োজন হিসাবে আমি এখানে ব্যবহার করি না ))

≔⁺ζηη»

পূর্ববর্তী উভয় সাবলিস্টকে বর্তমানের উপাদানটি অন্তর্ভুক্ত করে না এমন সাবলিস্টগুলির নতুন তালিকায় সংযুক্ত করুন।

≔Φ⁺υηιη

একবারে সাবলিস্টকে সংযুক্ত করুন এবং আসল খালি তালিকাটি (যা চারকোল কোনওভাবেই যোগ করতে পারে না) সরান।

≔ＥηΣιζ

সাবলিস্টগুলির সকলের যোগফল গণনা করুন।

Ｉ§η⌕ζ⌈ζ

সর্বাধিক যোগফলের একটি সূচক সন্ধান করুন এবং সংশ্লিষ্ট সাবলিস্টটিকে আউটপুট দিন।

— নিল
সূত্র
1

Japt -h , 21 বাইট

এমন চ্যালেঞ্জগুলির মধ্যে একটিও আছে যেখানে আপনি গল্ফটি কীভাবে সম্পূর্ণরূপে ভুলে যান ?!

ð¤à fÊk_än ø1îmgUÃñx

চেষ্টা করে দেখুন

ð¤à fÊk_än ø1îmgUÃñx     :Implicit input of array U
ð                         :Indices of elements that return true when
 ¤                        :  Converted to a base-2 string (to account for 0s)
  à                       :Combinations
    f                     :Filter by
     Ê                    :  Length (to remove the empty combination)
      k_                  :Remove elements that return true
        än                :  Deltas
           ø1             :  Contains 1
             Ã            :End remove
              ®           :Map
               m          :  Map
                gU        :    Index into U
                  Ã       :End map
                   ñ      :Sort by
                    x     :  Sum
                          :Implicit output of last element
— রোমশ
সূত্র
1

পাইথন 2 , 63 70 65 বাইট

f=lambda a:a and max([a[:1],a[:1]+f(a[2:]),f(a[1:])],key=sum)or a

এটি অনলাইন চেষ্টা করুন!

আরবোতে 5 বাইট থেক্স

— চ্যাস ব্রাউন
সূত্র
আপনার পরীক্ষার [1, 7, 4, -2] [1, 4] 5 7কেসটি ভুল উত্তর পাচ্ছে।
— xnor
@ এক্সনর: এখনই ঠিক হয়ে গেছে।
— চ্যাস ব্রাউন
— আরবো
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.