Déterminer si un nombre est un multiple de dix ou au sein d'un ensemble de plages

if (num est un multiple de 10) { faire }

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

if (num est à l'intérieur 11-20, 31-40, 51-60, 71-80, 91-100) { cela }

L'astuce ici est de regarder pour une sorte de point commun entre les plages. Bien sûr, vous pouvez toujours utiliser la "force brute" de la méthode:

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 remarquerez peut-être que, si vous soustrayez 1 de num, vous aurez les plages:

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

En d'autres termes, tous les nombres de 2 chiffres dont le premier chiffre est impair. Ensuite, vous avez besoin de trouver une formule qui l'exprime. Vous pouvez obtenir le premier chiffre en divisant par 10, et vous pouvez vérifier que c'est bizarre en vérifiant un reste de 1 lorsque vous divisez par 2. Ensemble:

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

Donné le trade-off entre plus de mais code maintenable et plus court "intelligent" de code, je prendrais plus de temps et plus clair à chaque fois. À tout le moins, si vous essayez d'être intelligent, s'il vous plaît, veuillez inclure un commentaire qui explique exactement ce que vous essayez d'accomplir.

Il aide à prendre la prochaine développeur pour travailler sur le code est armé et sait où vous habitez. 🙂

C'est pour les futurs visiteurs, plus qu'un débutant. Pour un cadre plus général de l'algorithme comme solution, vous pouvez prendre une liste de début et de fin, de valeurs et de vérifier si une valeur passée est à l'intérieur de l'un d'entre eux:

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 des raisons de simplicité, j'ai utilisé un polymorphe lambda (C++14) au lieu d'une explicite pair argument. Cela devrait aussi probablement s'en tenir à l'aide de < et == pour être cohérent avec les algorithmes standards, mais il fonctionne comme ceci aussi longtemps que Elem a <= définis. De toute façon, il peut être utilisé comme ceci:

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);

Il y a un exemple vivant ici.

Avec un couple de bons commentaires dans le code, il peut être écrit 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 { ... }

Vous pourriez avoir à y penser cela.

if (x % 10)
{
   .. code for 1..9 ..
} else
{
   .. code for 0, 10, 20 etc.
}

La première ligne if (x % 10) fonctionne parce que (un) une valeur qui est un multiple de 10 calcule comme '0', d'autres numéros de résultat dans leur reste a été, (b) une valeur de 0 dans un if est considéré comme false, toute autre valeur est true.

Edit:

À bascule dos-et-vient dans la vingtaine, utiliser la même astuce. Cette fois, le pivot nombre est 10:

if (((x-1)/10) & 1)
{
  .. code for 10, 30, ..
} else
{
   .. code for 20, 40, etc.
}

x/10 renvoie n'importe quel nombre de 0 à 9 0, de 10 à 19 1 et ainsi de suite. Essai sur pair ou impair -- le & 1 -- vous dit si c'est pair ou impair. Depuis vos gammes, sont, en fait, "de 11 à 20", soustraire 1 avant le test.

Pour le premier:

if (x % 10 == 0)

s'applique:

10, 20, 30, .. 100 .. 1000 ...

Pour la seconde:

if (((x-1) / 10) % 2 == 1)

s'appliquent pour:

11-20, 31-40, 51-60, ..

Nous avons d'abord faire x-1 pour obtenir:

10-19, 30-39, 50-59, ..

Ensuite, nous divisons par 10 pour obtenir:

1, 3, 5, ..

Nous avons donc vérifier si ce résultat est impair.

Comme d'autres l'ont souligné, rendant les conditions les plus concis de ne pas accélérer la compilation ou à l'exécution, et il n'est pas nécessairement aide à la lisibilité soit.

Où il peut contribuer à votre programme plus souple, dans le cas où vous décidez plus tard que vous voulez un enfant en bas âge de la version du jeu sur un 6 x 6 conseil d'administration, ou une version avancée (que vous pouvez jouer tout au long de la nuit) sur une 40 x 50 conseil.

Donc, je voudrais le code comme suit:

//What is the size of the game board?
#define ROWS            10
#define COLUMNS         10
//The numbers of the squares go from 1 (bottom-left) to (ROWS * COLUMNS)
//(top-left if ROWS is even, or top-right if ROWS is odd)
#define firstSquare     1
#define lastSquare      (ROWS * COLUMNS)
//We haven't started until we roll the die and move onto the first square,
//so there is an imaginary 'square zero'
#define notStarted(num) (num == 0)
//and we only win when we land exactly on the last square
#define finished(num)   (num == lastSquare)
#define overShot(num)   (num > lastSquare)
//We will number our rows from 1 to ROWS, and our columns from 1 to COLUMNS
//(apologies to C fanatics who believe the world should be zero-based, which would
// have simplified these expressions)
#define getRow(num)   (((num - 1) / COLUMNS) + 1)
#define getCol(num)   (((num - 1) % COLUMNS) + 1)
//What direction are we moving in?
//On rows 1, 3, 5, etc. we go from left to right
#define isLeftToRightRow(num)    ((getRow(num) % 2) == 1)
//On rows 2, 4, 6, etc. we go from right to left
#define isRightToLeftRow(num)    ((getRow(num) % 2) == 0)
//Are we on the last square in the row?
#define isLastInRow(num)    (getCol(num) == COLUMNS)
//And finally we can get onto the code
if (notStarted(mySquare))
{
//Some code for when we haven't got our piece on the board yet
}
else
{
if (isLastInRow(mySquare))
{
//Some code for when we're on the last square in a row
}
if (isRightToLeftRow(mySquare))
{
//Some code for when we're travelling from right to left
}
else
{
//Some code for when we're travelling from left to right
}
}

Oui, c'est verbeux, mais il fait clair exactement ce qui se passe sur le plateau de jeu.

Si j'étais le développement de ce jeu pour l'affichage sur un téléphone ou une tablette, je voudrais faire des LIGNES et des COLONNES des variables au lieu de constantes, de sorte qu'ils peuvent être définis de manière dynamique (au début du jeu) pour correspondre à la taille de l'écran et de l'orientation.
Je voudrais aussi permettre l'orientation de l'écran pour être modifiés à tout moment, en milieu de partie - tout ce que vous devez faire est de basculer les valeurs de LIGNES et de COLONNES, tout en laissant tout le reste (l'actuel square numéro de chaque joueur est sur, et le début/la fin des carrés de tous les serpents et les échelles) inchangée.
Ensuite, vous avez "juste" à dessiner le conseil joliment, et l'écriture de code pour vos animations (je suppose que c'était le but de votre if consolidés) ...