Giới thiệu:

Lấy cảm hứng từ hai câu hỏi SO này (không nghi ngờ gì từ cùng một lớp): in các phần tử trong tập con của tổng tối đa mà không có phần tử liền kề java và Tổng tối đa của các phần tử không liền kề của một mảng, sẽ được in .

Thử thách:

Đưa ra một danh sách các số nguyên, xuất ra một chuỗi con gồm các phần tử không liền kề có tổng cao nhất. Dưới đây là một số ví dụ:

• [1,2,3,-1,-3,2,5]sẽ dẫn đến [1,3,5](với một tổng số 9) tại các chỉ số dựa trên 0 [0,2,6].
• [4,5,4,3]sẽ dẫn đến một trong hai [4,4](với một tổng số 8) tại các chỉ số dựa trên 0 [0,2]hoặc [5,3](cũng với một tổng số 8) tại các chỉ số dựa trên 0 [1,3].
• [5,5,10,100,10,5]sẽ dẫn đến [5,100,5](với một tổng số 110) tại các chỉ số dựa trên 0 [0,3,5]hoặc [1,3,5].

Điều quan trọng nhất về các ví dụ trên, các chỉ số chứa các phần tử cách nhau ít nhất 2. Nếu chúng ta xem xét ví dụ [5,5,10,100,10,5]sâu hơn: chúng ta có các chuỗi con tiềm năng sau có chứa các mục không liền kề; với các chỉ số của họ bên dưới nó; với số tiền của họ dưới đây:

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

Vì tổng số tiền tối đa là 110, chúng tôi xuất [5,100,5]kết quả.

Quy tắc thử thách:

• Bạn được phép xuất các cặp khóa-giá trị của chỉ số + giá trị. Vì vậy, thay vì [5,100,5]bạn có thể xuất [[0,5],[3,100],[5,5]]hoặc [[1,5],[3,100],[5,5]]kết quả (hoặc [[1,5],[4,100],[6,5]]/ [[2,5],[4,100],[6,5]]khi lập chỉ mục dựa trên 1 được sử dụng thay vì dựa trên 0).
  • Nếu bạn sử dụng các cặp khóa-giá trị, chúng cũng có thể theo thứ tự ngược hoặc ngẫu nhiên, vì rõ ràng giá trị nào có nghĩa là do chỉ số được ghép nối.
  • Chỉ xuất ra các chỉ số không có giá trị. Nó sẽ xuất các giá trị hoặc các giá trị / chỉ mục dưới dạng cặp khóa-giá trị (hoặc hai danh sách riêng biệt cho 'khóa' và 'giá trị' có cùng kích thước nếu không thể sử dụng cặp giá trị khóa trong ngôn ngữ bạn chọn).
• Bạn được phép xuất tất cả các chuỗi con có thể với tổng tối đa thay vì chỉ một.
• Như bạn có thể thấy từ các ví dụ, danh sách đầu vào cũng có thể chứa các giá trị âm và trùng lặp. Bạn có thể giả sử các số nguyên đầu vào nằm trong phạm vi $[-999,999]$ .
• Danh sách đầu ra không thể để trống và phải luôn chứa ít nhất một phần tử (nếu danh sách chỉ chứa giá trị âm, danh sách chứa giá trị âm thấp nhất sẽ là kết quả đầu ra - xem hai trường hợp kiểm tra cuối cùng).
• Nếu có một đầu ra có thể nhưng đối với nhiều chỉ số khác nhau, nó được phép xuất cả hai đầu ra mặc dù chúng có thể trông trùng lặp. (tức là ví dụ trên, có thể xuất ra [[5,100,5],[5,100,5]]cho cả hai kết hợp chỉ mục có thể).

Các trường hợp thử nghiệm:

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 byte

►Σ†!¹mü≈tṖŀ

Hãy thử trực tuyến!

Giải trình

►Σ†!¹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 byte

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

Hãy thử trực tuyến!

Hàm trợ giúp %phân nhánh đệ quy về việc chọn bao gồm phần tử đầu tiên và bỏ phần tử thứ hai hoặc bỏ qua phần tử đầu tiên. Nó lấy tối đa của tất cả các kết quả, đó là các bộ có phần tử đầu tiên là tổng và phần tử thứ hai là danh sách tương ứng được trích xuất cho đầu ra.

Để xử lý quy tắc rằng danh sách trống không được phép ngay cả khi nó có thủ thuật nhỏ nhất, chúng tôi thực hiện một mẹo viết dễ thương sum r<$rhơn là sum r. Điều này tạo ra một danh sách có tất cả các yếu tố sum rvà độ dài của nó r. Theo cách đó, khi chúng tôi chọn mức tối đa, chúng tôi sẽ ưu tiên bất kỳ danh sách nào trong một danh sách trống r, nhưng nếu không thì sự so sánh phụ thuộc vào yếu tố đầu tiên sum r.

R , 136 125 byte

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

Hãy thử trực tuyến!

-6 byte nhờ digEmAll , người tình cờ cũng vượt xa tôi .

Trả về chuỗi ngắn nhất dưới dạng a list, phá vỡ các mối quan hệ trên từ vựng trước tiên bằng các chỉ số.

Brute-force tạo ra tất cả các chuỗi chỉ mục, sau đó Filters cho những thứ không liền kề, tức là ở đâu all(diff(x)>1). Sau đó, tập hợp [lại lbằng cách sử dụng các chỉ số này, chọn [[cái đầu tiên trong đó tổng là max ( which.max).

Tôi khá chắc chắn đây là câu trả lời R đầu tiên tôi từng viết sử dụng Filter! buồn, Filterlà vô duyên, không có gì lạ khi tôi chưa bao giờ sử dụng nó ...

05AB1E , 14 byte

Đã lưu 1 byte nhờ Kevin Cruijssen

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

ā<               # 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 byte

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

Hãy thử trực tuyến!

Chức năng trình; đầu vào từ bên trái, đầu ra từ bên phải, như thường lệ. Rất chậm; một danh sách năm yếu tố có lẽ là tối đa để thử nghiệm trên 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

Kết quả chúng tôi nhận được từ tiền tố không chính xác, nhưng cũng không thú vị; tất cả các kết quả có thể được tạo ra thông qua việc sử dụng một hậu tố (có thể là chính danh sách, nhưng không thể để trống), nhưng "hậu tố" dài dòng hơn trong Brachylog so với "tiền tố hoặc hậu tố", vì vậy tôi đã đi với phiên bản đó là (và ít hơn hiệu quả nhưng vẫn đúng). Ý tưởng cơ bản là đối với mỗi phần tử mà chúng ta muốn trong danh sách đầu ra, phân vùng thành các danh sách con liền kề cần đặt phần tử đó và phần tử trước vào cùng một danh sách con (vì phần tử là thứ haiphần tử của danh sách con), do đó hai phần tử liên tiếp không thể xuất hiện trong kết quả. Mặt khác, khá rõ ràng rằng bất kỳ danh sách nào không có hai yếu tố liên tiếp đều có thể xuất hiện trong kết quả. Vì vậy, một khi chúng ta có tất cả các danh sách ứng cử viên có thể, chúng ta có thể lấy tổng của tất cả chúng và xem cái nào là lớn nhất.

Thạch , 16 14 byte

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

Hãy thử trực tuyến!

Cảm ơn @EriktheOutgolfer đã lưu 2 byte!

JavaScript (ES6),  138 132 130 129  126 byte

Đầu ra các cặp khóa-giá trị.

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

Hãy thử trực tuyến!

Bước 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()

Bước 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 byte

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

Hãy thử trực tuyến!

fxây dựng tất cả các chuỗi con hợp lệ bằng cách bỏ qua phần tử tiếp theo ( f(b:c)) hoặc sử dụng nó và bỏ qua phần tiếp theo ( map(a:)(f c)) và làm việc đệ quy trên phần còn lại. Để có kết quả, hãy xây dựng tất cả các chuỗi con ( f), bỏ chuỗi con trống (xuất hiện đầu tiên trong danh sách tail:), tạo cặp (<sum>,<subsequence>)( map((,)=<<sum)), tìm mức tối đa (các cặp được so sánh theo thứ tự từ điển) -> maximum) và thả tổng ( snd).

Chỉnh sửa: -1 byte nhờ @Lynn.

J , 47 byte

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

Hãy thử trực tuyến!

-7 byte nhờ FrownyFrog

nguyên

J , 54 byte

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

Hãy thử trực tuyến!

T-SQL, 122 119 118 byte

Đầu vào là một biến bảng.

Truy vấn này chọn tất cả các phần tử từ biến bảng, kết hợp các phần tử này với tất cả các phần tử không liền kề với các giá trị vị trí cao hơn và hiển thị văn bản được tạo cho tổng giá trị cao nhất của các giá trị này.

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

Dùng thử trực tuyến ungolfed

Ngôn ngữ Wolfram (Mathicala) , 144 byte

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]]&

Hãy thử trực tuyến!

Bình thường, 19 byte

esDm@LQdtf!q#1.+TyU

Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

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 byte

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

Hãy thử trực tuyến!

Ugh, E‡hiện một số thứ kỳ lạ ... theo các tài liệu, nó nên làm điều gì đó như "cho chiều dài ibộ danh sách Xvà thời gian jtập hợp các chỉ số Y, lợi nhuận X[i][Y[j]]", nhưng thay vì lợi nhuận [X[i][Y[j]] X[i][Y[-j]]mà đánh chỉ số tiêu cực thể hiện sự bổ sung, vì vậy chúng ta phải làm ev2%để chỉ trích xuất những cái chúng ta muốn

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 byte

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}

Hãy thử trực tuyến!

-1 cảm ơn @Giuseppe

Ngôn ngữ Wolfram (Mathicala) , 70 63 byte

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

Hãy thử trực tuyến!

Tìm kiếm cấp cao

          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được yêu cầu để không vô tình trả về các bộ không hợp lệ (ví dụ, nếu không, đầu vào {1,1,1}sẽ dẫn đến đầu ra là {{1,1},{1,1},{1,1}})

Haskell , 300 168 byte

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..]

Hãy thử trực tuyến!

-132 byte nhờ tất cả các phản hồi từ @nimi :)

Nguyên

Ungolfed (bản gốc)

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

than củi , 46 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔⟦υ⟧η

Biến uđược xác định trước với một danh sách trống. Điều này được đặt trong một danh sách được gán cho h. Các biến này đóng vai trò là người tích lũy. uchứa danh sách con bao gồm yếu tố mới nhất của đầu vàoq trong khi hchứa các danh sách con không (và do đó phù hợp để nối thêm phần tử tiếp theo của đầu vào).

Ｆθ«

Lặp lại các yếu tố của đầu vào.

≔υζ

Lưu danh sách các danh sách con có chứa các yếu tố trước đó.

≔Ｅη⁺κ⟦ι⟧υ

Lấy tất cả các danh sách phụ không chứa phần tử trước đó, nối phần tử hiện tại và lưu kết quả làm danh sách danh sách phụ có chứa phần tử hiện tại. (Tôi không sử dụngPush ở đây vì tôi cần sao chép danh sách.)

≔⁺ζηη»

Ghép cả hai danh sách con trước vào danh sách mới của danh sách phụ không chứa thành phần hiện tại.

≔Φ⁺υηιη

Ghép nối danh sách con lần cuối và xóa danh sách trống ban đầu (dù sao Char Char không thể tổng hợp).

≔ＥηΣιζ

Tính tổng của tất cả các danh sách con.

Ｉ§η⌕ζ⌈ζ

Tìm một chỉ số của tổng lớn nhất và xuất ra danh sách con tương ứng.

Japt -h , 22 byte

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

Thử nó

Japt -h , 21 byte

Bạn đã bao giờ có một trong những thử thách mà bạn hoàn toàn quên cách chơi golf?!

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

Thử nó

ð¤à 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 byte

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

Hãy thử trực tuyến!

5 byte thx đến ArBo