소개:

이러한 두 질문 SO (동일한 클래스 의심)에 의해 고무 : 인접 요소없이 자바 최대 액수의 부분 배열의 요소의 출력 및 배열의 비 인접 요소들의 최대 합을 출력한다 .

도전:

정수 목록이 주어지면 가장 높은 합계를 가진 인접하지 않은 요소로 구성된 하위 시퀀스를 출력하십시오. 다음은 몇 가지 예입니다.

• [1,2,3,-1,-3,2,5]0부터 시작하는 인덱스 에서 [1,3,5](합계 9)가됩니다 [0,2,6].
• [4,5,4,3]어느 초래 [4,4](a의 합 80 기반 인덱스 AT) [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 기반 대신 1 기반 인덱싱을 사용하는 경우). [[0,5],[3,100],[5,5]][[1,5],[3,100],[5,5]][[1,5],[4,100],[6,5]][[2,5],[4,100],[6,5]]
  • 키-값 쌍을 사용하는 경우 쌍 인덱스로 인해 어떤 값이 의미가 있는지 명확하기 때문에 역순 또는 임의 순서 일 수도 있습니다.
  • 값이없는 인덱스 만 출력 할 수 없습니다. 값 또는 키 / 값 쌍으로 값 / 표시를 출력해야합니다 (또는 선택한 언어에서 키-값 쌍을 사용할 수없는 경우 동일한 크기의 '키'및 '값'에 대한 두 개의 분리 된 목록).
• 가능한 모든 하위 시퀀스를 하나가 아닌 최대 합계로 출력 할 수 있습니다.
• 예제에서 볼 수 있듯이 입력 목록에는 음수 값과 중복 값도 포함될 수 있습니다. 당신은 입력 정수 범위 내에있는 가정 할 수있다 $[-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

껍질 , 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]

하스켈 , 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.

R , 136125 바이트

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

온라인으로 사용해보십시오!

digEmAll 덕분에 -6 바이트 덕분에 우연히 저 를 능가했습니다 .

가장 짧은 하위 시퀀스를로 list사전 순으로 색인으로 나누면서 가장 작은 하위 시퀀스를 a로 반환합니다 .

Brute-force는 모든 색인 하위 시퀀스를 생성 한 다음 Filter인접하지 않은 하위 시퀀스 ( 예 : where)를 생성 all(diff(x)>1)합니다. 그런 다음 합계가 최대 값 ( ) 인 첫 번째 인덱스를 선택하여 이러한 인덱스 [를 l사용하여 하위 집합 을 만듭니다.[[which.max

나는 이것이 내가 쓴 최초의 R 답변이라고 확신합니다 Filter! 슬프다, Filter언 골프 다.

05AB1E , 14 바이트

Kevin Cruijssen 덕분에 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

Brachylog (v2), 14 바이트

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

온라인으로 사용해보십시오!

기능 제출; 평소와 같이 왼쪽에서 입력하고 오른쪽에서 출력합니다. 아주 느린; 5 개 요소 목록은 아마도 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

접두사에서 얻은 결과는 정확하지 않지만 흥미롭지는 않습니다. 가능한 모든 결과는 접미사 (목록 자체이지만 비어있을 수는 없음)를 사용하여 생성되지만 "접미사"는 "접두사 또는 접미사"보다 Brachylog에서 더 자세합니다. 따라서 더 간결한 버전을 사용했습니다. 효율적이지만 여전히 정확합니다). 기본 아이디어는 출력 목록에서 원하는 각 요소에 대해 연속 하위 목록으로 분할하면 해당 요소와 요소를 동일한 하위 목록에 배치해야합니다 (요소가 두 번째 이기 때문에)하위 목록의 요소)와 같이 두 개의 연속 요소가 결과에 표시되지 않습니다. 반면에 두 개의 연속 요소가없는 목록이 결과에 나타날 수 있음이 분명합니다. 가능한 후보 목록이 모두 있으면 모든 후보의 합계를 가져 와서 가장 큰 후보 목록을 볼 수 있습니다.

젤리 , 16 14 바이트

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

온라인으로 사용해보십시오!

2 바이트를 절약 한 @EriktheOutgolfer에게 감사합니다!

자바 스크립트 (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[]

하스켈, 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)를 삭제하십시오 .

편집 : @Lynn 덕분에 -1 바이트.

J , 47 바이트

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

온라인으로 사용해보십시오!

FrownyFrog 덕분에 -7 바이트

기발한

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

가이아 , 24 바이트

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

온라인으로 사용해보십시오!

음, E‡이상한 일을 ... 문서에 따르면, "주어진 길이 의 목록 세트 와 길이 의 인덱스 세트 , 반환 " 과 같은 것을 해야 하지만 대신 음의 색인이 보완을 나타내는 곳 을 반환 하므로 우리는해야 합니다. 우리가 원하는 것만 추출하십시오.iXjYX[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}

온라인으로 사용해보십시오!

@Giuseppe 덕분에 -1

Wolfram Language (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}})

하스켈 , 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
```

숯 , 46 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

≔⟦υ⟧η

변수 u는 빈 목록으로 사전 정의됩니다. 에 지정된 목록에 추가됩니다 h. 이 변수는 누산기 역할을합니다. u는 입력의 최신 요소 q를 h포함하는 하위 목록을 포함하고 그렇지 않은 하위 목록을 포함합니다 (따라서 입력의 다음 요소를 추가하는 데 적합 함).

Ｆθ«

입력 요소를 반복합니다.

≔υζ

이전 요소가 포함 된 서브리스트 목록을 저장하십시오.

≔Ｅη⁺κ⟦ι⟧υ

이전 요소가 포함되지 않은 모든 하위 목록을 가져 와서 현재 요소를 추가 한 후 결과를 현재 요소가 포함 된 하위 목록의 목록으로 저장하십시오. ( Push목록을 복제해야 하므로 여기 에서는 사용하지 않습니다 .)

≔⁺ζηη»

이전 하위 목록을 모두 현재 요소를 포함하지 않는 새로운 하위 목록으로 연결합니다.

≔Φ⁺υηιη

마지막으로 하위 목록을 연결하고 원래 비어있는 목록 (어쨌든 합할 수없는)을 제거하십시오.

≔ＥηΣιζ

모든 하위 목록의 합계를 계산하십시오.

Ｉ§η⌕ζ⌈ζ

가장 큰 합계의 색인을 찾아 해당 하위 목록을 출력하십시오.

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

파이썬 2 , 63 70 65 바이트

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

온라인으로 사용해보십시오!

ArBo에 5 바이트 thx