Déterminer si un nombre est un multiple de dix ou s'il est compris dans un ensemble particulier d'intervalles.

Question

J'ai besoin de quelques boucles dans mon programme. Je peux écrire le pseudo-code, mais je ne sais pas vraiment comment les écrire logiquement.

J'ai besoin

if (num is a multiple of 10) { do this }

if (num is within 11-20, 31-40, 51-60, 71-80, 91-100) { do this }
else { do this } //this part is for 1-10, 21-30, 41-50, 61-70, 81-90

Il s'agit d'un jeu de société "Serpents et échelles", si ma question a plus de sens.

J'imagine que le premier si Je vais devoir utiliser le module. Est-ce que if (num == 100%10) être correct ?

Le second, je n'en ai aucune idée. Je peux l'écrire comme if (num > 10 && num is < 21 || etc.) mais il doit y avoir quelque chose de plus intelligent que ça.

Answer 1

Pour le premier, pour vérifier si un nombre est un multiple de l'utilisation :

if (num % 10 == 0) // It's divisible by 10

Pour le second :

if(((num - 1) / 10) % 2 == 1 && num <= 100)

Mais c'est plutôt dense, et vous feriez mieux de simplement énumérer les options de manière explicite.

---

Maintenant que vous avez donné une meilleure idée de ce que vous faites, j'écrirais le deuxième comme :

   int getRow(int num) {
      return (num - 1) / 10;
   }

   if (getRow(num) % 2 == 0) {
   }

C'est la même logique, mais en utilisant la fonction, nous avons une idée plus claire de ce qu'elle signifie.

Answer 2

si (num est un multiple de 10) { faire ceci }

if (num % 10 == 0) {
  // Do something
}

si (num est dans 11-20, 31-40, 51-60, 71-80, 91-100) { faire ceci }

L'astuce consiste à rechercher une sorte de point commun entre les gammes. Bien sûr, vous pouvez toujours utiliser la méthode de la "force brute" :

if ((num > 10 && num <= 20) ||
    (num > 30 && num <= 40) ||
    (num > 50 && num <= 60) ||
    (num > 70 && num <= 80) ||
    (num > 90 && num <= 100)) {
  // Do something
}

Mais vous pourriez remarquer que, si vous soustrayez 1 de num vous aurez les gammes :

10-19, 30-39, 50-59, 70-79, 90-99

En d'autres termes, tous les nombres à deux chiffres dont le premier chiffre est impair. Ensuite, vous devez trouver une formule pour exprimer cela. Vous pouvez obtenir le premier chiffre en divisant par 10, et vous pouvez vérifier qu'il est impair en vérifiant que le reste est égal à 1 lorsque vous divisez par 2. En mettant tout ça ensemble :

if ((num > 0) && (num <= 100) && (((num - 1) / 10) % 2 == 1)) {
  // Do something
}

Étant donné le compromis entre un code plus long mais maintenable et un code plus court et "intelligent", je choisirais toujours un code plus long et plus clair. Au minimum, si vous essayez d'être intelligent, veuillez inclure un commentaire qui explique exactement ce que vous essayez d'accomplir.

Il est utile de supposer que le prochain développeur qui travaillera sur le code est armé et sait où vous vivez. :-)

Answer 3

Si vous utilisez GCC ou tout autre compilateur qui supporte gammes de cas vous pouvez le faire, mais votre code ne pas être portable .

switch(num)
{
case 11 ... 20:
case 31 ... 40:
case 51 ... 60:
case 71 ... 80:
case 91 ... 100:
    // Do something
    break;
default:
    // Do something else
    break;
}

Answer 4

Ceci s'adresse davantage aux futurs visiteurs qu'aux débutants. Pour une solution plus générale, de type algorithmique, vous pouvez prendre une liste de valeurs de début et de fin et vérifier si une valeur passée est comprise dans l'une d'entre elles :

template<typename It, typename Elem>
bool in_any_interval(It first, It last, const Elem &val) {
    return std::any_of(first, last, [&val](const auto &p) {
        return p.first <= val && val <= p.second;
    });
}

Pour simplifier, j'ai utilisé un lambda polymorphe (C++14) au lieu d'un explicite pair argument. Il faudrait aussi s'en tenir à l'utilisation de < et == pour être cohérent avec les algorithmes standards, mais cela fonctionne ainsi tant que Elem a <= défini pour elle. Quoi qu'il en soit, il peut être utilisé comme suit :

std::pair<int, int> intervals[]{
    {11, 20}, {31, 40}, {51, 60}, {71, 80}, {91, 100}
};

const int num = 15;
std::cout << in_any_interval(std::begin(intervals), std::end(intervals), num);

Voici un exemple concret ici .

Answer 5

Avec quelques bons commentaires dans le code, il peut être écrit de manière assez concise et lisible.

// Check if it's a multiple of 10
if (num % 10 == 0) { ... }

// Check for whether tens digit is zero or even (1-10, 21-30, ...)
if ((num / 10) % 2 == 0) { ... }
else { ... }