Giriş:

Bu iki SO sorusundan esinlenerek (aynı sınıftan kuşku duyulmuyor ): öğeleri, java ve bir dizinin bitişik olmayan öğelerinin Maksimum toplamının, yazdırılacak olan bitişik elemanlar java'sı olmadan ve maksimum toplamın alt dizisine yazdırın .

Meydan okuma:

Bir tamsayı listesi verildiğinde, en yüksek toplamı olan bitişik olmayan öğelerden oluşan bir alt dizilim çıkar. İşte bazı örnekler:

• [1,2,3,-1,-3,2,5]0 tabanlı endekslerde [1,3,5](toplamla 9) sonuçlanır [0,2,6].
• [4,5,4,3]ya da neden olur [4,4]: (a toplamı 80 tabanlı endekslerine) [0,2]veya [5,3](aynı zamanda bir miktar ile 80 tabanlı endekslerine) [1,3].
• [5,5,10,100,10,5]0 tabanlı endekslerde [5,100,5](toplamla 110) sonuçlanabilir [0,3,5]veya [1,3,5].

Yukarıdaki bu örneklerde en önemlisi, elemanları içeren endeksler birbirlerinden en az 2 ayrıdır. Örneğe [5,5,10,100,10,5]daha derinlemesine bakarsak: bitişik olmayan öğeleri içeren aşağıdaki potansiyel alt dizilime sahibiz; altındaki endeksleri ile; toplamları bunun altında olduğunda:

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

Maksimum toplamlar olduğundan 110, [5,100,5]sonuç olarak çıkarız.

Meydan okuma kuralları:

• İndeks + değerinin anahtar / değer çiftlerini çıkarmanıza izin verilir. Yani yerine [5,100,5]çıkış can [[0,5],[3,100],[5,5]]veya [[1,5],[3,100],[5,5]](veya sonucu [[1,5],[4,100],[6,5]]/ [[2,5],[4,100],[6,5]]1 tabanlı indeksleme kullanılan yerine 0 tabanlı iken).
  • Anahtar-değer çiftleri kullanıyorsanız, bunlar aynı zamanda eşleştirilmiş indekse göre hangi değerlerin ifade edildiğinin açık olduğu için ters veya rasgele sırada da olabilirler.
  • Sadece değerleri olmayan endeksleri çıkarmak yasaktır. Değerleri veya anahtar / değer çiftleri olarak değerleri / indeksleri (veya seçtiğiniz anahtar değer çiftleri mümkün değilse, anahtar / değer çiftleri olarak aynı büyüklükteki 'anahtarlar ve' değerler için iki ayrı liste) vermelidir.
• Tüm olası alt eklerin yalnızca bir tane yerine maksimum toplamla çıkmasına izin verilir.
• Örneklerden görebileceğiniz gibi, giriş listesi negatif ve kopyalanmış değerler de içerebilir. Giriş tam sayılarının aralığında olduğunu varsayabilirsiniz .$[-999,999]$
• Çıktı listesi boş olamaz ve her zaman en az bir öğe içermelidir (bir liste yalnızca negatif değerler içeriyorsa, en düşük tek negatif değeri içeren bir liste sonuç olarak çıkarılır - son iki test durumuna bakın).
• Olası bir çıktı varsa ancak birden fazla farklı dizin için, her ikisinin de kopya görünmesine rağmen çıktısı alınmasına izin verilir. (yani yukarıdaki örnek, [[5,100,5],[5,100,5]]her iki olası indeks kombinasyonu için çıktı verebilir ).

Test durumları:

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

Kabuğu , 11 bayt

►Σ†!¹mü≈tṖŀ

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Yardımcı işlev %, ilk öğenin dahil edilip edilmeyeceğini veya ikincisini düşürüp düşürmeyeceğinizi veya ilk öğeyi atlayıp atmayacağınızı seçerek tekrarlanır. İlk elemanı toplamı olan ve ikinci elemanı çıktı için çıkarılan liste olan tuple olan tüm sonuçların maksimumunu alır.

Boş liste, en küçük hile olurdu bile izin verilmezse bu kuralı işlemek için, yazma şirin hile yapmak sum r<$ryerine sum r.bu öğelerinin tümü olduğu bir listesini yapar sum rve uzunluğu o taşımaktadır r. Bu şekilde, maksimum değeri seçtiğimizde, herhangi bir listeyi boş yerine öncelik sırasına koyarız r, ancak karşılaştırmalar olan ilk öğeye bağlıdır sum r.

R , 136 125 bayt

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

Çevrimiçi deneyin!

-6 bayt tesadüfen de beni aşan digEmAll sayesinde .

En kısa sonucu bir dizin olarak döndürür, listilk önce dizinleri sözlüksel olarak bağlar.

Brute-force tüm indeks alt dizgelerini üretir, daha sonra Filterbitişik olmayanlar için, yani nerede all(diff(x)>1). Daha sonra alt-gruplar [halinde l, bu endeksler kullanılarak seçilmesi [[toplamı maksimum ilk bir ( which.max).

Bunun yazdığım ilk R cevabı olduğuna eminim Filter! hüzünlü, Filterungolfy, hiç kullanmadığım için şaşırmadım ...

05AB1E , 14 bayt

Kevin Cruijssen sayesinde 1 bayt kaydedildi

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

Çevrimiçi deneyin! veya Test Paketi olarak

açıklama

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

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

Çevrimiçi deneyin!

İşlev sunumu; soldan giriş, her zamanki gibi sağdan çıkış. Çok yavaş; beş elemanlı bir liste muhtemelen TIO'da test yapmak için maksimum değerdir.

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

Öneklerden aldığımız sonuçlar yanlış değil, aynı zamanda ilginç değil; tüm olası sonuçlar bir son ek alarak elde edilir (muhtemelen listenin kendisidir ancak boş olamaz); verimli ama yine de doğru). Temel fikir, çıktı listesinde istediğimiz her öğe için, bitişik alt listelerdeki bölümün o öğeyi ve öğeyi daha önce aynı alt listeye yerleştirmesi gerektiğidir (çünkü öğe ikincialt listenin öğesi), yani iki ardışık öğe sonuçta görüntülenemez. Öte yandan, art arda iki eleman içermeyen herhangi bir listenin sonuçta görünebileceği açıktır. Dolayısıyla, olası tüm aday listelerine sahip olduğumuzda, hepsinin toplamını alabilir ve hangisinin en büyük olduğunu görebiliriz.

Jöle , 16 14 bayt

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

Çevrimiçi deneyin!

2 bayt kaydettiğiniz için @EriktheOutgolfer'a teşekkürler!

JavaScript (ES6),  138 132 130 129  126 bayt

Anahtar-değer çiftlerini çıkarır.

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

Çevrimiçi deneyin!

Aşama 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()

Adım 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 bayt

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

Çevrimiçi deneyin!

fBir sonraki öğeyi ( f(b:c)) atlayarak veya kullanarak ve bir sonrakini ( map(a:)(f c)) atlayarak ve tümüyle yinelemeli olarak çalışarak geçerli tüm alt dizileri oluşturur . Sonuç için, tüm alt dizileri ( f) oluşturun, boş alt diziyi bırakın (listedeki ilk sırada yer alır:) tail, çiftler yapın (<sum>,<subsequence>)( map((,)=<<sum)), maksimum değeri bulun (çiftler sözlükbilim sırasına göre karşılaştırılır) -> maximum) ve toplamı ( snd) bırakın .

Düzenleme: @Lynn sayesinde -1 bayt.

J , 47 bayt

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

Çevrimiçi deneyin!

FrownyFrog sayesinde -7 bayt

orijinal

J , 54 bayt

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

Çevrimiçi deneyin!

T-SQL, 122 119 118 bayt

Giriş bir tablo değişkenidir.

Bu sorgu, tablo değişkenindeki tüm öğeleri seçer, bunları tüm bitişik olmayan öğelerle daha yüksek konum değerleriyle birleştirir ve bu değerlerin en yüksek toplamı için oluşturulan metni gösterir.

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

Çevrimiçi deneyin ungolfed

Wolfram Dili (Mathematica) , 144 bayt

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

Çevrimiçi deneyin!

Pyth, 19 bayt

esDm@LQdtf!q#1.+TyU

Online Deneyin burada ya bir kerede tüm test durumları doğrulamak burada .

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 bayt

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

Çevrimiçi deneyin!

Ahh, E‡bazı garip şeyler yapar ... belgelere göre, gerektiği "Verilen uzunluk böyle bir şey yapmak ilistelerinin seti Xve uzunluk jendekslerinin seti Y, dönüş X[i][Y[j]]", ancak bunun yerine döner [X[i][Y[j]] X[i][Y[-j]]yapmamız gereken çok olumsuz indeksleme, tamamlayıcı temsil ev2%etmek sadece istediklerimizi çıkarı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 bayt

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}

Çevrimiçi deneyin!

@Giuseppe sayesinde -1

Wolfram Dili (Mathematica) , 70 63 bayt

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

Çevrimiçi deneyin!

Üst düzey arama

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

,1yanlışlıkla geçersiz kümeleri döndürmemek için gereklidir (aksi halde, örneğin {1,1,1}bir çıktısı ile sonuçlanacaktır {{1,1},{1,1},{1,1}}).

Haskell , 300 168 bayt

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

Çevrimiçi deneyin!

@Nimi dan gelen tüm geri bildirimler sayesinde -132 bayt :)

orijinal

Ungolfed (orijinal)

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

Kömür , 46 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

≔⟦υ⟧η

Değişken u, boş bir liste ile önceden tanımlanmıştır. Bu, atanmış bir listeye yerleştirilirh . Bu değişkenler biriktirici görevi görür. ugirişin en son öğesini içeren alt listeleri qiçerirken h, içermeyen alt listeleri içerir (ve bu nedenle girişin bir sonraki öğesini eklemek için uygundur).

Ｆθ«

Giriş öğelerinin üzerinde döngü.

≔υζ

Önceki öğeyi içeren alt listelerin listesini kaydedin.

≔Ｅη⁺κ⟦ι⟧υ

Önceki öğeyi içermeyen tüm alt listeleri al, geçerli öğeyi ekle ve sonucu, geçerli öğeyi içeren alt listelerin listesi olarak kaydet. (KullanmıyorumPush Listeyi klonladığım için burada .)

≔⁺ζηη»

Her iki önceki listeyi, geçerli öğeyi içermeyen yeni listelerin listesiyle birleştir.

≔Φ⁺υηιη

Alt listeleri bir kez daha birleştirin ve orijinal boş listeyi kaldırın (ki bu Kömür kömürü bir şekilde toplayamaz).

≔ＥηΣιζ

Tüm alt listelerin toplamlarını hesaplayın.

Ｉ§η⌕ζ⌈ζ

En büyük toplamın bir dizinini bulun ve karşılık gelen alt listenin çıktısını alın.

Japt -h , 22 bayt

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

Dene

Japt -h , 21 bayt

Hiç golf oynamayı tamamen unutacağınız zorluklardan biri oldu mu ?!

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

Dene

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

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

Çevrimiçi deneyin!

ArBo'ya 5 bayt thx