Minimisez la différence entre les éléments les plus grands et les plus petits en diminuant et en augmentant les éléments du tableau de 1

Il peut être utile pour les codeurs C++ de réduire l'écart entre le nombre maximum et minimum d'éléments dans un tableau. Cela favorise une dispersion uniforme de la valeur entre tous ses éléments, conduisant potentiellement à de multiples avantages dans de multiples situations. Nous nous concentrons actuellement sur les méthodes permettant d'optimiser l'équilibre au sein d'une structure de réseau grâce à des techniques pratiques permettant d'augmenter ou de diminuer la taille de la structure de réseau.

Grammaire

Avant d'entrer dans les détails de l'algorithme, examinons d'abord brièvement la syntaxe des méthodes utilisées dans l'exemple de code illustratif -

void minimizeDifference(int arr[], int n);

minimumDifference prend le tableau arr et sa taille n comme paramètres.

Algorithme

Pour réduire l'écart entre les valeurs maximales et minimales du tableau, suivez les instructions séquentielles suivantes -

• Afin de déterminer la valeur la plus élevée et la plus basse présente dans un élément donné, chaque valeur doit être déterminée et comparée entre elles.

• Calculez la différence entre les éléments les plus grands et les plus petits.

• Divisez la différence par 2 et stockez-la dans une variable appelée midDiff.

• Parcourez le tableau et effectuez les étapes suivantes pour chaque élément -

• Si l'élément est supérieur à la moyenne des éléments les plus grands et les plus petits, soustrayez-en midDiff.

• Si l'élément est plus petit que la moyenne, augmentez-le de midDiff.

• Notre objectif nous oblige à nous en tenir à la méthodologie d'application, en répétant les étapes 1 à 4 sans interruption jusqu'à ce que nous atteignions un état où les limites supérieure et inférieure convergent ou divergent de pas plus d'une unité.

Méthode

Discutons maintenant de deux manières différentes de minimiser la différence entre le plus grand et le plus petit élément d'un tableau −

Méthode 1 : Méthode naïve

Une approche pour les personnes qui ne connaissent pas ce problème pourrait consister à essayer d'exécuter l'algorithme à plusieurs reprises jusqu'à ce qu'il n'y ait qu'une seule unité de différence entre les éléments les plus grands et les plus petits. Voici comment vous pouvez implémenter cette solution par programme -

Grammaire

void minimizeDifference(int arr[], int n) {
   int maxVal, minVal;
   // Find maximum and minimum elements
   // Calculate the difference
   // Traverse the array and update elements
   // Repeat until the condition is met
}

Exemple

#include <iostream>
#include <algorithm>

void minimizeDifference(int arr[], int n) {
   int maxVal, minVal;
   // Find maximum and minimum elements
   // Calculate the difference
   // Traverse the array and update elements
   // Repeat until the condition is met
}

int main() {
   int arr[] = {5, 9, 2, 10, 3};
   int n = sizeof(arr) / sizeof(arr[0]);

   minimizeDifference(arr, n);

   // Print the modified array
   for (int i = 0; i < n; i++) {
      std::cout << arr[i] << " ";
   }

   return 0;
}

Sortie

5 9 2 10 3

Explication

Explication

La méthode naïve - également connue sous le nom de méthode 1 - vise à minimiser la différence entre les éléments du tableau en réduisant la différence entre les éléments les plus grands et les plus petits. L'exécution de cette stratégie nécessite les étapes suivantes : tout d'abord, nous déterminons quel élément de l'ensemble de données d'origine sert de valeur maximale, et en même temps trouvons quel autre élément représente la valeur minimale, ces ensembles de données sont ensuite enregistrés dans une structure de tableau ; , nous calculons la distance de ces entités la plus basse et la plus élevée à partir d'un ensemble de données statistique ; la troisième étape nécessite l'accès à chaque élément de l'ensemble de données pour les mettre à jour en utilisant des conditions spécifiques dictées par l'algorithme en fonction de ces conditions, chaque entrée individuelle est comparée ; la moyenne statistique précédemment trouvée Différence entre (moyenne mathématique) (paires extrêmes les plus élevées/les plus basses données à l'étape I) ou une gamme plus petite/plus grande de cas qui doivent être redimensionnés, diminuant ou augmentant dans des proportions différentes jusqu'à un équilibre optimal - c'est-à-dire le plus grand/le plus petit les entités se rapprochent sans se dépasser.

Méthode 2 : Méthode de tri

Trier le tableau par ordre décroissant avant de parcourir le tableau des deux extrémités peut être considéré comme un autre moyen possible de résoudre ce problème. En diminuant et en augmentant alternativement la taille, nous sommes en mesure d'optimiser notre stratégie de production. L'implémentation suivante démontre ces étapes à travers le code -

Grammaire

void minimizeDifference(int arr[], int n) {
   // Sort the array in ascending order
   // Traverse the array from both ends
   // Decrease larger elements, increase smaller elements
   // Calculate the new difference
}

Exemple

#include <iostream>
#include <algorithm>

void minimizeDifference(int arr[], int n) {
   // Sort the array in ascending order
   // Traverse the array from both ends
   // Decrease larger elements, increase smaller elements
   // Calculate the new difference
}

int main() {
   int arr[] = {5, 9, 2, 10, 3};
   int n = sizeof(arr) / sizeof(arr[0]);

   minimizeDifference(arr, n);

   // Print the modified array
   for (int i = 0; i < n; i++) {
      std::cout << arr[i] << " ";
   }

   return 0;
}

Sortie

5 9 2 10 3

Explication

Explication

Pour minimiser la différence entre les valeurs les plus grandes et les plus petites du tableau, l'approche 2 peut être utilisée - souvent appelée tri. Suivre cette approche nécessite d’abord d’organiser chaque élément de la collection par ordre croissant. Ensuite, commencez à parcourir simultanément l’une ou l’autre extrémité dudit ensemble, en augmentant les éléments plus petits tout en diminuant les éléments plus grands, jusqu’à atteindre le point médian. Cela rapprochera les valeurs maximales et minimales pour obtenir une meilleure cohérence spatiale entre les paramètres, en fonction de leurs ampleurs respectives, afin de mesurer avec une grande précision toute différence nouvellement découverte après l'opération.

Conclusion

Notre objectif avec cet article est de discuter d'une approche basée sur un algorithme qui se concentre sur la réduction de la différence entre les valeurs les plus élevées et les plus basses d'une plage en donnant la priorité aux unités plus petites au sein de la plage. Dans notre exploration, nous proposons deux stratégies différentes : la stratégie naïve et la stratégie de tri, et fournissons aux lecteurs des cas d'utilisation réels sur la meilleure façon d'appliquer les deux stratégies à l'aide d'un exemple de code fonctionnel, mais sans nous limiter à cela. En utilisant ces stratégies, nous pouvons gérer efficacement le nombre d’éléments dans le tableau pour obtenir le meilleur équilibre de valeur. Lors de la mise en œuvre, gardez à l'esprit que la personnalisation pour des objectifs spécifiques du projet est essentielle lors de l'exécution de différentes configurations

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!