En C++, réorganiser un nombre qui peut également être réorganisé par celui-ci

On nous donne un nombre de type entier, en supposant qu'il s'agit d'un nombre. La tâche consiste à réorganiser les chiffres du nombre afin que les nombres réorganisés soient également divisibles par le nombre donné.

Regardons différents scénarios d'entrée et de sortie :

Entrée - nombre int = 100035

Sortie - Le nombre qui peut être divisé par nombre après réarrangement est : 300105

Explication - Nous donnons un Nombre entier, soit 100035. Maintenant, la tâche consiste à réorganiser ces nombres donnés afin que le nombre formé soit divisible par le nombre 100035. Ainsi, après avoir réorganisé les nombres, nous obtenons 300105 qui est divisible par le nombre 100035.

Entrée - nombre int = 1000035

Sortie - Le nombre réorganisé est également divisible par celui-ci : 3000105

Explication - On nous donne un nombre entier "numéro" qui est 1000035. Maintenant, la tâche consiste à réorganiser ces nombres donnés de manière à ce que le nombre formé soit divisible par 1000035. Ainsi, après avoir réorganisé les nombres, nous obtenons 3000105 qui est divisible par le nombre 1000035.

Entrée - nombre int = 28

Sortie - Le nombre réorganisé est également divisible par celui-ci : -1

Explication - On nous donne un nombre entier "nombre" qui est 28. Maintenant, la tâche consiste à réorganiser ces nombres donnés de manière à ce que le nombre formé soit divisible par 28. Ainsi, après avoir réorganisé les nombres, nous obtenons 82 qui n’est pas divisible par le nombre 28 donc le résultat est -1.

La méthode utilisée dans le programme ci-dessous est la suivante

• Entrez une variable de type entier, en supposant qu'il s'agit d'un nombre, et transmettez les données à la fonction Réarrangement(nombre).

• Dans la fonction Réarrangement(nombre)

  • créez une variable vectorielle qui stocke une variable de type entier, en supposant qu'elle soit vec(10, 0).

  • Appelez la fonction total_count(number, vec) et transmettez number et vec comme paramètres à la fonction.

  • Commencez par une boucle de i à 2 jusqu'à ce que i soit inférieur à 10. À l’intérieur de la boucle, définissez temp sur le nombre * i.

  • Créez une variable vectorielle qui stocke une variable de type entier, en supposant qu'elle soit vec_2(10, 0).

  • Appelez la fonction total_count(number, vec_2) et transmettez number et vec_2 comme paramètres à la fonction.

  • Vérifiez si égal (vec.begin(), vec.end(), vec_2.begin()), puis renvoyez temp. Sinon, -1 est renvoyé.

• Dans la fonction total_count(int number, vector &vec_3)

  • démarre la boucle lorsque le nombre est 1. Dans la boucle, définissez vec_3 sur vec_3[number % 10]++ et number sur number/10.

Exemple

#include<bits/stdc++.h>
using namespace std;
void total_count(int number, vector<int> &vec_3){
   while(number){
      vec_3[number % 10]++;
      number = number / 10;
   }
}
int Rearrangement(int number){
   vector<int> vec(10, 0);
   total_count(number, vec);
   for(int i = 2; i < 10; i++){
      int temp = number * i;
      vector<int> vec_2(10, 0);
      total_count(temp, vec_2);
      if(equal(vec.begin(), vec.end(), vec_2.begin())){
         return temp;
      }
   }
   return -1;
}
int main(){
   int number = 100035;
   cout<<"Rearrangement of a number which is also divisible by it is: "<<Rearrangement(number);
   return 0;
}

Output

Si nous exécutons le code ci-dessus, la sortie suivante sera générée

Rearrangement of a number which is also divisible by it is: 300105

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!