บทนำ:

แรงบันดาลใจจากทั้งสองคำถาม SO (ข้อสงสัยจากชั้นเรียนเดียวกันไม่): พิมพ์องค์ประกอบใน subarray ของจำนวนเงินสูงสุดโดยไม่องค์ประกอบที่อยู่ติดกันชวาและผลรวมสูงสุดขององค์ประกอบที่ไม่อยู่ติดกันของอาร์เรย์ที่จะพิมพ์

ท้าทาย:

รับรายการจำนวนเต็มเอาต์พุตอนุกรมที่ประกอบด้วยองค์ประกอบที่ไม่อยู่ติดกันซึ่งมีผลรวมสูงสุด นี่คือตัวอย่าง:

• [1,2,3,-1,-3,2,5]จะส่งผลให้[1,3,5](กับผลรวมของ9) [0,2,6]ที่ดัชนี
• [4,5,4,3]จะส่งผลอย่างใดอย่างหนึ่ง[4,4](ที่มีผลรวมของ8) ที่ดัชนี 0-based [0,2]หรือ[5,3](ยังมีผลรวมของ8) [1,3]ที่ดัชนี
• [5,5,10,100,10,5]จะส่งผลให้[5,100,5](ที่มีผลรวมของ110) ที่ทั้งดัชนี 0-based หรือ[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)
  • หากคุณใช้คู่คีย์ - ค่าพวกเขาสามารถอยู่ในลำดับย้อนกลับหรือแบบสุ่มเนื่องจากมันชัดเจนว่าค่าใดที่มีความหมายเนื่องจากดัชนีที่จับคู่
  • ไม่อนุญาตให้แสดงเฉพาะดัชนีที่ไม่มีค่า ควรส่งออกค่าหรือค่า / ดัชนีเป็นคู่ของคีย์ - ค่า (หรือสองรายการที่แยกกันสำหรับ 'คีย์' และ 'ค่า' ที่มีขนาดเท่ากันหากไม่สามารถใช้คู่ของคีย์ - ค่าในภาษาที่คุณเลือก)
• คุณได้รับอนุญาตให้ส่งออกลำดับที่เป็นไปได้ทั้งหมดด้วยผลรวมสูงสุดแทนที่จะเป็นเพียงหนึ่ง
• ดังที่คุณเห็นจากตัวอย่างรายการอินพุตสามารถมีค่าลบและค่าซ้ำเช่นกัน คุณสามารถถือว่าอินจำนวนเต็มอยู่ในช่วง[-999999]$[-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

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

Haskell , 60 ไบต์

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

ลองออนไลน์!

ฟังก์ชั่นผู้ช่วยจะ%แยกสาขาซ้ำ ๆ เพื่อเลือกว่าจะรวมองค์ประกอบแรกแล้วปล่อยองค์ประกอบที่สองหรือข้ามองค์ประกอบแรก ใช้เวลาสูงสุดของผลลัพธ์ทั้งหมดซึ่งเป็น tuples ซึ่งองค์ประกอบแรกคือผลรวมและองค์ประกอบที่สองคือรายการที่สอดคล้องกันซึ่งถูกแยกสำหรับผลลัพธ์

เพื่อจัดการกับกฎว่ารายการที่ว่างเปล่าไม่ได้รับอนุญาตแม้ว่ามันจะมีเคล็ดลับเล็ก ๆ ที่เราทำเคล็ดลับน่ารักของการเขียนsum r<$rมากกว่าsum rครั้งนี้ทำให้รายการมีองค์ประกอบทั้งหมดเป็นและมีความยาวของsum r rด้วยวิธีนี้เมื่อเราเลือกสูงสุดที่เราให้ความสำคัญกับรายการใด ๆ ในช่วงที่ว่างเปล่าแต่อย่างอื่นการเปรียบเทียบขึ้นอยู่กับองค์ประกอบแรกซึ่งเป็นrsum r

R , 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ที่บังเอิญยังoutgolfed ฉัน

ส่งคืนการเรียงลำดับที่สั้นที่สุดเป็น a list, แบ่งความสัมพันธ์กับ lexicographically เป็นอันดับแรกโดยดัชนี

แรงเดรัจฉานสร้าง subsequences ดัชนีทั้งหมดแล้วFilters all(diff(x)>1)สำหรับผู้ที่ไม่อยู่ติดกันคือที่ จากนั้นเซ็ตย่อย[ให้lใช้ดัชนีเหล่านี้เลือก[[อันแรกที่ผลรวมคือค่าสูงสุด ( which.max)

ฉันค่อนข้างแน่ใจว่านี่เป็นคำตอบ R แรกที่ฉันเคยเขียนที่ใช้Filter! เศร้าFilterไม่ดีไม่น่าแปลกใจที่ฉันไม่เคยใช้มัน ...

05AB1E , 14 ไบต์

บันทึก 1 ไบต์ขอบคุณKevin Cruijssen

ā<æʒĆ¥≠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

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

ผลลัพธ์ที่เราได้รับจากคำนำหน้านั้นไม่ถูกต้อง แต่ก็ไม่น่าสนใจเช่นกัน ผลลัพธ์ที่เป็นไปได้ทั้งหมดถูกสร้างขึ้นผ่านการต่อท้าย (ซึ่งอาจเป็นรายการตัวเอง แต่ไม่สามารถว่าง) แต่ "ต่อท้าย" เป็น verbose เพิ่มเติมใน Brachylog มากกว่า "คำนำหน้าหรือคำต่อท้าย" ดังนั้นฉันไปกับรุ่นที่ terser (และน้อยกว่า มีประสิทธิภาพ แต่ก็ยังถูกต้อง) แนวคิดพื้นฐานคือสำหรับแต่ละองค์ประกอบที่เราต้องการในรายการผลลัพธ์พาร์ติชันลงในรายการย่อยที่อยู่ติดกันจำเป็นต้องวางองค์ประกอบนั้นและองค์ประกอบก่อนลงในรายการย่อยเดียวกัน (เพราะองค์ประกอบเป็นที่สององค์ประกอบของรายการย่อย) ดังนั้นองค์ประกอบที่สองติดต่อกันจะไม่ปรากฏในผลลัพธ์ ในทางกลับกันมันค่อนข้างชัดเจนว่ารายการใด ๆ ที่ไม่มีองค์ประกอบต่อเนื่องสองรายการสามารถปรากฏในผลลัพธ์ได้ ดังนั้นเมื่อเรามีรายชื่อผู้สมัครที่เป็นไปได้ทั้งหมดเราก็สามารถรับผลรวมของพวกเขาทั้งหมดและดูว่ารายการใดที่ใหญ่ที่สุด

เยลลี่ , 16 14 ไบต์

JŒPḊf’$ÐḟịµSÞṪ

ลองออนไลน์!

ขอบคุณ @EriktheOutgolfer สำหรับการบันทึก 2 ไบต์!

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

$[value, index]$

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

$m$$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[]

Haskell, 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 ไบต์ขอบคุณ @Lynn

J , 47 ไบต์

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

ลองออนไลน์!

-7 ไบต์ขอบคุณ FrownyFrog

เป็นต้นฉบับ

J , 54 ไบต์

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

ลองออนไลน์!

T-SQL, 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

ลองมันออนไลน์ ungolfed

ภาษา Wolfram (Mathematica) , 144 ไบต์

If[Max[a=#]>(d=Max[m=Tr/@(g=a[[#]]&/@Select[Subsets[Range[x=Length@#],{2,x}]&@#,FreeQ[Differences@#,1]&]&@a)]),{Max@a},g[[#]]&@@@Position[m,d]]&

ลองออนไลน์!

Pyth, 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

Gaiaขนาด 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

R , 108 107 ไบต์

function(v,M=-Inf){for(j in J<-seq(a=v))for(i in combn(J,j,,F))if(all(diff(i)>1)&sum(v[i])>sum(M))M=v[i]
M}

ลองออนไลน์!

-1 ต้องขอบคุณ @Giuseppe

ภาษา Wolfram (Mathematica) , 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}})

Haskell , 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 :)

เป็นต้นฉบับ

Ungolfed (ดั้งเดิม)

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

ถ่าน 46 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการสร้างรหัสเวอร์ชัน คำอธิบาย:

≔⟦υ⟧η

ตัวแปรuถูกกำหนดไว้ล่วงหน้าพร้อมกับรายการที่ว่างเปล่า hนี้จะใส่ในรายการที่ได้รับมอบหมายให้เป็น ตัวแปรเหล่านี้ทำหน้าที่เป็นตัวสะสม uมีรายการย่อยที่มีองค์ประกอบล่าสุดของอินพุตqในขณะที่hมีรายการย่อยที่ไม่ได้ (และเหมาะสมสำหรับการผนวกองค์ประกอบถัดไปของอินพุต)

Ｆθ«

วนรอบองค์ประกอบของอินพุต

≔υζ

บันทึกรายการของรายการย่อยที่มีองค์ประกอบก่อนหน้า

≔Ｅη⁺κ⟦ι⟧υ

ใช้รายการย่อยทั้งหมดที่ไม่มีองค์ประกอบก่อนหน้าผนวกองค์ประกอบปัจจุบันและบันทึกผลลัพธ์เป็นรายการของรายการย่อยที่มีองค์ประกอบปัจจุบัน (ฉันไม่ได้ใช้Pushที่นี่เพราะฉันต้องการโคลนรายการ)

≔⁺ζηη»

เชื่อมทั้งรายการย่อยก่อนหน้าเข้ากับรายการใหม่ของรายการย่อยที่ไม่มีองค์ประกอบปัจจุบัน

≔Φ⁺υηιη

เชื่อมโยงรายการย่อยหนึ่งครั้งล่าสุดและลบรายการว่างเปล่าเดิม (ซึ่งถ่านไม่สามารถหาผลรวมได้)

≔ＥηΣιζ

คำนวณผลรวมของรายการย่อยทั้งหมด

Ｉ§η⌕ζ⌈ζ

ค้นหาดัชนีของผลรวมที่ยิ่งใหญ่ที่สุดและแสดงรายการย่อยที่เกี่ยวข้อง

Japt -h , 22 ไบต์

Êo à k_mÄ øZÃm!gU
fÊñx

ลองมัน

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

Python 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 ไบต์ขอบคุณไปยังArBo