Determinare se un numero è un multiplo di dieci o all'interno di un particolare insieme di intervalli

Ho alcuni loop di cui ho bisogno nel mio programma. Posso scrivere lo pseudo codice ma non sono del tutto sicuro di come scriverlo logicamente.

Ho bisogno -

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

Questo è per un gioco da tavolo con serpenti e scale, se ha più senso per la mia domanda.

Immagino che la prima istruzione if di cui avrò bisogno per usare il modulo, sarebbe if (num == 100%10)corretta?

Il secondo non ne ho idea. Posso scriverlo in questo modo, if (num > 10 && num is < 21 || etc)ma deve esserci qualcosa di più intelligente di quello.

Per il primo, per verificare se un numero è un multiplo d'uso:

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

Per il secondo:

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

Ma è piuttosto denso, e potresti essere meglio elencare le opzioni in modo esplicito.

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

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

È la stessa logica, ma utilizzando la funzione abbiamo un'idea più chiara di cosa significa.

if (num è un multiplo di 10) {do this}

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

if (num è compreso tra 11-20, 31-40, 51-60, 71-80, 91-100) {do this}

Il trucco qui è cercare una sorta di comunanza tra le gamme. Ovviamente puoi sempre usare il metodo "forza bruta":

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

Ma potresti notare che, se sottrai 1da num, avrai gli intervalli:

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

In altre parole, tutti i numeri a due cifre la cui prima cifra è dispari. Successivamente, è necessario elaborare una formula che lo esprima. Puoi ottenere la prima cifra dividendo per 10, e puoi verificare che sia dispari controllando un resto di 1 quando dividi per 2. Mettendo tutto insieme:

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

Dato il compromesso tra codice più lungo ma mantenibile e codice "intelligente" più breve, sceglierei ogni volta più lungo e più chiaro. Per lo meno, se cerchi di essere intelligente, per favore, includi un commento che spieghi esattamente cosa stai cercando di realizzare.

È utile presumere che il prossimo sviluppatore che lavorerà sul codice sia armato e sappia dove vivi. :-)

Se stai usando GCC o qualsiasi compilatore che supporta intervalli di casi, puoi farlo, ma il tuo codice lo farà non sarà portabile .

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

Questo è per i futuri visitatori più che per un principiante. Per una soluzione più generale, simile ad un algoritmo, puoi prendere un elenco di valori iniziali e finali e controllare se un valore passato è all'interno di uno di essi:

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

Per semplicità, ho usato un lambda polimorfico (C ++ 14) invece di un pairargomento esplicito . Anche questo dovrebbe probabilmente attenersi all'uso <e ==per essere coerente con gli algoritmi standard, ma funziona in questo modo finché Elemè <=definito per esso. Ad ogni modo, può essere utilizzato in questo modo:

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

C'è un esempio dal vivo qui .

Il primo è facile. Devi solo applicare l'operatore modulo al tuo valore num:

if ( ( num % 10 ) == 0)

Poiché C ++ valuta ogni numero diverso da 0 come vero, potresti anche scrivere:

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

Per il secondo, penso che questo sia più pulito da capire:

Lo schema si ripete ogni 20, quindi puoi calcolare il modulo 20. Tutti gli elementi che vuoi saranno in una riga tranne quelli che sono divisibili per 20.

Per ottenere anche quelli, usa num-1 o meglio num + 19 per evitare di trattare con numeri negativi.

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

Questo presuppone che il modello si ripeta per sempre, quindi per 111-120 si applicherebbe di nuovo e così via. Altrimenti devi limitare i numeri a 100:

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

Con un paio di buoni commenti nel codice, può essere scritto in modo abbastanza conciso e leggibile.

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

Fondamentalmente hai spiegato tu stesso la risposta, ma ecco il codice per ogni evenienza.

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
}

Potresti pensare troppo a questo.

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

La prima riga if (x % 10)funziona perché (a) un valore che è un multiplo di 10 viene calcolato come '0', altri numeri risultano nel loro resto, (b) ifviene considerato un valore di 0 in un false, qualsiasi altro valore ètrue .

Modificare:

Per passare avanti e indietro negli anni venti, usa lo stesso trucco. Questa volta, il numero chiave è 10:

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

x/10restituisce un numero qualsiasi da 0 a 9 come 0, da 10 a 19 come 1e così via. Testare su pari o dispari - il & 1- ti dice se è pari o dispari. Poiché i tuoi intervalli sono effettivamente "da 11 a 20", sottrai 1 prima di eseguire il test.

Una richiesta di leggibilità

Anche se hai già alcune buone risposte, vorrei raccomandare una tecnica di programmazione che renderà il tuo codice più leggibile per qualche futuro lettore - che puoi essere tu in sei mesi, un collega ha chiesto di eseguire una revisione del codice, il tuo successore, .. .

Questo serve a racchiudere qualsiasi istruzione "intelligente" in una funzione che mostra esattamente (con il suo nome) cosa sta facendo. Sebbene ci sia un impatto minimo sulle prestazioni (da "overhead di chiamata di funzione") questo è veramente trascurabile in una situazione di gioco come questa.

Lungo la strada puoi disinfettare i tuoi input, ad esempio testare valori "illegali". Quindi potresti ritrovarti con un codice come questo - vedi quanto è più leggibile? Le "funzioni di supporto" possono essere nascoste da qualche parte (non è necessario che siano nel modulo principale: è chiaro dal loro nome quello che fanno):

#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");
}

Per il primo:

if (x % 10 == 0)

si applicherà a:

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

Per il secondo:

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

richiederà:

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

Fondamentalmente prima facciamo x-1per ottenere:

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

Quindi li dividiamo 10per ottenere:

1, 3, 5, ..

Quindi controlliamo se questo risultato è dispari.

Puoi provare quanto segue:

        // 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
        }

So che questa domanda ha così tante risposte, ma la getterò comunque qui ...

Tratto da Code Complete di Steve McConnell , seconda edizione: "Tabelle di accesso per gradini:

Un altro tipo di accesso al tavolo è il metodo del gradino. Questo metodo di accesso non è diretto come una struttura di indice, ma non spreca tanto spazio dati. L'idea generale delle strutture a gradini, illustrata nella Figura 18-5, è che le voci in una tabella sono valide per intervalli di dati piuttosto che per punti dati distinti.

Figura 18-5 L'approccio a gradini classifica ciascuna voce determinando il livello al quale colpisce una "scala". Il "passaggio" che colpisce determina la sua categoria.

Ad esempio, se stai scrivendo un programma di valutazione, l'intervallo di immissione "B" potrebbe essere compreso tra il 75% e il 90%. Ecco una serie di voti che potresti dover programmare un giorno:

Per utilizzare il metodo del gradino, inserisci l'estremità superiore di ogni intervallo in una tabella e poi scrivi un ciclo per controllare un punteggio rispetto all'estremità superiore di ogni intervallo. Quando trovi il punto in cui il punteggio supera per la prima volta il massimo di un intervallo, sai qual è il voto. Con la tecnica del gradino, devi stare attento a gestire correttamente i punti finali degli intervalli. Ecco il codice in Visual Basic che assegna i voti a un gruppo di studenti in base a questo esempio:

Sebbene questo sia un semplice esempio, puoi facilmente generalizzarlo per gestire più studenti, più schemi di valutazione (ad esempio, voti diversi per diversi livelli di punteggio su compiti diversi) e modifiche allo schema di valutazione. "

Code Complete , 2nd Edition, pagine 426 - 428 (capitolo 18).

Come altri hanno sottolineato, rendere le condizioni più concise non velocizzerà la compilazione o l'esecuzione, e non necessariamente aiuta nemmeno con la leggibilità.

Può aiutare a rendere il tuo programma più flessibile, nel caso in cui decidi in seguito di volere la versione del gioco per bambini su una tavola 6 x 6, o una versione avanzata (che puoi giocare tutta la notte) su una tavola 40 x 50 .

Quindi lo codificherei come segue:

// 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
  }
}

Sì, è prolisso, ma chiarisce esattamente cosa sta succedendo sul tabellone.

Se stavo sviluppando questo gioco da visualizzare su un telefono o tablet, creerei variabili ROWS e COLUMNS invece di costanti, in modo che possano essere impostate dinamicamente (all'inizio di un gioco) in modo che corrispondano alle dimensioni e all'orientamento dello schermo.

Consentirei anche di modificare l'orientamento dello schermo in qualsiasi momento, a metà partita: tutto ciò che devi fare è cambiare i valori di RIGHE e COLONNE, lasciando tutto il resto (il numero quadrato corrente su cui si trova ciascun giocatore e il i quadrati di inizio / fine di tutti i serpenti e le scale) invariati. Quindi devi 'solo' disegnare bene la lavagna e scrivere il codice per le tue animazioni (presumo che fosse lo scopo delle tue ifdichiarazioni) ...