하위 시퀀스의 가장 큰 합계 찾기

주어진 정수 시퀀스는 시퀀스의 서브 시퀀스 (연속 위치의 정수)의 가장 큰 합계를 찾습니다. 하위 시퀀스는 비어있을 수 있습니다 (이 경우 합계는 0 임).

입력은 한 줄에 하나씩 표준 입력에서 읽습니다. 가장 큰 합계는 표준 출력에 기록해야합니다.

나는 당신을 위해 작은 발전기를 썼습니다.

#include <stdio.h>
#include <assert.h>


/* From http://en.wikipedia.org/wiki/Random_number_generation */
unsigned m_w;
unsigned m_z;

unsigned get_random()
{
  m_z = 36969 * (m_z & 65535) + (m_z >> 16);
  m_w = 18000 * (m_w & 65535) + (m_w >> 16);
  return (m_z << 16) + m_w;  /* 32-bit result */
}

int main(int argc, char **argv)
{
  int i;

  assert(argc == 3);
  m_w = atoi(argv[1]);
  m_z = atoi(argv[2]);

  i = 10;
  while (i--);
    get_random();

  i = atoi(argv[2]);
  while (i--)
    printf("%d\n", (int) get_random() << 8 >> 22);

  return 0;
}

예 :

$ printf "1\n2\n-1\n4\n" | ./sum
6
$ printf "0\n-2\n-3\n" | ./sum
0

$ ./a.out 1 1 | ./sum
387
$ ./a.out 1 10 | ./sum
571
$ ./a.out 1 100 | ./sum
5867
$ ./a.out 1 1000 | ./sum
7531
$ ./a.out 1 10000 | ./sum
27268
$ ./a.out 1 100000 | ./sum
101332
$ ./a.out 1 1000000 | ./sum
187480
$ ./a.out 1 10000000 | ./sum
666307

• ./sum 내 해결책이야
• ./a.out 발전기입니다

귀하의 솔루션은 위의 모든 테스트에 대해 적절한 시간 내에 실행되어야합니다 (마지막 테스트 사례에서 1.2 초 내로 실행).

가장 짧은 코드가 승리합니다.

편집 : 위의 테스트 중 하나에서 실행되는 예제를 제공하십시오.

루비, 53 자

p$<.inject(-1.0/s=0){|a,b|[s=[0,s+b.to_i].max,a].max}

마지막 테스트 케이스에는 약 28 초가 걸립니다.

파이썬, 91 84 64 자

s=m=0
try:
 while 1:s=max(s+input(),0);m=max(m,s)
except:print m

마지막 테스트 케이스에서 약 14 12 72 초가 걸립니다 . 편집 : Paul R found 알고리즘 사용. 편집 :을 사용하여 가져 오기를 처리했습니다 input().

C, 100 자

main(){char s[80];int i,m=0,n=0;while(gets(s)){i=atoi(s);n=n+i>0?n+i:0;m=m>n?m:n;}printf("%d\n",m);}

ICC 11.1이있는 2.67GHz Core i7에서 최종 테스트 사례 (10000000) 의 실행 시간 = 1.14 초 (이전 : gcc 4.2.1 의 경우 1.44 초 )

참고 : 위의 솔루션에 사용 된 알고리즘 은 Jon Bentley의 Programming Pearls 에서 온 것 입니다. 이 알고리즘을 Kadane 's Algorithm이라고 합니다.

하스켈 ( 88 64)

Kadane의 알고리즘을 구현합니다.

main=interact$show.maximum.scanr(\x->max x.(x+))0.map read.lines

파이썬-114 자

import sys
s=map(int,sys.stdin.readlines())
l=range(len(s)+1)
print`max(sum(s[i:j])for i in l[:-1]for j in l[i:])`

반드시 필요한만큼 빠르지는 않지만 제대로 작동합니다.

동적 프로그래밍을 사용하는 Python-92 자

import sys
s=map(int,sys.stdin.readlines())
f=h=0
for x in s:h=max(0,h+x);f=max(f,h)
print f

J ( 34 33 자)

이 솔루션은 Kadane 알고리즘의 변형을 구현하며 합리적으로 빠릅니다.

echo>./0,([>.+)/\.0".];._2(1!:1)3

여기에 설명이 있습니다 :

• u/ y– 항목 사이에 동사가 u 삽입 되었습니다 y. 예를 들면, +/ 1 2 3 4같은입니다 1 + 2 + 3 + 4. J의 모든 동사는 오른쪽으로 연관되어 있습니다. 즉, 의 대체 합과 -/ 1 2 3 4같 1 - (2 - (3 - 4))으며이를 계산합니다 1 2 3 4.
• x >. y– x및 의 최대 값 y.
• x ([ >. +) y– x및 의 최대 값 x + y. [ >. +는 암묵적 표기법의 동사이며와 동일하게 평가됩니다 x >. x + y.
• ([ >. +)/ y– y가장 큰 합계 를 가진 비어 있지 않은 접두사 .
• u\. y–의 u모든 접미사에 적용됩니다 y. 특수 코드는 u/\. y2 차 시간 대신 선형으로 실행 되도록 일반적인 경우를 처리합니다 .
• ([ >. +)/\. y–의 각 위치에서 시작하는 비어 있지 않은 가장 큰 하위 배열을 나타내는 벡터입니다 y.
• 0 , ([ >. +)/\. y– 의 빈 하위 배열 길이와 0같이 이전 결과로 미리 표시됩니다 .0y
• >./ 0 , ([ >. +)/\. y–의 가장 큰 하위 배열 y.
• 0 ". ];._2 (1!:1) 3 – 숫자 벡터로 마샬링 된 표준 입력.
• >./ 0 , ([ >. +)/\. 0 ". ];._2 (1!:1) 3 – 표준 입력에서 가장 큰 하위 배열.

루비, 68 자

m=-2**31;n=0;$<.lines.map{|x|n+=x.to_i;n=0 if n<0;m=n if n>m};puts m

또한 조금 느리지 만 1-10000000 번의 테스트를 30 분 동안 조금만 끝냅니다. 대부분의 마지막 테스트에 소비 된 시간은 ...

들여 쓰기 버전 :

m=-2**31
n=0
$<.lines.map {|x|
  n+=x.to_i
  n=0 if n<0
  m=n if n>m
}
puts m

C ++, 192 자

#include <iostream>
#include <string>
#include <stdlib.h>
#define S std::
main(){long a=0,m=0,M=0;char s[9];while(S cin.getline(s,9)){a+=atoi(s);if(m>a)m=a;if(M<a-m)M=a-m;}S cout<<M<<S endl;}

랩톱에서 합리적으로 빠르게 작동합니다 (마지막 테스트의 경우 4 초).

{if((r+$1)>0)
   r=r+$1 
 else r=0; 
 if(m<r) 
   m=r;
}
END{print m}

awk Code (66) , 마지막 테스트 케이스에서 8 초 이상 매우 느림

dwang@dwang-ws ~/Playground/lss $ time ./random 1 10000000 | awk -f lss.awk
666307

real    0m6.705s
user    0m8.671s
sys 0m0.052s