Vérifier si un numéro se termine par un autre numéro

Un défi de programmation typique consiste à déterminer si un nombre se termine par un autre nombre. Pour résoudre ce problème, vous devez identifier les derniers chiffres d'un numéro donné et vérifier s'ils correspondent à un autre numéro. De nombreuses applications, notamment le traitement des données, la manipulation de chaînes et l'analyse numérique, impliquent fréquemment de telles opérations. Des méthodes de programmation, notamment la conversion de nombres en chaînes, l'arithmétique modulo et l'utilisation d'opérateurs logiques, sont utilisées pour résoudre ce défi. Ce sujet devrait intéresser les programmeurs débutants et intermédiaires qui souhaitent améliorer la manipulation des nombres et la résolution de problèmes algorithmiques.

Méthode

Il existe de nombreuses façons de vérifier si un numéro se termine par un autre numéro. Voici deux méthodes courantes -

• Utilisez l'opérateur modulo (%)

• Utiliser la conversion de chaîne

Méthode 1 : Utiliser l'opérateur modulo (%)

Si deux nombres sont divisés, l'opérateur modulo renvoie le reste. À l'aide de l'opérateur modulo, nous pouvons déterminer si un nombre se termine par un autre nombre, en utilisant le deuxième nombre comme diviseur. Si le résultat est égal au deuxième nombre, le premier nombre se termine par le deuxième nombre.

L'opérateur mathématique couramment utilisé est appelé l'opérateur modulo, qui renvoie le reste de l'opération de division et est représenté par le symbole %. Une application utile consiste à utiliser l’opérateur modulo pour vérifier si un nombre se termine par un autre nombre.

Nous pouvons utiliser l'opérateur modulo pour obtenir la valeur restante après avoir divisé un nombre « n » par un autre nombre « m » afin de déterminer si les deux nombres sont consécutifs. Si le reste est égal à m, alors n se termine par m. Si ce n’est pas égal à m, alors ce n’est pas le cas.

Grammaire

La syntaxe de cette méthode est la suivante −

• Fonction pour vérifier si un numéro se termine par un autre numéro

bool endsWith(int number, int ending) {
   int digits = floor(log10(ending)) + 1; 

• Obtenez le nombre de chiffres du numéro final

int divisor = pow(10, digits); 

• Calculer le diviseur

int remainder = number % divisor; 

• Calculer le reste

return remainder == ending; }

• Renvoie vrai si le reste est égal au numéro final

Ici, numéro est le numéro d'origine et fin est le numéro pour vérifier s'il est à la fin de numéro. L'expression floor(log10(ending)) + 1 calcule le nombre de chiffres dans ending, tandis que pow(10, digits) calcule le diviseur. Le reste de nombre divisé par diviseur est ensuite calculé à l'aide de l'opérateur modulo %. Si le reste est égal à fin, la fonction renvoie vrai, indiquant que le numéro se termine par fin.

Algorithme

L'opérateur

modulo est utilisé dans la procédure C++ suivante pour déterminer si un entier se termine par un autre nombre −

Étape 1 - Entrez num et terminez Num, les deux nombres à comparer.

Étape 2 - Utilisez l'opérateur modulo (%) pour calculer le reste de num divisé par 10.

Étape 3 - Renvoie vrai si le nombre se termine par le chiffre de fin et que le reste est égal au chiffre de fin.

Étape 4 - Sinon, divisez le nombre par 10 et répétez les étapes 1 à 2 jusqu'à ce que le nombre soit égal à 0.

Étape 5 - Si la boucle se termine sans correspondance, le numéro ne se termine pas par end Num, donc false est renvoyé.

Exemple 1

Exemple d'utilisation de l'opérateur modulo pour vérifier si un nombre se termine par un autre nombre −

Dans cet exemple, la fonction finsAvec accepte deux paramètres entiers numéro et fin. Utilisez ensuite l'opérateur modulo % pour déterminer si le dernier chiffre du nombre est égal à la fin. Si tel est le cas, la fonction renvoie vrai, sinon elle renvoie faux.

Avant d'appeler la méthode endWith, nous définissons d'abord le nombre et la fin dans la fonction principale. Si la méthode renvoie vrai, nous imprimons un message indiquant que le nombre se termine par une fin. Sinon, imprimez un message indiquant que le numéro ne se termine pas par la fin.

Il est important de noter qu'il ne s'agit que d'un exemple très simple, il existe de nombreuses méthodes différentes (telles que les méthodes de manipulation de chaînes) pour déterminer si un nombre se termine par un autre nombre. L'opérateur modulo est une technique populaire et efficace.

#include <iostream>
using namespace std;

bool endsWith(int number, int ending) {
   return (number % 10) == ending; // Check if last digit is equal to ending
}

int main() {
   int number = 12345;
   int ending = 5;

   if (endsWith(number, ending)) {
      cout << number << " ends with " << ending << endl;
   }
   else {
      cout << number << " does not end with " << ending << endl;
   }

   return 0;
}

Sortie

12345 ends with 5

Méthode 2 : Utiliser la conversion de chaîne

À l'aide de fonctions de manipulation de chaînes, cette technique vérifie si les extrémités de deux entiers correspondent en les convertissant en chaînes. Une approche courante consiste à utiliser la fonction to_string() pour convertir un nombre en chaîne, puis à déterminer si les derniers caractères de la première chaîne correspondent aux derniers caractères de la deuxième chaîne.

Grammaire

Voici la syntaxe d'une méthode de conversion de chaîne en C++ qui vérifie si un nombre se termine par un autre nombre, sans le code réel :

• Convertir le numéro en chaîne

string num1_str = to_string(num1);
string num2_str = to_string(num2);

• Vérifiez si les derniers caractères de la chaîne sont égaux

bool ends_with = num1_str.substr(num1_str.size() - num2_str.size()) == num2_str;

Algorithme

Voici un algorithme C++ pour déterminer si un nombre se termine par un autre nombre −

Étape 1 - Commencez par créer des chaînes pour ces deux entiers.

Étape 2 - Supposons que le deuxième entier s'appelle n, déterminez sa longueur.

步骤 3 - 如果第一个数字的长度小于 n，则返回 false。

步骤 4 − 将 substr 方法应用于第一个数字，以提取最后 n 位数字。

第五步 - 使用stoi方法将第二个数字和检索到的子字符串转换为整数。比较这两个整数

步骤6 - 如果它们相等，则返回true。如果不相等，则返回false。

Example 2

使用 to_string() 函数将这两个数字转换为字符串。然后使用 substr() 函数提取第一个字符串的最后几个字符，使其与第二个字符串的长度相匹配。然后使用 == 运算符将这些提取的字符与第二个字符串进行比较。

#include <iostream>
#include <string>

using namespace std;

int main() {
   int num1 = 123456;
   int num2 = 56;

   string str1 = to_string(num1);
   string str2 = to_string(num2);

   if (str1.substr(str1.length() - str2.length()) == str2) {
      cout << "Number 1 ends with number 2" << endl;
   } else {
      cout << "Number 1 does not end with number 2" << endl;
   }

   return 0;
}

输出

Number 1 ends with number 2

结论

总之，使用substr()函数比较每个字符串的最后几个字符，或者使用模运算来分离每个数字的最后几位数并直接比较它们，这两种方法都可以判断一个数字是否以另一个数字结尾。这两种策略都很有效，并且可以使用基本的C++编程结构来实践。许多需要模式匹配的数值和计算应用都可以从这个任务中受益。

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!