Defina el "subarreglo máximo" de un conjunto dado como "un subconjunto (consecutivo) que tiene la mayor suma". Tenga en cuenta que no hay un requisito "distinto de cero". Salida de esa suma.

Da una descripción de tu código si es posible.

Entrada de muestra 1:

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

Salida de muestra 1: 24

Descripción 1:
la mayor suma se obtiene cortando 6 7 -8 9 10y resumiendo.

Entrada de muestra 2: -1 -2 -3
Salida de muestra 2: 0
Descripción 2: Es simple :) Un subconjunto vacío es el "más grande".

Requisito:

• No lea nada excepto stdin, y la salida debería ir a stdout.
• Se aplican restricciones de lagunas estándar .

Clasificación: El programa más corto gana este código-golf .

Casco , 6 4 bytes

▲ṁ∫ṫ

Pruébalo en línea!

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

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

Pruébalo en línea!

Algoritmo robado de Wikipedia .

Pyth , 8 bytes

eS+0sM.:

Pruébalo en línea!

¿Cómo?

eS + 0sM.: Q - Q es implícito, lo que significa entrada. Digamos que es [-1, -2, -3].

      .: - Todas las sublistas contiguas no vacías. Tenemos [[-1], [-2], [-3], [-1, -2], [-2, -3], [-1, -2, -3]].
    sM: obtenga la suma de cada sublista. [-1, -2, -3, -3, -5, -6]
  +0: ​​agrega un 0 a la lista de suma. [0, -1, -2, -3, -3, -5, -6]
eS - Elemento máximo. S nos da [-6, -5, -3, -3, -2, -1, 0], mientras que e devuelve 0, el último elemento.

05AB1E , 4 bytes

Ό0M

Pruébalo en línea!

-1 gracias a Adnan .

Jalea , 6 bytes

ẆS€;0Ṁ

Pruébalo en línea!

C ++, 197 195 187 bytes

-10 bytes gracias 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 bytes

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

Pruébalo en línea!

Algoritmo tomado de: Problema de submatriz máxima

R , 65 bytes

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

Pruébalo en línea!

• Leer xde stdin.
• Establecer ycomo índice de x.
• Iterar dos veces sobre todos los posibles subconjuntos no vacíos.
• Compare la suma de un subconjunto con m(inicialmente m=0).
• Almacenar el valor máximo en m.
• Valor de impresión de m.

R , 72 bytes

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

Pruébalo en línea!

• Leer xde stdin.
• Haga una búsqueda completa en todos los posibles subconjuntos no vacíos.
• Compare la suma de un subconjunto con m(inicialmente m=0).
• Almacenar el valor máximo en m.
• Valor de impresión de m.

Otras ideas fracasadas

58 bytes

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

63 bytes

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

72 bytes

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

Haskell , 28 bytes

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

Pruébalo en línea!

05AB1E , 4 bytes

-2 bytes gracias a Adnan

ÎŒOM

Pruébalo en línea!

Mathematica, 24 bytes

Max[Tr/@Subsequences@#]&

Haskell , 41 33 bytes

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

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

Pruébalo en línea! gracias a Laikoni

Japt , 11 bytes

£ãY mxÃc rw

Pruébalo en línea!

Explicación

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

Método alternativo, 11 bytes.

De @ETHproductions; basado en la respuesta Husk de Brute Forces .

£sY å+Ãc rw

Obtiene todas las colas de la matriz de entrada y suma cada una de forma acumulativa. Luego aplana la matriz y obtiene el máximo.

Pruébalo en línea!

Ruby, 61 59 57 bytes

Acabo de empezar a aprender Ruby, así que esto es lo que se me ocurrió.

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

Vi este algoritmo por primera vez en la versión finlandesa de este libro inacabado . Está muy bien explicado en la página 23.

Pruébalo en línea!

JavaScript, 58 bytes

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

Implementación JS Golfed del algoritmo de Kadane. Hecho lo más corto posible. Abierto a sugerencias constructivas!

Lo que aprendí de esta publicación: el valor de retorno de eval- cuando su último estado es un forbucle - es básicamente el último valor presente dentro del bucle. ¡Guay!

EDITAR: ahorró cuatro bytes gracias a las sugerencias de Justin y Hermann.

Gaia , 6 bytes

0+ḋΣ¦⌉

Pruébalo en línea!

Python 2 , 52 51 bytes

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

Pruébalo en línea!

Lisp común, 73 bytes

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

Pruébalo en línea!

k , 14 bytes

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

Pruébalo en línea!

            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 bytes

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

Pruébalo en línea! (modificado para que se ejecute en TryAPL)

¿Cómo?

• ∊∘.{+/W[X/⍨⍺≤X←⍳⍵]}⍨⍳⍴W←⎕ Generar sumas de subvectores.
• ⌈/ Máximo

CJam, 24 bytes

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

Función que toma una matriz de números como entrada.

Pruébalo en línea

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

MI , 11 bytes

⎕𝟚35ǵ'ƒ⇹(⍐↵

Pruébalo en línea! ¡MY está en TIO ahora! Woohoo!

¿Cómo?

• ⎕ = entrada evaluada
• 𝟚 = subvectores
• 35ǵ'= chr(0x53)(Σ, suma)
• ƒ = cadena como una función MY
• ⇹ = mapa
• ( = aplicar
• ⍐ = máximo
• ↵ = salida con una nueva línea.

La suma fue corregida ( 0en matrices vacías) para que esto funcione. El producto también fue reparado.

J, 12 bytes

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

Similar a la solución K de zgrep: la suma de exploración de todos los sufijos (produce una matriz), raze, take max

Pruébalo en línea!

NOTA

para no muchos bytes más, puede obtener una solución eficiente (19 bytes de golf):

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

Axioma, 127 bytes

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)

Esto sería O (# a ^ 3) Algo; Lo copio de C ++ one ... resultados

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

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

No he encontrado ninguna mejor manera de generar los sub listas de matrices.

Java 8, 242 bytes

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

Pruébalo aquí

106 bytes sin usar el 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;}

Pruébalo aquí

Explicación:

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