Pengantar:

Terinspirasi oleh dua pertanyaan SO ini (tidak diragukan lagi dari kelas yang sama): cetak elemen dalam subarray jumlah maksimum tanpa elemen yang berdekatan java dan jumlah maksimum elemen yang tidak berdekatan dari array, untuk dicetak .

Tantangan:

Diberikan daftar bilangan bulat, menghasilkan urutan yang terdiri dari elemen yang tidak berdekatan yang memiliki jumlah tertinggi. Berikut beberapa contoh:

• [1,2,3,-1,-3,2,5]akan menghasilkan [1,3,5](dengan jumlah 9) pada indeks berbasis 0 [0,2,6].
• [4,5,4,3]akan menghasilkan [4,4](dengan jumlah 8) pada indeks berbasis 0 [0,2]atau [5,3](juga dengan jumlah 8) pada indeks berbasis 0 [1,3].
• [5,5,10,100,10,5]akan menghasilkan [5,100,5](dengan jumlah 110) pada indeks berbasis 0 [0,3,5]atau [1,3,5].

Yang paling penting tentang contoh-contoh di atas, indeks yang mengandung unsur-unsur setidaknya 2 terpisah satu sama lain. Jika kita melihat contoh [5,5,10,100,10,5]lebih mendalam: kita memiliki potensi berikut berikut yang mengandung item yang tidak berdekatan; dengan indeks mereka di bawahnya; dengan jumlah mereka di bawah itu:

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

Karena jumlah maksimumnya adalah 110, kami mengeluarkan [5,100,5]sebagai hasilnya.

Aturan tantangan:

• Anda diizinkan untuk mengeluarkan pasangan nilai kunci dari nilai indeks +. Jadi alih-alih [5,100,5]Anda dapat menampilkan [[0,5],[3,100],[5,5]]atau [[1,5],[3,100],[5,5]]sebagai hasilnya (atau [[1,5],[4,100],[6,5]]/ [[2,5],[4,100],[6,5]]ketika pengindeksan berbasis 1 digunakan, bukan berbasis 0).
  • Jika Anda menggunakan pasangan nilai kunci, mereka juga bisa dalam urutan terbalik atau acak, karena jelas nilai mana yang dimaksudkan karena indeks pasangan.
  • Mengeluarkan hanya indeks tanpa nilai tidak diizinkan. Ini harus menampilkan nilai, atau nilai / indeks sebagai pasangan nilai kunci (atau dua daftar terpisah untuk 'kunci' dan 'nilai' dengan ukuran yang sama jika pasangan nilai kunci tidak dimungkinkan dalam bahasa pilihan Anda).
• Anda diizinkan untuk menampilkan semua kemungkinan berikutnya dengan jumlah maksimum, bukan hanya satu.
• Seperti yang Anda lihat dari contoh, daftar input dapat berisi nilai negatif dan duplikat juga. Anda dapat menganggap bilangan bulat input berada dalam kisaran $[-999,999]$ .
• Daftar keluaran tidak boleh kosong dan harus selalu mengandung setidaknya satu elemen (jika daftar hanya akan berisi nilai negatif, daftar yang berisi nilai negatif terendah tunggal akan dihasilkan sebagai hasilnya - lihat dua kasus uji terakhir).
• Jika ada satu kemungkinan output tetapi untuk beberapa indeks berbeda, itu diperbolehkan untuk menghasilkan keduanya meskipun mereka mungkin terlihat duplikat. (yaitu contoh di atas, dapat menampilkan [[5,100,5],[5,100,5]]untuk kedua kombinasi indeks yang mungkin).

Kasus uji:

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

Sekam , 11 byte

►Σ†!¹mü≈tṖŀ

Cobalah online!

Penjelasan

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

Cobalah online!

Fungsi helper %secara rekursif bercabang untuk memilih apakah menyertakan elemen pertama dan menjatuhkan elemen kedua, atau untuk melewatkan elemen pertama. Dibutuhkan maksimum dari semua hasil, yaitu tupel yang elemen pertamanya adalah jumlah, dan elemen kedua adalah daftar terkait yang diekstraksi untuk output.

Untuk menangani aturan bahwa daftar kosong dianulir walaupun memiliki trik terkecil, kita melakukan trik menulis yang lucu sum r<$rdaripada sum r. Ini membuat daftar yang unsur-unsurnya semua sum rdan panjangnya berapa r. Dengan begitu, ketika kami memilih maksimum, kami memprioritaskan daftar apa pun daripada yang kosong r, tetapi perbandingannya bergantung pada elemen pertama yaitu 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))]

Cobalah online!

-6 byte terima kasih kepada digEmAll , yang notabene juga mengalahkan saya .

Mengembalikan urutan terpendek sebagai list, memutuskan ikatan pada leksikografis pertama dengan indeks.

Brute-force menghasilkan semua urutan indeks, kemudian Filters untuk yang tidak berdekatan, yaitu di mana all(diff(x)>1). Kemudian subset [ke dalam lmenggunakan indeks ini, memilih [[yang pertama di mana jumlahnya adalah max ( which.max).

Saya cukup yakin ini adalah jawaban R pertama yang pernah saya tulis yang menggunakan Filter! sedih, Filteritu ungolfy, tidak heran aku tidak pernah menggunakannya ...

05AB1E , 14 byte

Disimpan 1 byte berkat Kevin Cruijssen

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

Cobalah online! atau sebagai Test Suite

Penjelasan

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

Cobalah online!

Pengiriman fungsi; input dari kiri, output dari kanan, seperti biasa. Sangat lambat; daftar lima elemen mungkin adalah maksimum untuk pengujian pada 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

Hasil yang kami dapatkan dari awalan tidak salah, tetapi juga tidak menarik; semua hasil yang mungkin dihasilkan melalui mengambil suffix (yang mungkin daftar itu sendiri, tetapi tidak boleh kosong), tetapi "suffix" lebih banyak digunakan di Brachylog daripada "awalan atau suffix", jadi saya memilih versi yang terser (dan kurang efisien tapi tetap benar). Ide dasarnya adalah bahwa untuk setiap elemen yang kita inginkan dalam daftar output, partisi ke dalam daftar yang berdekatan perlu menempatkan elemen dan elemen sebelum ke dalam sublist yang sama (karena elemen adalah kedua).elemen sublist), sehingga dua elemen berturut-turut tidak dapat muncul di hasil. Di sisi lain, cukup jelas bahwa daftar apa pun tanpa dua elemen berturut-turut dapat muncul di hasilnya. Jadi begitu kita memiliki semua daftar calon yang mungkin, kita bisa mengambil jumlah semua dari mereka dan melihat mana yang terbesar.

Jelly , 16 14 byte

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

Cobalah online!

Terima kasih kepada @EriktheOutgolfer karena telah menghemat 2 byte!

JavaScript (ES6),  138 132 130 129  126 byte

Menghasilkan pasangan nilai kunci.

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

Cobalah online!

Langkah 1

$[value, index]$ pasangan.

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

Langkah 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

Cobalah online!

fmembangun semua urutan yang valid dengan melewatkan elemen berikutnya ( f(b:c)) atau menggunakannya dan melewatkan berikutnya ( map(a:)(f c)) dan mengerjakan sisanya secara rekursif. Untuk hasilnya, buat semua urutan ( f), jatuhkan urutan kosong (yang muncul pertama kali dalam daftar tail:), buat pasangan (<sum>,<subsequence>)( map((,)=<<sum)), cari maksimum (pasangan dibandingkan dalam urutan leksikografis) -> maximum) dan turunkan jumlah ( snd).

Sunting: -1 byte berkat @Lynn.

J , 47 byte

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

Cobalah online!

-7 byte berkat FrownyFrog

asli

J , 54 byte

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

Cobalah online!

T-SQL, 122 119 118 byte

Input adalah variabel tabel.

Kueri ini mengambil semua elemen dari variabel tabel, menggabungkannya dengan semua elemen yang tidak berdekatan dengan nilai posisi yang lebih tinggi dan menampilkan teks yang dihasilkan untuk jumlah tertinggi dari nilai-nilai ini.

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

Cobalah secara online ungolfed

Bahasa Wolfram (Mathematica) , 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]]&

Cobalah online!

Pyth, 19 byte

esDm@LQdtf!q#1.+TyU

Coba online di sini , atau verifikasi semua uji sekaligus di sini .

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%Σ⌠

Cobalah online!

Ugh, E‡melakukan beberapa hal aneh ... menurut dokumentasi, itu harus melakukan sesuatu seperti "diberikan idaftar Xpanjang dan panjang jindeks Y, kembali X[i][Y[j]]", tetapi sebaliknya mengembalikan di [X[i][Y[j]] X[i][Y[-j]]mana pengindeksan negatif merupakan pelengkap, jadi kita harus lakukan ev2%untuk ekstrak hanya yang kita inginkan.

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}

Cobalah online!

-1 terima kasih kepada @Giuseppe

Bahasa Wolfram (Mathematica) , 70 63 byte

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

Cobalah online!

Pencarian tingkat tinggi

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

,1diperlukan agar tidak secara tidak sengaja mengembalikan set yang tidak valid (jika tidak, misalnya input {1,1,1}akan menghasilkan output dari{{1,1},{1,1},{1,1}} )

Haskell , 300 168 bytes

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

Cobalah online!

-132 byte terima kasih atas semua umpan balik dari @nimi :)

Asli

Tidak disatukan (asli)

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

Arang , 46 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

≔⟦υ⟧η

Variabel uditentukan sebelumnya dengan daftar kosong. Ini dimasukkan ke dalam daftar yang ditugaskan h. Variabel-variabel ini bertindak sebagai akumulator. uberisi sublists yang menyertakan elemen input terbaru qsementara hberisi sublists yang tidak (dan karenanya cocok untuk menambahkan elemen input berikutnya).

Ｆθ«

Lingkarkan elemen-elemen input.

≔υζ

Simpan daftar sublists yang berisi elemen sebelumnya.

≔Ｅη⁺κ⟦ι⟧υ

Ambil semua sublists yang tidak mengandung elemen sebelumnya, tambahkan elemen saat ini, dan simpan hasilnya sebagai daftar sublists yang berisi elemen saat ini. (Saya tidak menggunakan di Pushsini karena saya perlu mengkloning daftar.)

≔⁺ζηη»

Gabungkan kedua daftar sebelumnya ke dalam daftar baru daftar yang tidak mengandung elemen saat ini.

≔Φ⁺υηιη

Gabungkan subtitel untuk terakhir kalinya dan hapus daftar kosong asli (yang tidak dapat dijumlahkan oleh Arang).

≔ＥηΣιζ

Hitung jumlah dari semua sublists.

Ｉ§η⌕ζ⌈ζ

Temukan indeks dari jumlah terbesar dan hasilkan sublist yang sesuai.

Japt -h , 22 byte

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

Cobalah

Japt -h , 21 byte

Pernah memiliki salah satu tantangan di mana Anda benar-benar lupa bagaimana bermain golf ?!

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

Cobalah

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

Cobalah online!

5 byte thx ke ArBo