Minimiser le produit des plus grands nombres dans deux tableaux en utilisant le swap

La manipulation de la structure des données est désormais un aspect important du développement réussi de solutions dans la programmation et l'informatique modernes. Cela est dû à la complexité croissante présentée par ces structures au fil du temps. Un exemple consiste à effectuer une opération d'échange pour minimiser la somme des plus grands nombres contenus dans deux tableaux, réduisant ainsi leur valeur globale. Dans cet article, nous discutons de deux manières d'accomplir ces tâches en utilisant C++, tout en reconnaissant les avantages et les inconvénients de chaque approche en fonction de différentes perspectives.

Grammaire

Afin de comprendre efficacement les méthodes et les codes du langage de programmation C++, nous devons avoir une solide compréhension de la syntaxe de base. Cela signifie examiner de plus près les éléments pertinents pour le sujet traité.

Arrays: int arrayName[size];
Sorting: sort(arrayName, arrayName + size);
Swap: swap(arrayName1[index], arrayName2[index]);
Function Declaration: int functionName(type variableName);

Algorithme

Une façon de réduire le produit des plus grands nombres dans deux tableaux consiste à utiliser un algorithme commun pour échanger leurs éléments. Pour illustrer cette approche, considérons l'exemple suivant -

• Accepte ou initialise deux tableaux.

• Triez deux tableaux.

• Trouvez le plus grand élément de chaque tableau.

• Si le plus grand élément du premier tableau est plus important que le plus grand élément du deuxième tableau, échangez.

• Répétez les étapes 3 et 4 jusqu'à ce que nous ne puissions plus minimiser le produit.

Méthode

Maintenant, discutons de deux méthodes différentes −

Méthode 1 : Utiliser les fonctions intégrées

• La première méthode consiste à utiliser les fonctions de tri et d'échange intégrées en C++.

• Initialisez ou saisissez deux tableaux.

• L'utilisation de la fonction sort() est un outil utile pour trier le contenu d'un tableau par ordre croissant.

• Trouvez le plus grand élément (dernier élément après le tri) dans deux tableaux.

• Si le plus grand élément du premier tableau est supérieur au plus grand élément du deuxième tableau, utilisez la fonction swap() pour échanger les éléments.

• Continuez ce processus jusqu'à ce que le produit ne puisse plus être minimisé.

Exemple

#include<bits/stdc++.h>
using namespace std;

void minimizeProduct(int a[], int b[], int n) {
   sort(a, a + n);
   sort(b, b + n);
    
   for (int i = n - 1; i >= 0; --i) {
      if (a[i] > b[i])
         swap(a[i], b[i]);
      else
         break;
   }
    
   cout << "Product of maximums: " << a[n - 1] * b[n - 1] << endl;
}

int main() {
   int a[] = {5, 7, 9, 3, 6};
   int b[] = {1, 2, 6, 8, 0};
   int n = sizeof(a)/sizeof(a[0]);

   minimizeProduct(a, b, n);
    
   return 0;
}

Sortie

Product of maximums: 72

La traduction chinoise de

Explication

est :

Explication

Cette méthode utilise la directive #include pour ajouter des bibliothèques avant d'exécuter la tâche. Définir l'espace de noms std au début simplifie l'appel des fonctions de bibliothèque standard et évite les longues instructions. Entrez la fonction minimiserProduct, qui inclut les deux tableaux d'entrée et leurs tailles comme paramètres.

Ensuite, il trie ces tableaux par ordre croissant à l'aide de la méthode sort() intégrée, puis démarre une boucle for comparant les plus grands éléments du premier et du deuxième tableaux.

Si le plus grand élément du premier tableau est plus grand que le deuxième tableau, échangez les éléments pour vous rapprocher de la solution. Imprimez le produit en utilisant l'élément maximum nouvellement échangé. Les fonctions intégrées telles que sort() et swap() permettent d'y parvenir sans problème. L’appel de minimiseProduct dans main() renvoie 0 pour indiquer le succès.

Méthode 2 : Ne pas utiliser les fonctions intégrées

Cette technique peut apporter des avantages dans les situations où les fonctions intégrées ne sont pas possibles. Au lieu d'utiliser des fonctions de tri et d'échange prédéfinies, nous créons nos variantes personnalisées.

• Initialisez ou saisissez deux tableaux.

• Implémentez une fonction de tri pour trier deux tableaux par ordre croissant.

• Trouvez le plus grand élément (dernier élément après le tri) dans deux tableaux.

• Si le plus grand élément du premier tableau est supérieur au plus grand élément du deuxième tableau, utilisez une fonction d'échange personnalisée pour échanger les éléments.

• Répétez jusqu'à ce que vous ne puissiez plus réduire le produit.

Exemple

#include<iostream>
using namespace std;

void sortArray(int arr[], int n) {
   for(int i = 0; i < n; ++i) {
      for(int j = i+1; j < n; ++j) {
         if(arr[i] > arr[j]) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
         }
      }
   }
}

void minimizeProduct(int a[], int b[], int n) {
   sortArray(a, n);
   sortArray(b, n);
    
   for (int i = n - 1; i >= 0; --i) {
      if (a[i] > b[i]) {
         int temp = a[i];
         a[i] = b[i];
         b[i] = temp;
      } else {
         break;
      }
   }
    
   cout << "Product of maximums: " << a[n - 1] * b[n - 1] << endl;
}

int main() {
   int a[] = {5, 7, 9, 3, 6};
   int b[] = {1, 2, 6, 8, 0};
   int n = sizeof(a)/sizeof(a[0]);

   minimizeProduct(a, b, n);
    
   return 0;
}

Sortie

Product of maximums: 72

La traduction chinoise de

Explication

est :

Explication

Dans une autre approche, nous abandonnons l'utilisation des fonctions intégrées et implémentons plutôt les opérations de tri et d'échange manuellement. Nous écrivons d'abord une nouvelle fonction appelée « sortArray » qui utilise des boucles for imbriquées pour comparer et échanger les éléments dans l'ordre souhaité lorsqu'un tableau est donné en entrée. Dans 'minimizeProduct', les deux tableaux donnés sont triés de la même manière avant de commencer l'itération, puis nous commençons à itérer à partir de l'extrémité droite et échangeons les éléments correspondants si nécessaire - uniquement à n'importe quelle étape de l'itération, dans le premier tableau. Les éléments de sont échangés uniquement s'ils sont plus grands dans le sens de la colonne que les éléments du deuxième tableau ; enfin, le produit des valeurs maximales est obtenu grâce à ce processus et imprimé sur la console de sortie en tant que résultat. Dans 'main()', cette opération 'minimiser le produit' est appliquée en passant des valeurs prédéfinies via deux tableaux préexistants.

Conclusion

La valeur entière maximale dans deux tableaux spécifiés peut être considérablement réduite en utilisant un programme C++ selon la méthode détaillée ici. Cette réduction est obtenue grâce à des techniques d'échange d'éléments qualifiées. De plus, cette approche permet une compréhension plus approfondie des multiples stratégies de manipulation des tableaux : elle met en évidence la manière dont les fonctions personnalisées se complètent lorsqu'elles sont utilisées avec des options prédéfinies. Il est important de se rappeler que déterminer quelle méthode est la plus appropriée dépend principalement des contraintes et du potentiel de calcul global de chaque problème. Sur la base de ces considérations, il est important de ne pas succomber à la frustration lorsque vous travaillez pour améliorer vos compétences en codage.

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!