Definisci il "massimo array secondario" di un determinato array come "un array secondario (consecutivo) con la somma maggiore". Nota che non esiste un requisito "diverso da zero". Emetti quella somma.

Fornisci una descrizione del tuo codice, se possibile.

Esempio di input 1:

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

Uscita campione 1: 24

Descrizione 1:
la somma maggiore viene prodotta tagliando 6 7 -8 9 10e riassumendo.

Esempio di input 2: -1 -2 -3
Esempio di output 2: 0
Descrizione 2: È semplice :) Un sottoarray vuoto è il "più grande".

Requisiti:

• Non leggere nulla tranne stdin e l'output dovrebbe andare su stdout.
• Si applicano le restrizioni standard sulle lacune .

Classifica: il programma più corto vince questo codice-golf .

Buccia , 6 4 byte

▲ṁ∫ṫ

Provalo online!

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

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

Provalo online!

Algoritmo rubato da Wikipedia .

Pyth , 8 byte

eS+0sM.:

Provalo online!

Come?

eS + 0sM.: Q - Q è implicito, ovvero input. Diciamo che è [-1, -2, -3].

      .: - Tutte le liste secondarie non vuote contigue. Abbiamo [[-1], [-2], [-3], [-1, -2], [-2, -3], [-1, -2, -3]].
    sM: ottieni la somma di ciascun elenco secondario. [-1, -2, -3, -3, -5, -6]
  +0 - Aggiunge uno 0 all'elenco di somma. [0, -1, -2, -3, -3, -5, -6]
eS - Elemento massimo. S ci dà [-6, -5, -3, -3, -2, -1, 0], mentre e restituisce 0, l'ultimo elemento.

05AB1E , 4 byte

Ό0M

Provalo online!

-1 grazie ad Adnan .

Gelatina , 6 byte

ẆS€;0Ṁ

Provalo online!

C ++, 197 195 187 byte

-10 byte grazie a Zacharý

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

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

Provalo online!

Algoritmo tratto da: massimo problema al subarray

R , 65 byte

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

Provalo online!

• Leggi xda stdin.
• Imposta ycome indice di x.
• Scorrere due volte su tutti i possibili sottoinsiemi non vuoti.
• Confronta la somma di un sottoinsieme con m(inizialmente m=0).
• Memorizza il valore massimo in m.
• Valore di stampa di m.

R , 72 byte

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

Provalo online!

• Leggi xda stdin.
• Effettua una ricerca completa su tutti i possibili sottoinsiemi non vuoti.
• Confronta la somma di un sottoinsieme con m(inizialmente m=0).
• Memorizza il valore massimo in m.
• Valore di stampa di m.

Altre idee senza successo

58 byte

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

63 byte

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

72 byte

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

Haskell , 28 byte

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

Provalo online!

05AB1E , 4 byte

-2 byte grazie ad Adnan

ÎŒOM

Provalo online!

Mathematica, 24 byte

Max[Tr/@Subsequences@#]&

Haskell , 41 33 byte

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

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

Provalo online! grazie a Laikoni

Japt , 11 byte

£ãY mxÃc rw

Provalo online!

Spiegazione

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

Metodo alternativo, 11 byte

Da @ETHproductions; basato sulla risposta Husk di Brute Forces .

£sY å+Ãc rw

Ottiene tutte le code dell'array di input e somma sommariamente ciascuna. Quindi appiattisce l'array e ottiene il massimo.

Provalo online!

Rubino, 61 59 57 byte

Ho appena iniziato a studiare Ruby, quindi è quello che mi è venuta in mente.

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

Ho visto per la prima volta questo algoritmo nella versione finlandese di questo libro incompiuto . È molto ben spiegato a pagina 23.

Provalo online!

JavaScript, 58 byte

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

Implementazione JS golfizzata dell'algoritmo di Kadane. Fatto il più corto possibile. Aperto a suggerimenti costruttivi!

Quello che ho imparato da questo post: restituisce il valore di eval- quando il suo ultimo enunciato è un forloop - è sostanzialmente l'ultimo valore presente all'interno del loop. Freddo!

EDIT: salvato quattro byte grazie ai suggerimenti di Justin e Hermann.

Gaia , 6 byte

0+ḋΣ¦⌉

Provalo online!

Python 2 , 52 51 byte

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

Provalo online!

Lisp comune, 73 byte

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

Provalo online!

k , 14 byte

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

Provalo online!

            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 byte

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

Provalo online! (modificato in modo che venga eseguito su TryAPL)

Come?

• ∊∘.{+/W[X/⍨⍺≤X←⍳⍵]}⍨⍳⍴W←⎕ Genera somme di subvettori
• ⌈/ Massimo

CJam, 24 byte

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

Funzione che accetta array di numeri come input.

Provalo online

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 byte

⎕𝟚35ǵ'ƒ⇹(⍐↵

Provalo online! MY è su TIO ora! Woohoo!

Come?

• ⎕ = input valutato
• 𝟚 = subvettori
• 35ǵ'= chr(0x53)(Σ, somma)
• ƒ = stringa come funzione MY
• ⇹ = mappa
• ( = applica
• ⍐ = massimo
• ↵ = output con una nuova riga.

La somma è stata riparata ( 0su array vuoti) affinché questo funzionasse. Anche il prodotto è stato riparato.

J, 12 byte

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

Simile alla soluzione K di zgrep: la somma di scansione di tutti i suffissi (produce una matrice), raze, take max

Provalo online!

NOTA

per non troppi byte in più, è possibile ottenere una soluzione efficiente (golf 19 byte):

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

Assioma, 127 byte

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)

Questo sarebbe O (# a ^ 3) Algo; Lo copio dal C ++ uno ... risultati

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

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

Non ho trovato alcun modo migliore per generare le matrici degli elenchi secondari .

Java 8, 242 byte

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

Provalo qui.

106 byte senza utilizzare il requisito STDIN / STDOUT.>.>

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

Provalo qui.

Spiegazione:

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