주어진 배열의 "최대 하위 배열"을 "가장 큰 합계를 갖는 (연속적인) 하위 배열"로 정의하십시오. "0이 아닌"요구 사항은 없습니다. 그 합계를 출력합니다.

가능하면 코드에 대한 설명을 제공하십시오.

샘플 입력 1 :

1 2 3 -4 -5 6 7 -8 9 10 -11 -12 -13 14

샘플 출력 1 : 24

설명 1 :
잘라 6 7 -8 9 10내고 합산하면 가장 큰 합계가 산출됩니다 .

샘플 입력 2 : -1 -2 -3
샘플 출력 2 : 0
설명 2 : 간단합니다. 빈 하위 배열이 "가장 큰"것입니다.

요구 사항 :

• stdin 이외의 것을 읽지 않으면 출력이 stdout으로 이동해야합니다.
• 표준 허점 제한이 적용됩니다.

순위 : 가장 짧은 프로그램이이 code-golf를 이깁니다 .

껍질 , 6 4 바이트

▲ṁ∫ṫ

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

      -- implicit input (list) xs  - eg. [-1,2,3]
   ṫ  -- get all tails of xs       -     [[-1,2,3],[2,3],[3],[]]
 ṁ∫   -- map & concat cumsum       -     [0,-1,1,4,0,2,5,0,3,0]
▲     -- get maximum               -     5

파이썬 3 , 61 바이트

a=b=0
for x in eval(input()):a=max(x,a+x);b=max(a,b)
print(b)

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

Wikipedia 에서 도난당한 알고리즘 .

Pyth , 8 바이트

eS+0sM.:

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

방법?

eS + 0sM. : Q-Q는 암시 적이며 입력을 의미합니다. 그것이 [-1, -2, -3]이라고 가정 해 봅시다.

      . :-비어 있지 않은 모든 비 하위 서브리스트. [[-1], [-2], [-3], [-1, -2], [-2, -3], [-1, -2, -3]이 있습니다.
    sM-각 하위 목록의 합계를 가져옵니다. [-1, -2, -3, -3, -5, -6]
  +0-합계 목록에 0을 추가합니다. [0, -1, -2, -3, -3, -5, -6]
eS-최대 요소. S는 [-6, -5, -3, -3, -2, -1, 0]을, e는 마지막 요소 인 0을 반환합니다.

05AB1E , 4 바이트

Ό0M

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

Adnan 에게 -1 감사합니다 .

젤리 , 6 바이트

ẆS€;0Ṁ

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

C ++, 197 195 187 바이트

Zacharý 덕분에 -10 바이트

#include<vector>
#include<numeric>
int f(std::vector<int>v){int i=0,j,t,r=0;for(;i<v.size();++i)for(j=i;j<v.size();++j){t=std::accumulate(v.begin()+i,v.begin()+j,0);if(t>r)r=t;}return r;}

R , 54 바이트

a=b=0;for(x in scan()){a=max(x,a+x);b=max(a,b)};cat(b)

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

알고리즘 : 최대 부분 배열 문제

R , 65 바이트

y=seq(x<-scan());m=0;for(i in y)for(j in y)m=max(m,sum(x[i:j]));m

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

• xstdin에서 읽습니다 .
• 의 y색인으로 설정하십시오 x.
• 비어 있지 않은 모든 가능한 하위 집합을 두 번 반복합니다.
• m(초기 m=0) 와 부분 집합의 합계를 비교합니다 .
• 최대 값을에 저장하십시오 m.
• 의 값을 인쇄합니다 m.

R , 72 바이트

n=length(x<-scan());m=0;for(i in 1:n)for(j in i:n)m=max(m,sum(x[i:j]));m

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

• xstdin에서 읽습니다 .
• 비어 있지 않은 모든 가능한 하위 집합에 대해 전체 검색을 수행하십시오.
• m(초기 m=0) 와 부분 집합의 합계를 비교합니다 .
• 최대 값을에 저장하십시오 m.
• 의 값을 인쇄합니다 m.

다른 실패한 아이디어

58 바이트

Reduce(max,lapply(lapply(seq(x<-scan()),tail,x=x),cumsum))

63 바이트

Reduce(max,lapply(seq(x<-scan()),function(i)cumsum(tail(x,i))))

72 바이트

m=matrix(x<-scan(),n<-length(x),n);max(apply(m*lower.tri(m,T),2,cumsum))

하스켈 , 28 바이트

maximum.scanl((max<*>).(+))0

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

05AB1E , 4 바이트

Adnan 덕분에 -2 바이트

ÎŒOM

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

Mathematica, 24 바이트

Max[Tr/@Subsequences@#]&

하스켈 , 41 33 바이트

import Data.List
g=maximum.concatMap(map sum.inits).tails

maximum.(scanl(+)0=<<).scanr(:)[]

온라인으로 사용해보십시오! 라이 코니 덕분에

Japt , 11 바이트

£ãY mxÃc rw

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

설명

£ãY mxÃc rw
m@ãY mx} c rw   // Ungolfed
m@     }        // Map the input array by the following function, with Y=index
  ãY            //   Get all subsections in input array length Y
     mx         //   Sum each subsection
         c rw   // Flatten and get max

대체 방법, 11 바이트

@ETHproductions에서; Brute Forces의 Husk answer 에 기반합니다 .

£sY å+Ãc rw

입력 배열의 모든 꼬리를 가져오고 각각을 합산합니다. 그런 다음 배열을 평평하게하고 최대 값을 얻습니다.

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

루비, 61 59 57 바이트

방금 Ruby를 배우기 시작했습니다. 이것이 제가 생각해 낸 것입니다.

s=0
p [gets.split.map{|i|s=[j=i.to_i,s+j].max}.max,0].max

나는 이 미완성 된 책 의 핀란드어 버전에서이 알고리즘을 처음 보았다 . 23 페이지에 잘 설명되어 있습니다.

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

자바 스크립트, 58 바이트

m=Math.max;x=y=>eval("a=b=0;for(k of y)b=m(a=m(a+k,k),b)")

Kadane 알고리즘의 골프 JS 구현. 가능한 짧게 만들었습니다. 건설적인 제안에 개방!

이 게시물에서 배운 것 : 반환 값 eval-마지막 통계가 for루프 일 때-기본적으로 루프 안에 있는 마지막 값 입니다. 시원한!

편집 : Justin과 Hermann의 제안 덕분에 4 바이트를 절약했습니다.

가이아 , 6 바이트

0+ḋΣ¦⌉

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

파이썬 2 , 52 51 바이트

f=lambda l:len(l)and max(sum(l),f(l[1:]),f(l[:-1]))

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

공통 리스프, 73 바이트

(lambda(a &aux(h 0)(s 0))(dolist(x a s)(setf h(max x(+ h x))s(max s h))))

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

k , 14 바이트

|/,/+\'(1_)\0,

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

            0, /prepend a zero (in case we're given all negatives)
       (1_)\   /repeatedly remove the first element, saving each result
    +\'        /cumulative sum over each result, saving each result
  ,/           /flatten (fold concat)
|/             /maximum (fold max)

APL, 31 29 27 바이트

⌈/∊∘.{+/W[X/⍨⍺≤X←⍳⍵]}⍨⍳⍴W←⎕

온라인으로 사용해보십시오!(TryAPL에서 실행되도록 수정되었습니다)

방법?

• ∊∘.{+/W[X/⍨⍺≤X←⍳⍵]}⍨⍳⍴W←⎕ 서브 벡터의 합 생성
• ⌈/ 최고

CJam, 24 바이트

q~:A,{)Aew{:+}%}%e_0+:e>

숫자 배열을 입력으로받는 함수입니다.

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

q~:A   e# Store array in 'A' variable
,{)Aew e# Get every possible sub-array of the array
{:+}%  e# Sum every sub array
}e_    e# flatten array of sums
0+     e# Add zero to the array
:e>    e# Return max value in array

MY , 11 바이트

⎕𝟚35ǵ'ƒ⇹(⍐↵

온라인으로 사용해보십시오! 내 지금 TIO에 있습니다! 우후!

방법?

• ⎕ = 평가 입력
• 𝟚 = 서브 벡터
• 35ǵ'= chr(0x53)(Σ, 합계)
• ƒ = MY 함수로서의 문자열
• ⇹ =지도
• ( = 적용
• ⍐ = 최대
• ↵ = 줄 바꿈으로 출력합니다.

0이것이 작동하기 위해 합계가 ( 빈 배열에서) 고정되었습니다 . 제품도 수정되었습니다.

J, 12 바이트

[:>./@,+/\\.

zgrep의 K 솔루션과 유사 : 모든 접미사의 스캔 합계 (매트릭스 생성), raze, max

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

노트

너무 많은 바이트를 사용하지 않으면 효율적인 솔루션을 얻을 수 있습니다 (19 바이트 골프).

[: >./ [: ({: - <./)\ +/\

공리, 127 바이트

f(a:List INT):Complex INT==(n:=#a;n=0=>%i;r:=a.1;for i in 1..n repeat for j in i..n repeat(b:=reduce(+,a(i..j));b>r=>(r:=b));r)

이것은 O (# a ^ 3) Algo입니다. C ++에서 복사합니다 ... 결과

(3) -> f([1,2,3,-4,-5,6,7,-8,9,10,-11,-12,-13,14])
   (3)  24
                                                    Type: Complex Integer
(4) -> f([])
   (4)  %i
                                                    Type: Complex Integer
(5) -> f([-1,-2,3])
   (5)  3
                                                    Type: Complex Integer

스칼라, 105 바이트

val l=readLine.split(" ").map(_.toInt);print({for{b<-l.indices;a<-0 to b+2}yield l.slice(a,b+1).sum}.max)

하위 목록 배열 을 생성하는 더 좋은 방법을 찾지 못했습니다 .

자바 8, 242 바이트

import java.util.*;v->{List a=new Stack();for(String x:new Scanner(System.in).nextLine().split(" "))a.add(new Long(x));int r=0,l=a.size(),i=l,j,k,s;for(;i-->0;)for(j=l;--j>1;r=s>r?s:r)for(s=0,k=i;k<j;)s+=(long)a.get(k++);System.out.print(r);}

여기에서 시도하십시오.

STDIN / STDOUT 요구 사항을 사용하지 않고 106 바이트 ..>.>

a->{int r=0,l=a.length,i=l,j,k,s;for(;i-->0;)for(j=l;--j>1;r=s>r?s:r)for(s=0,k=i;k<j;s+=a[k++]);return r;}

여기에서 시도하십시오.

설명:

import java.util.*;      // Required import for List, Stack and Scanner

v->{                     // Method with empty unused parameter and no return-type
  List a=new Stack();    //  Create a List
  for(String x:new Scanner(System.in).nextLine().split(" "))
                         //  Loop (1) over the STDIN split by spaces as Strings
    a.add(new Long(x));  //   Add the String converted to a number to the List
                         //  End of loop (1) (implicit / single-line body)
  int r=0,               //  Result-integer
      l=a.size(),        //  Size of the List
      i=l,j,k,           //  Index-integers
      s;                 //  Temp sum-integer
  for(;i-->0;)           //  Loop (2) from `l` down to 0 (inclusive)
    for(j=l;--j>1;       //   Inner loop (3) from `l-1` down to 1 (inclusive)
        r=               //     After every iteration: change `r` to:
          s>r?           //      If the temp-sum is larger than the current `r`:
           s             //       Set `r` to the temp-sum
          :              //      Else:
           r)            //       Leave `r` the same
      for(s=0,           //    Reset the temp-sum to 0
          k=i;k<j;)      //    Inner loop (4) from `i` to `j` (exclusive)
        s+=(long)a.get(k++);
                         //     Add the number at index `k` in the List to this temp-sum
                         //    End of inner loop (4) (implicit / single-line body)
                         //   End of inner loop (3) (implicit / single-line body)
                         //  End of loop (2) (implicit / single-line body)
  System.out.print(r);   //  Print the result to STDOUT
}                        // End of method