Déterminer si un nombre est un multiple de dix ou dans un ensemble particulier de plages

J'ai quelques boucles dont j'ai besoin dans mon programme. Je peux écrire le pseudo code, mais je ne suis pas tout à fait sûr de savoir 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

Ceci est pour un jeu de société serpents et échelles, si cela a plus de sens pour ma question.

J'imagine la première instruction if dont j'ai besoin pour utiliser le module. Serait- if (num == 100%10)ce correct?

Le second, je n'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.

Pour le premier, pour vérifier si un nombre est un multiple d'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 peut-être mieux de simplement énumérer les options explicitement.

   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 que cela signifie.

if (num est un multiple de 10) {do this}

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

if (num est compris entre 11-20, 31-40, 51-60, 71-80, 91-100) {do this}

L'astuce ici est de rechercher une sorte de points communs entre les gammes. Bien entendu, vous pouvez toujours utiliser la méthode "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 remarquerez peut-être que si vous soustrayez 1de num, vous aurez les plages:

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 qui exprime cela. Vous pouvez obtenir le premier chiffre en divisant par 10, et vous pouvez tester que c'est étrange en vérifiant le reste de 1 lorsque vous divisez par 2. Rassemblez tout cela:

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 "intelligent" plus court, je choisirais plus long et plus clair à chaque fois. À tout le moins, si vous essayez d'être intelligent, veuillez inclure un commentaire qui explique exactement ce que vous essayez d'accomplir.

Cela permet de supposer que le prochain développeur qui travaillera sur le code est armé et sait où vous habitez. :-)

Si vous utilisez GCC ou tout autre compilateur prenant en charge les plages de cas, vous pouvez le faire, mais votre code ne sera pas 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;
}

Ceci est pour les futurs visiteurs plus qu'un débutant. Pour une solution plus générale, semblable à un algorithme, vous pouvez prendre une liste de valeurs de début et de fin et vérifier si une valeur passée se trouve dans l'une d'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;
    });
}

Par souci de simplicité, j'ai utilisé un lambda polymorphe (C ++ 14) au lieu d'un pairargument explicite . Cela devrait aussi probablement s'en tenir à l'utilisation <et ==être cohérent avec les algorithmes standard, mais cela fonctionne comme ça tant que cela Elema été <=défini pour cela. Quoi qu'il en soit, 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 en direct ici .

Le premier est facile. Il vous suffit d'appliquer l'opérateur modulo à votre valeur num:

if ( ( num % 10 ) == 0)

Puisque C ++ évalue chaque nombre qui n'est pas 0 comme vrai, vous pouvez également écrire:

if ( ! ( num % 10 ) )  // Does not have a residue when divided by 10

Pour le second, je pense que c'est plus simple à comprendre:

Le motif se répète tous les 20, vous pouvez donc calculer le modulo 20. Tous les éléments que vous voulez seront dans une rangée sauf ceux qui sont divisibles par 20.

Pour les obtenir également, utilisez simplement num-1 ou mieux num + 19 pour éviter de traiter des nombres négatifs.

if ( ( ( num + 19 ) % 20 ) > 9 )

Cela suppose que le modèle se répète pour toujours, donc pour 111-120, il s'appliquerait à nouveau, et ainsi de suite. Sinon, vous devez limiter les nombres à 100:

if ( ( ( ( num + 19 ) % 20 ) > 9 ) && ( num <= 100 ) )

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 { ... }

Vous avez essentiellement expliqué la réponse vous-même, mais voici le code au cas où.

if((x % 10) == 0) {
  // Do this
}
if((x > 10 && x < 21) || (x > 30 && x < 41) || (x > 50 && x < 61) || (x > 70 && x < 81) || (x > 90 && x < 101)) {
  // Do this
}

Vous y réfléchissez peut-être trop.

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

La première ligne if (x % 10)fonctionne car (a) une valeur qui est un multiple de 10 se calcule comme '0', les autres nombres donnent leur reste, (b) une valeur de 0 dans an ifest considérée false, toute autre valeur esttrue .

Éditer:

Pour basculer dans la vingtaine, utilisez la même astuce. Cette fois, le numéro pivot est 10:

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

x/10renvoie n'importe quel nombre de 0 à 9 comme 0, 10 à 19 comme 1et ainsi de suite. Tester sur pair ou impair - le & 1- vous indique si c'est pair ou impair. Puisque vos plages sont en fait de "11 à 20", soustrayez 1 avant de tester.

Un plaidoyer pour la lisibilité

Bien que vous ayez déjà de bonnes réponses, je voudrais vous recommander une technique de programmation qui rendra votre code plus lisible pour certains futurs lecteurs - cela peut être vous dans six mois, un collègue a demandé d'effectuer une révision de code, votre successeur, .. .

C'est pour envelopper toutes les instructions "intelligentes" dans une fonction qui montre exactement (avec son nom) ce qu'elle fait. Bien qu'il y ait un impact minime sur les performances (de la "surcharge d'appel de fonction"), c'est vraiment négligeable dans une situation de jeu comme celle-ci.

En cours de route, vous pouvez nettoyer vos entrées - par exemple, tester les valeurs «illégales». Ainsi, vous pourriez vous retrouver avec un code comme celui-ci - voyez à quel point il est plus lisible? Les "fonctions d'assistance" peuvent être cachées quelque part (elles n'ont pas besoin d'être dans le module principal: leur nom indique clairement ce qu'elles font):

#include <stdio.h>

enum {NO, YES, WINNER};
enum {OUT_OF_RANGE=-1, ODD, EVEN};

int notInRange(int square) {
  return(square < 1 || square > 100)?YES:NO;
}

int isEndOfRow(int square) {
  if (notInRange(square)) return OUT_OF_RANGE;
  if (square == 100) return WINNER; // I am making this up...
  return (square % 10 == 0)? YES:NO;
}

int rowType(unsigned int square) {
  // return 1 if square is in odd row (going to the right)
  // and 0 if square is in even row (going to the left)
  if (notInRange(square)) return OUT_OF_RANGE; // trap this error
  int rowNum = (square - 1) / 10;
  return (rowNum % 2 == 0) ? ODD:EVEN; // return 0 (ODD) for 1-10, 21-30 etc.
                                       // and 1 (EVEN) for 11-20, 31-40, ...
}

int main(void) {
  int a = 12;
  int rt;
  rt = rowType(a); // this replaces your obscure if statement

  // and here is how you handle the possible return values:
  switch(rt) {
  case ODD:
    printf("It is an odd row\n");
    break;
  case EVEN:
    printf("It is an even row\n");
    break;
  case OUT_OF_RANGE:
    printf("It is out of range\n");
    break;
  default:
    printf("Unexpected return value from rowType!\n");
  }

  if(isEndOfRow(10)==YES) printf("10 is at the end of a row\n");
  if(isEndOfRow(100)==WINNER) printf("We have a winner!\n");
}

Pour le premier:

if (x % 10 == 0)

s'appliquera à:

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

Pour le second:

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

demandera:

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

Nous faisons d'abord x-1pour obtenir:

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

Ensuite, nous les divisons par 10pour obtenir:

1, 3, 5, ..

Nous vérifions donc si ce résultat est étrange.

Vous pouvez essayer ce qui suit:

// Multiple of 10
if ((num % 10) == 0)
{
   // Do something
}
else if (((num / 10) % 2) != 0)
{
    // 11-20, 31-40, 51-60, 71-80, 91-100
}
 else
{
    // Other case
}

Je sais que cette question a tellement de réponses, mais je vais quand même jeter la mienne ici ...

Tiré du code complet de Steve McConnell , 2nd Edition: "Stair-Step Access Tables:

Un autre type d'accès à la table est la méthode en escalier. Cette méthode d'accès n'est pas aussi directe qu'une structure d'index, mais elle ne gaspille pas autant d'espace de données. L'idée générale des structures en escalier, illustrée à la figure 18-5, est que les entrées dans un tableau sont valides pour des plages de données plutôt que pour des points de données distincts.

Figure 18-5 L'approche en escalier catégorise chaque entrée en déterminant le niveau auquel elle atteint un «escalier». Le «pas» qu'il atteint détermine sa catégorie.

Par exemple, si vous écrivez un programme de notation, la plage d'entrée «B» peut être comprise entre 75% et 90%. Voici une gamme de notes que vous pourriez avoir à programmer un jour:

Pour utiliser la méthode de l'escalier, vous placez l'extrémité supérieure de chaque plage dans une table, puis écrivez une boucle pour vérifier un score par rapport à l'extrémité supérieure de chaque plage. Lorsque vous trouvez le point auquel le score dépasse pour la première fois le haut d'une fourchette, vous savez quelle est la note. Avec la technique de l'escalier, vous devez faire attention à gérer correctement les extrémités des plages. Voici le code en Visual Basic qui attribue des notes à un groupe d'étudiants en fonction de cet exemple:

Bien qu'il s'agisse d'un exemple simple, vous pouvez facilement le généraliser pour gérer plusieurs étudiants, plusieurs systèmes de notation (par exemple, différentes notes pour différents niveaux de points sur différents devoirs) et des changements dans le système de notation. "

Code complet , 2e édition, pages 426 à 428 (chapitre 18).

Comme d'autres l'ont souligné, rendre les conditions plus concises n'accélérera pas la compilation ou l'exécution, et cela n'aide pas nécessairement non plus la lisibilité.

Cela peut aider à rendre votre programme plus flexible, au cas où vous décideriez plus tard que vous voulez une version du jeu pour tout-petit sur un plateau 6 x 6, ou une version avancée (à laquelle vous pouvez jouer toute la nuit) sur un plateau 40 x 50 .

Je le coderais donc 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 cela montre exactement ce qui se passe sur le plateau de jeu.

Si je développais ce jeu pour l'afficher sur un téléphone ou une tablette, je créerais des variables ROWS et COLUMNS au lieu de constantes, afin qu'elles puissent être définies dynamiquement (au début d'un jeu) pour correspondre à la taille et à l'orientation de l'écran.

J'autoriserais également l'orientation de l'écran à changer à tout moment, en milieu de partie - tout ce que vous avez à faire est de changer les valeurs de ROWS et COLUMNS, tout en laissant tout le reste (le numéro de carré actuel sur lequel chaque joueur est, et le carrés de début / fin de tous les serpents et échelles) inchangés. Ensuite, il vous suffit de bien dessiner le tableau et d'écrire du code pour vos animations (je suppose que c'était le but de vos ifdéclarations) ...