Programme JavaScript pour calculer la taille du sous-tableau avec la somme maximale

Le programme JavaScript permettant de trouver la taille maximale du sous-tableau de somme est un problème courant dans le domaine de la programmation, en particulier dans le développement Web. L'énoncé du problème consiste à trouver le sous-tableau contigu avec la somme maximale dans un tableau unidimensionnel d'entiers donné. Ceci est également connu sous le nom de problème de sous-réseau maximum. La résolution de ce problème est utile dans diverses applications, telles que l’analyse financière, les prévisions boursières et le traitement du signal.

Dans cet article, nous verrons l'algorithme et la taille des sous-tableaux pour une somme maximale en utilisant JavaScript. Nous discuterons d’abord du problème en détail, puis développerons une solution étape par étape à l’aide du langage de programmation JavaScript. Alors commençons !

Énoncé du problème

Étant donné un tableau d'entiers, nous devons trouver la longueur du sous-tableau avec la somme maximale.

Par exemple, supposons que nous ayons un tableau d'entiers : [1, -2, 1, 1, -2, 1], le plus grand sous-tableau est [1, 1] et la somme est 2. Nous pouvons trouver la longueur de ce sous-tableau en soustrayant l'index de début de l'index de fin et en ajoutant 1. Dans cet exemple, l'index de début est 0 et l'index de fin est 1, donc la longueur du sous-tableau est 2.

Un autre exemple est un tableau de tous les entiers négatifs : [-2, -5, -8, -3, -1, -7]. Dans ce cas, le plus grand sous-tableau sera [-1] et la somme sera -1. Puisque tous les éléments sont négatifs, le sous-tableau ayant la plus petite valeur absolue a la plus grande somme. Par conséquent, la longueur du sous-tableau est de -1.

Il convient de noter qu'il peut y avoir plusieurs sous-tableaux maximum, chacun avec la même somme. Cependant, il suffit d’en trouver un.

Algorithme

Étape 1

Nous initialisons d'abord quatre variables : "maxSum" est "-Infinity", "currentSum" est "0", "start" est "0" et end est "0". Nous utiliserons 'maxSum' pour garder une trace de la plus grande somme que nous ayons vue jusqu'à présent, 'currentSum' pour calculer la somme du sous-tableau de notre itération actuelle, 'start' pour garder une trace de l'index de départ du sous-tableau, et 'end' pour garder une trace de l'index de fin du sous-tableau.

Étape 2

Ensuite, nous utilisons une boucle « for » pour parcourir le tableau. Pour chaque élément du tableau, nous l'ajoutons à "currentSum". Si 'currentSum' est supérieur à 'maxSum', nous mettons à jour 'maxSum' en 'currentSum' et définissons 'end' sur l'index actuel.

Étape 3

Ensuite, nous utilisons une boucle while pour vérifier si "currentSum" est inférieur à "0". Si tel est le cas, nous soustrayons la valeur à « start » de « currentSum » et ajoutons 1 à « start ». Cela garantit que nous avons toujours un sous-ensemble contigu du tableau.

Étape 4

Enfin, nous vérifions si "currentSum" est égal à "maxSum" et si la taille du sous-tableau actuel est supérieure à celle du sous-tableau précédent. Si tel est le cas, nous mettons à jour "end" avec l'index actuel.

Étape 5

La complexité temporelle de cet algorithme est O(n) et la complexité spatiale est O(1), ce qui est optimal pour ce problème.

Exemple

Le programme JavaScript suivant est conçu pour résoudre le problème de l'utilisation de deux pointeurs, début et fin, pour trouver le sous-tableau contigu avec la plus grande somme dans un tableau d'entiers. L'algorithme initialise la somme maximale à l'infini négatif, la somme actuelle à zéro et les index de début et de fin à zéro. Il ajoute chaque élément à la somme actuelle et met à jour la somme maximale et l'index de fin si la somme actuelle est supérieure à la somme maximale. Il supprime les éléments du début du sous-tableau jusqu'à ce que la somme actuelle ne soit plus négative, puis met à jour l'index de fin si la somme actuelle est égale à la somme maximale et que la longueur du sous-tableau est supérieure à la longueur du sous-tableau précédent. Enfin, il renvoie la longueur du plus grand sous-tableau en soustrayant l'index de début de l'index de fin et en ajoutant 1.

function maxSubarraySize(arr) {
   let maxSum = -Infinity;
   let currentSum = 0;
   let start = 0;
   let end = 0;
   for (let i = 0; i < arr.length; i++) {
      currentSum += arr[i];
      if (currentSum > maxSum) {
         maxSum = currentSum;
         end = i;
      }
      while (currentSum < 0) {
         currentSum -= arr[start];
         start++;
      }
      if (currentSum === maxSum && i - start > end - start) {
         end = i;
      }
   }
   return end - start + 1;
} 
// Example usage:
const arr = [1, -2, 1, 1, -2, 1];
console.log("Array:", JSON.stringify(arr));
const size = maxSubarraySize(arr);
console.log("Size of the Subarray with Maximum Sum:", size);

Voyons le résultat avec quelques exemples pour une meilleure compréhension.

Exemple 1

Input - Étant donné un tableau d'entiers, a[]= {1, -2, 1, 1, -2, 1}

Sortie− 2

Description - Un sous-tableau avec des éléments consécutifs avec une somme maximale de {1, 1}. La longueur est donc 2.

Exemple 2

Entrée - Étant donné un tableau de tous les entiers négatifs, a[]= {-2, -5, -8, -3, -1, -7}

Sortie-1

Explication - Dans ce cas, le sous-tableau maximum sera de [-1] et la somme sera de -1. Par conséquent, la longueur du sous-tableau est de -1.

Conclusion

La taille du sous-tableau avec la plus grande somme est une question courante lorsque l'on travaille avec des tableaux en programmation. L'algorithme pour résoudre ce problème consiste à parcourir le tableau et à garder une trace de la somme actuelle et de la plus grande somme vue jusqu'à présent. En implémentant cet algorithme en JavaScript, nous pouvons écrire un programme qui trouve efficacement la taille du sous-tableau qui a la plus grande somme pour un tableau d'entiers donné.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!