गैर-आसन्न आइटम के साथ अधिकतम अभिव्यक्तियाँ

23

परिचय:

इन दो एसओ प्रश्नों (एक ही वर्ग से कोई संदेह नहीं) से प्रेरित: आसन्न तत्वों जावा और बिना किसी सरणी के गैर आसन्न तत्वों की अधिकतम राशि के सबर्रे में तत्वों को मुद्रित करें ।

चुनौती:

पूर्णांकों की एक सूची को देखते हुए, गैर-आसन्न तत्वों से मिलकर एक परिणाम उत्पन्न करता है जिसमें सबसे अधिक राशि होती है। यहाँ कुछ उदाहरण हैं:

  • [1,2,3,-1,-3,2,5]0-आधारित सूचकांकों में [1,3,5](एक राशि के साथ 9) परिणाम होगा [0,2,6]।
  • [4,5,4,3]या तो में परिणाम होगा [4,4](की राशि के साथ 80-आधारित सूचकांक में) [0,2]या [5,3](भी की राशि के साथ 80-आधारित सूचकांक पर) [1,3]।
  • [5,5,10,100,10,5]या तो 0-आधारित सूचकांकों में या [5,100,5](एक राशि के साथ 110) में परिणाम होगा ।[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-आधारित के बजाय किया जाता है)।
    • यदि आप कुंजी-मूल्य वाले जोड़े का उपयोग करते हैं, तो वे रिवर्स या यादृच्छिक क्रम में भी हो सकते हैं, क्योंकि यह स्पष्ट है कि युग्मित सूचकांक के कारण कौन से मूल्य हैं।
    • मूल्यों के बिना सिर्फ सूचकांकों का आउटपुट देने की अनुमति नहीं है। इसे या तो मानों को आउटपुट देना चाहिए, या कुंजी-मूल्य जोड़े के रूप में मान / सूचकांक (या 'आकार की' और 'मान' के लिए दो अलग-अलग सूचियां यदि आपकी पसंद की भाषा में कुंजी-मूल्य जोड़े संभव नहीं हैं)।
  • आपको केवल एक के बजाय अधिकतम राशि के साथ सभी संभव नतीजों को आउटपुट करने की अनुमति है।
  • जैसा कि आप उदाहरणों से देख सकते हैं, इनपुट-सूची में नकारात्मक और डुप्लिकेट किए गए मान हो सकते हैं। आप मान सकते हैं कि इनपुट-पूर्णांक सीमा के भीतर हैं [−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
@Arnauld हाँ, यदि मान उनके इंडेक्स के साथ की-वैल्यू जोड़े हैं तो यह स्पष्ट है कि इनपुट में कौन से इंडेक्स वैल्यूज़ हैं, इसलिए वे किसी भी क्रम में हो सकते हैं। इसे चुनौती विवरण में भी संपादित करेंगे।
— केविन क्रूज़सेन
2
बस यह सुनिश्चित करने के लिए: सूचकांकों का उत्पादन एक विकल्प नहीं है, क्या यह है?
— झबरा
1
शास्त्रीय शब्द "परवर्ती" है । हालांकि, सन्निहित बाद की सोच वाले लोगों की यह समस्या है। अगर हम वास्तव में यहां सेट के साथ काम कर रहे थे तो मैं "सबसेट" कहूंगा, लेकिन ये निश्चित रूप से अनुक्रम हैं - आदेश मामलों और डुप्लिकेट की अनुमति है।
— user2357112 मोनिका

जवाबों:

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 बाइट्स digEmAll के लिए धन्यवाद , जिन्होंने संयोग से मुझे भी पछाड़ दिया ।

एक के रूप में सबसे कम बाद में रिटर्न list, सूचकांकों द्वारा पहले lexicographically पर संबंधों को तोड़ने।

जानवर-बल सभी सूचकांक अनुवर्ती उत्पन्न करता है, फिर Filter उन लोगों के लिए है जो गैर-आसन्न हैं, अर्थात, जहां all(diff(x)>1)। फिर इन सूचकांकों का उपयोग [करते lहुए, [[पहले वाले का चयन करें जहां योग अधिकतम ( which.max) है।

मुझे पूरा यकीन है कि यह पहला R उत्तर है जो मैंने कभी लिखा है जो उपयोग करता है Filter!दुख की बात है, Filterअस्वाभाविक है, कोई आश्चर्य नहीं कि मैंने इसका इस्तेमाल कभी नहीं किया है ...

— ग्यूसेप
स्रोत
— E१ एक्सईएल
@digEmAll धन्यवाद!
— ग्यूसेप
5

05AB1E , 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

ब्रेकीलॉग (v2), 14 बाइट्स

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

इसे ऑनलाइन आज़माएं!

समारोह प्रस्तुत करना; बाएं से इनपुट, दाएं से आउटपुट, हमेशा की तरह। बहुत धीमी गति से; एक पांच-तत्व सूची शायद TIO पर परीक्षण के लिए अधिकतम है।

{~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

उपसर्गों से हमें मिलने वाले परिणाम गलत नहीं हैं, लेकिन यह भी दिलचस्प नहीं हैं; प्रत्यय लेने के माध्यम से सभी संभावित परिणाम उत्पन्न होते हैं (जो संभवतः सूची ही है, लेकिन खाली नहीं हो सकता है), लेकिन "प्रत्यय" "उपसर्ग या प्रत्यय" की तुलना में ब्राचीलॉग में अधिक क्रिया है, इसलिए मैं उस संस्करण के साथ चला गया जो कि terser (और कम है) कुशल लेकिन फिर भी सही)। मूल विचार यह है कि प्रत्येक तत्व को हम आउटपुट सूची में चाहते हैं, सन्निहित उपविदों में विभाजन को उस तत्व और तत्व को एक ही सबलिस्ट में रखना होगा (क्योंकि तत्व तत्व है) दूसरा हैतत्व का तत्व), इसलिए परिणाम में दो लगातार तत्व दिखाई नहीं दे सकते हैं। दूसरी ओर, यह बिल्कुल स्पष्ट है कि दो लगातार तत्वों के बिना कोई भी सूची परिणाम में दिखाई दे सकती है। इसलिए एक बार जब हमारे पास सभी संभावित उम्मीदवारों की सूची आ जाती है, तो हम बस उन सभी की रकम ले सकते हैं और देख सकते हैं कि कौन सा सबसे बड़ा है।

— ais523
स्रोत
3

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

[vएएलयूई,मैंnघईएक्स]

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

चरण 2

मीटरआर

.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

टी-एसक्यूएल, 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
— ग्यूसेप
स्रोत
जिज्ञासा से बाहर, आउटपुट ]]में एक के बजाय दो अनुगामी क्यों होते हैं ?
— केविन क्रूज़सेन
@ केविनक्रूजसेन दुभाषिया का सिर्फ एक और मजेदार क्विक; सभी सूचियाँ उसी तरह प्रिंट की जाती हैं, इसलिए [[1] [2]]मुद्रित हो जाती हैं , [[1]] [2]]]]जो सूची के आउटपुट / डीबग को पढ़ने के लिए कठिन बनाता है।
— ग्यूसेप
मुझे लगता है कि यह re.sub(" ?$","]",result)दुभाषिया में अभिव्यक्ति के कारण है जो इसके बजाय होना चाहिए re.sub(" +$","]",result)लेकिन मेरा अजगर सुपर खराब है।
— ग्यूसेप
2

वोल्फ्राम भाषा (गणितज्ञ) , 70 63 बाइट्स

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 बाइट्स @nimi से सभी प्रतिक्रिया के लिए धन्यवाद :)

मूल

अघोषित (मूल)

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..]
— nimi
— निम्मी
ओह, और Data.Functionअब आयात करने की आवश्यकता नहीं है।
— नीमी
यह बहुत अच्छा है, प्रतिक्रिया के लिए धन्यवाद :)
— बग
अगला h: हम आसन्न तत्वों की तलाश कर रहे हैं, यानी आसन्न सूचकांकों का अंतर होना चाहिए >1। zipWith(-)=<<tailइस तरह की भिन्नताओं की सूची बनाता है, लेकिन खाली सूची के लिए विफल रहता है, इसलिए हमें इससे छुटकारा पाने tailके subsequencesलिए एक अतिरिक्त की आवश्यकता है। इनलाइन फिर से। इसे ऑनलाइन आज़माएं!
— नीमी
1

चारकोल , 46 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⟦υ⟧η

चर uएक खाली सूची के साथ पूर्वनिर्धारित है। यह एक सूची में रखा गया है जिसे सौंपा गया है h। ये चर संचयकों के रूप में कार्य करते हैं। uसब्लिस्ट्स में इनपुट के नवीनतम तत्व शामिल होते हैं, qजबकि hसब्लिस्ट्स होते हैं जो नहीं होते हैं (और इसलिए इनपुट के अगले तत्व को जोड़ने के लिए उपयुक्त हैं)।

Ｆθ«

इनपुट के तत्वों पर लूप करें।

≔υζ

उन उप-सूचीकर्ताओं की सूची सहेजें जिनमें पिछले तत्व हैं।

≔Ｅη⁺κ⟦ι⟧υ

उन सभी उदात्तताओं को लें जिनमें पिछले तत्व शामिल नहीं है, वर्तमान तत्व को जोड़ते हैं, और परिणाम को उन उप-सूचीकर्ताओं की सूची के रूप में सहेजते हैं जिनमें वर्तमान तत्व शामिल हैं। (मैं 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
@ xnor: अब ठीक किया गया।
— चास ब्राउन
— 22
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.