Belirli bir dizinin "maksimum alt dizisi" ni "en büyük toplamı olan bir (ardışık) alt dizi" olarak tanımlayın. Not "sıfır olmayan" bir gereklilik yoktur. Bu toplamı çıkar.

Mümkünse kodunuzun bir açıklamasını verin.

Örnek giriş 1:

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

Örnek çıktı 1: 24

Tanım 1:
En büyük miktar kesilerek 6 7 -8 9 10ve toplanarak elde edilir .

Örnek girişi 2: -1 -2 -3
Örnek çıkışı 2: 0
Açıklama 2: Çok basit :) Boş bir alt dizi "en büyük" dir.

Gereksinimi:

• Stdin dışında hiçbir şey okuma, çıktı stdout'a gitmeli.
• Standart boşluklar kısıtlamaları geçerlidir.

Sıralama: En kısa program bu kod golfünü kazandı .

Kabuğu , 6 4 bayt

▲ṁ∫ṫ

Çevrimiçi deneyin!

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

Python 3 , 61 bayt

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

Çevrimiçi deneyin!

Algoritma Wikipedia'dan çalındı .

Pyth , 8 bayt

eS+0sM.:

Çevrimiçi deneyin!

Nasıl?

eS + 0sM.: Q - Q tam anlamlıdır, giriş anlamına gelir. Diyelim ki [-1, -2, -3].

      .: - Tüm bitişik boş olmayan alt listeler. [[-1], [-2], [-3], [-1, -2], [-2, -3], [-1, -2, -3]] öğelerine sahibiz.
    sM - Her alt listenin toplamını alın. [-1, -2, -3, -3, -5, -6]
  +0 - Toplam listesine 0 ekleyin. [0, -1, -2, -3, -3, -5, -6]
eS - Maksimum öğe. S bize [-6, -5, -3, -3, -2, -1, 0] verirken e, son elemanı 0 döndürür.

05AB1E , 4 bayt

Ό0M

Çevrimiçi deneyin!

-1 Adnan sayesinde .

Jöle , 6 bayt

ẆS€;0Ṁ

Çevrimiçi deneyin!

C ++, 197 195 187 bayt

Zacharý sayesinde -10 bayt

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

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

Çevrimiçi deneyin!

Alınan Algoritma: Maksimum alt dizi problemi

R , 65 bayt

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

Çevrimiçi deneyin!

• xStdin'den oku .
• yDizini olarak ayarla x.
• Muhtemel bütün kâr amacı gütmeyen altküme üzerinde iki kez tekrarlayın.
• Bir alt kümenin toplamını m(başlangıçta m=0) ile karşılaştırın.
• Maksimum değeri sakla m.
• Baskı değeri m.

R , 72 bayt

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

Çevrimiçi deneyin!

• xStdin'den oku .
• Muhtemel tüm kar amacı gütmeyen alt kümeleri üzerinde tam bir arama yapın.
• Bir alt kümenin toplamını m(başlangıçta m=0) ile karşılaştırın.
• Maksimum değeri sakla m.
• Baskı değeri m.

Diğer başarısız fikirler

58 bayt

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

63 bayt

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

72 bayt

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

Haskell , 28 bayt

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

Çevrimiçi deneyin!

05AB1E , 4 bayt

Adnan sayesinde -2 bayt

ÎŒOM

Çevrimiçi deneyin!

Mathematica, 24 bayt

Max[Tr/@Subsequences@#]&

Haskell , 41 33 bayt

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

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

Çevrimiçi deneyin! Laikoni sayesinde

Japt , 11 bayt

£ãY mxÃc rw

Çevrimiçi deneyin!

açıklama

£ã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

Alternatif yöntem, 11 bayt

@ETHproductions'tan; Brute Kuvvetlerinin Husk cevabına dayanarak .

£sY å+Ãc rw

Giriş dizisinin tüm kuyruklarını alır ve kümülatif olarak her birini toplar. Sonra diziyi düzleştirir ve maks.

Çevrimiçi deneyin!

Ruby, 61 59 57 bayt

Ruby'yi öğrenmeye yeni başladım, bu yüzden buldum.

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

Bu algoritmayı ilk olarak bu bitmemiş kitabın Fince versiyonunda gördüm . Sayfa 23'te çok iyi açıklanmıştır.

Çevrimiçi deneyin!

JavaScript, 58 bayt

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

Kadane algoritmasının Golf JS uygulaması. Mümkün olduğu kadar kısa yapılmıştır. Yapıcı önerilere açık!

Bueval gönderiden öğrendiklerim: dönüş değeri - son durumu bir fordöngü olduğunda - temelde döngü içinde mevcut olan son değerdir . Güzel!

EDIT: Justin ve Hermann'ın önerileri sayesinde dört bayt kurtardı.

Gaia , 6 bayt

0+ḋΣ¦⌉

Çevrimiçi deneyin!

Python 2 , 52 51 bayt

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

Çevrimiçi deneyin!

Ortak Lisp, 73 bayt

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

Çevrimiçi deneyin!

k , 14 bayt

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

Çevrimiçi deneyin!

            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 bayt

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

Çevrimiçi deneyin!(TryAPL'de çalışacak şekilde değiştirildi)

Nasıl?

• ∊∘.{+/W[X/⍨⍺≤X←⍳⍵]}⍨⍳⍴W←⎕ Altvektör toplamı oluşturun
• ⌈/ Maksimum

CJam, 24 bayt

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

Sayı dizisini girdi olarak alan işlev.

Çevrimiçi Deneyin

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

BEN , 11 bayt

⎕𝟚35ǵ'ƒ⇹(⍐↵

Çevrimiçi deneyin! MY şimdi TIO'da! Bravo!

Nasıl?

• ⎕ = değerlendirilmiş girdi
• 𝟚 = altvektörler
• 35ǵ'= chr(0x53)(Σ, toplam)
• ƒ = bir MY işlevi olarak string
• ⇹ = harita
• ( = uygula
• ⍐ = maksimum
• ↵ = yeni satırlı çıktı.

Bunun çalışması için Sum ( 0boş dizilerde) düzeltildi . Ürün de sabitlendi.

J, 12 bayt

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

Zgrep'in K çözümüne benzer: tüm sonların tarama toplamı (bir matris üretir), gölgelendirme, maks.

Çevrimiçi deneyin!

NOT

çok fazla bayt olmadığından verimli bir çözüm elde edebilirsiniz (19 bayt golf sahası):

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

Aksiyom, 127 bayt

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)

Bu, O (# a ^ 3) Algo olacaktır; C ++ 'dan kopyaladım ... sonuç

(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

Scala, 105 bayt

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

Alt liste dizileri oluşturmanın daha iyi bir yolunu bulamadım .

Java 8, 242 bayt

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);}

Burada dene.

STDIN / STDOUT gereksinimini kullanmadan 106 bayt ..>.>

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;}

Burada dene.

Açıklama:

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