Vérifiez si le plus grand diviseur commun d'un tableau peut être rendu supérieur à 1 en remplaçant les paires par leur produit

Dans cet article, nous visons à explorer une question fascinante sur le plus grand diviseur commun (PGCD) des tableaux dans divers langages de programmation, en nous concentrant sur le C++. Nous démontrerons une approche algorithmique qui utilise des échanges d'éléments par paires et le nombre de leurs produits pour vérifier s'il est possible d'améliorer GCD au-dessus de 1. De plus, nous proposerons d’autres manières de résoudre ce problème, chacune avec sa définition syntaxique. En plus de ces solutions, nous présenterons également deux codes exécutables complets contenant ces méthodes.

Grammaire

Pour garantir une compréhension claire des exemples de code qui suivent, nous devons évaluer et comprendre la syntaxe utilisée avant de le faire.

#include <iostream>
#include <vector>
using namespace std;

int gcd(int a, int b) {
   if (b == 0)
      return a;
   return gcd(b, a % b);
}

bool canIncreaseGCD(vector<int>& arr) {
   // Your implementation goes here
}

Algorithme

Examinons la question de savoir si le plus grand diviseur commun d'un tableau peut être amélioré en échangeant le produit d'une paire d'éléments. Nous procéderons de la manière suivante :

• Pour simplifier le processus de recherche du plus grand diviseur commun (PGCD) de deux nombres spécifiques à l'aide de l'algorithme euclidien, il sera d'une grande aide de créer une fonction d'assistance appelée "gcd(a,b)". Cette méthode prend deux entiers d'entrée « a » et « b » et, une fois traitée via cette variable, renvoie leur valeur « GDC » résultante comme données de sortie, simplifiant ainsi considérablement ce que vous devez faire pour obtenir diverses quantités scalaires et/ou de produits. pour obtenir des informations sur la GDC.

• Cela s'appelle "canIncreaseGCD" et notre équipe a suggéré de créer une fonction booléenne qui prend un paramètre d'entrée appelé "arr" - représentant le tableau de valeurs GCD qui doivent être évaluées. Le but est de vérifier s'il existe des opérations possibles qui peuvent améliorer cette valeur en renvoyant « vrai » ou « faux ».

Méthode

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

Méthode 1

• Initialisez la variable currentGCD au plus grand diviseur commun des deux premiers éléments du tableau.

• Vérifiez chaque élément du tableau, en commençant par le troisième élément, et calculez son plus grand diviseur commun (PGCD) en utilisant la valeur GCD actuelle. Ce processus est répété pour chaque élément suivant.

• Dans le cas où le diviseur commun le plus élevé du GDC actuel par rapport à l'élément est supérieur à une valeur, un ajustement (currentGDC) est nécessaire pour que l'ajustement soit égal à la valeur/facteur commun le plus élevé introduit.

• Renvoie true à partir de la fonction canIncreaseGCD si currentGCD devient supérieur à 1 pendant l'itération.

Exemple

Exemple

#include <iostream>
#include <vector>
using namespace std;

int gcd(int a, int b) {
   if (b == 0)
      return a;
   return gcd(b, a % b);
}

bool canIncreaseGCD(vector<int>& arr) {
   int currentGCD = gcd(arr[0], arr[1]);
   for (int i = 2; i < arr.size(); i++) {
      if (gcd(arr[i], currentGCD) > 1) {
         currentGCD = gcd(arr[i], currentGCD);
         return true;
      }
   }
   return false;
}

int main() {
   vector<int> arr = {2, 3, 4, 5, 6};
   if (canIncreaseGCD(arr)) {
      cout << "The GCD of the array can be increased." << endl;
   } else {
      cout << "The GCD of the array cannot be increased." << endl;
   }
   return 0;
}

Sortie

The GCD of the array cannot be increased.

Explication

Cette méthode vise à vérifier si le plus grand diviseur commun (PGCD) d'un tableau est amélioré en remplaçant une paire d'éléments par leur produit. Tout d’abord, le code définit une fonction qui calcule GCD sur la base de l’algorithme euclidien. Par la suite, CanIncreaseGCD est introduit pour initialiser currentGCD en utilisant le GCD des deux premiers éléments du vecteur arr. Il compare en outre le GCD de chaque élément suivant avec currentGDC et met à jour currentGDC si le GCD d'un élément et currentGDC dépasse 1. Au cours de l'itération, si currentGDC dépasse 1, nous pouvons incrémenter le GCD du tableau et renvoyer true sinon, renvoyer false, indiquant que cette méthode a échoué pour cette séquence de nombres particulière ; La fonction principale démontre son utilisation à l'aide d'un exemple de tableau et imprime sa réponse après avoir évalué si canIncreaseGDC peut incrémenter sa valeur GDC correspondante.

Méthode 2

• Initialisez la variable totalGCD au plus grand diviseur commun de tous les éléments du tableau.

• Parcourez le tableau et calculez le plus grand diviseur commun de chaque élément avec totalGCD.

• Si le plus grand diviseur commun d'un élément et totalGCD est supérieur à 1, renvoie true à partir de la fonction canIncreaseGCD.

• Si aucun élément augmentant le plus grand diviseur commun n'est trouvé à la fin de l'itération, renvoie false.

Exemple

Exemple

#include <iostream>
#include <vector>
using namespace std;

int gcd(int a, int b) {
   if (b == 0)
      return a;
   return gcd(b, a % b);
}

bool canIncreaseGCD(vector<int>& arr) {
   int totalGCD = arr[0];
   for (int i = 1; i < arr.size(); i++) {
      totalGCD = gcd(arr[i], totalGCD);
      if (totalGCD > 1)
         return true;
   }
   return false;
}

int main() {
   vector<int> arr = {2, 3, 4, 5, 6};
   if (canIncreaseGCD(arr)) {
      cout << "The GCD of the array can be increased." << endl;
   } else {
      cout << "The GCD of the array cannot be increased." << endl;
   }
   return 0;
}

Sortie

The GCD of the array cannot be increased.

Explication

Un autre objectif de la méthode 2 est de vérifier si la substitution de paires d'éléments dans le tableau peut augmenter leur plus grand diviseur commun (PGCD). La structure du code est similaire à celle utilisée dans la méthode 1. Tout d’abord, il inclut une fonction gcd pour calculer le GDC entre deux nombres, puis fournit une fonction canIncreaseGDC qui accepte un vecteur de tableau en entrée. En initialisant d'abord totalGCG en utilisant uniquement son premier élément, puis en itérant sur les éléments suivants, il évalue systématiquement chaque valeur calculée correspondante par rapport à totalCGC - Vrai si la sortie actuelle s'avère supérieure à un, indiquant que le CGC global a bien été incrémenté. , sinon False, indiquant qu'il n'y a pas eu d'incrément approprié une fois la recherche terminée. Encore une fois, cette approche fonctionne efficacement dans des situations comparables aux exemples utilisés dans notre démonstration principale.

Conclusion

Dans cet article, nous explorons les problèmes liés au plus grand diviseur commun (PGCD) des tableaux en C++. Nous avons discuté d'une approche algorithmique pour déterminer si le PGCD d'un tableau peut être supérieur à 1 en remplaçant le produit de paires d'éléments. Nous fournissons la syntaxe de la méthode utilisée dans l'extrait de code et proposons deux manières différentes de résoudre le problème. Deux exemples complets de code exécutable sont également fournis pour chaque méthode. En appliquant ces méthodes, vous pouvez déterminer efficacement si le GCD d'un tableau peut être augmenté, ouvrant ainsi la voie à une résolution ultérieure du problème.

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!