Sequência maximal de um array de inteiros.

sequenciaMaximal.c

#include <math.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// = IMPLEMENTACAO DE ARRAY DINAMICO ===========================================
typedef struct {
  int *arranjo;
  size_t quantidadeDeElementos;
  size_t espacoEmMemoria;
} Arranjo;

void inicializarArranjo(Arranjo *a, size_t tamanhoInicial) {
  a->arranjo = malloc(tamanhoInicial * sizeof(int));
  a->quantidadeDeElementos = 0;
  a->espacoEmMemoria = tamanhoInicial;
}

void inserirNoArranjo(Arranjo *a, int elemento) {
  if (a->quantidadeDeElementos == a->espacoEmMemoria) {
    a->espacoEmMemoria *= 2;
    a->arranjo = realloc(a->arranjo, a->espacoEmMemoria * sizeof(int));
  }
  a->arranjo[a->quantidadeDeElementos++] = elemento;
}

int obterElemento(Arranjo *a, int posicao) {
  if (a->quantidadeDeElementos > posicao) {
    return a->arranjo[posicao];
  } else {
    return 0;
  }
}

int obterTamanhoDoArranjo(Arranjo *a) { return a->quantidadeDeElementos; }

void destruirArranjo(Arranjo *a) {
  free(a->arranjo);
  a->arranjo = NULL;
  a->quantidadeDeElementos = a->espacoEmMemoria = 0;
}
// = FIM DA IMPLEMENTACAO DE ARRAY DINAMICO ====================================

int sequenciaMaximal(Arranjo valores) {
  Arranjo sequencias;
  int tam = obterTamanhoDoArranjo(&valores);
  inicializarArranjo(&sequencias, tam);

  int soma, valor, indice, maiorSequencia;
  soma = valor = indice = maiorSequencia = 0;
  bool sequenciaQuebrada = false;

  for (indice = 0; indice < tam; indice++) {
    valor = obterElemento(&valores, indice);
    soma += valor;
    if (soma < 0) {
      soma = 0;
    }
    inserirNoArranjo(&sequencias, soma);
  }

  soma = 0;
  for (indice = 0; indice < tam; indice++) {
    soma = obterElemento(&sequencias, indice);
    maiorSequencia = soma > maiorSequencia ? soma : maiorSequencia;
  }
  destruirArranjo(&sequencias);

  return maiorSequencia;
}

int main() {
  Arranjo arr;
  inicializarArranjo(&arr, 10);
  inserirNoArranjo(&arr, 3);
  inserirNoArranjo(&arr, -4);
  inserirNoArranjo(&arr, 6);
  inserirNoArranjo(&arr, 3);
  inserirNoArranjo(&arr, -5);
  inserirNoArranjo(&arr, 6);
  inserirNoArranjo(&arr, 10);
  inserirNoArranjo(&arr, -9);
  inserirNoArranjo(&arr, -2);
  inserirNoArranjo(&arr, 8);

  printf("%d\n", sequenciaMaximal(arr));

  destruirArranjo(&arr);

  return 0;
}

sequenciaMaximal.js

/**
 * Função de complexidade O(n²) focada em encontrar a maior sequência números 
 * inteiros que geram uma soma positiva dentro de um arranjo.
 * @param  {...number} valores - Arranjo de números inteiros.
 * @returns {number} a maior sequência/soma encontrada no arranjo.
 */
function sequenciaMaximal(...valores) {
  let soma = 0;
  let sequenciaQuebrada = false;

  const sequencias = valores.reduce((acumulador, valor) => {
    soma += valor;
    sequenciaQuebrada = soma < 0;

    if (sequenciaQuebrada) {
      soma = 0;
    }

    return [...acumulador, soma];
  }, []);

  return sequencias.reduce((maiorSequencia, sequencia) => {
    return (maiorSequencia =
      sequencia > maiorSequencia ? sequencia : maiorSequencia);
  }, 0 /* VALOR INICIAL DA VARIAVEL maiorSequencia */);
}

const resultado = sequenciaMaximal(3, -4, 6, 3, -5, 6, 10, -9, -2, 8);

console.log(resultado);