Bestimmen, ob eine Zahl entweder ein Vielfaches von zehn oder innerhalb eines bestimmten Satzes von Bereichen ist

Ich habe ein paar Schleifen, die ich in meinem Programm brauche. Ich kann den Pseudocode ausschreiben, bin mir aber nicht ganz sicher, wie ich sie logisch schreiben soll.

Ich brauche -

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

Dies ist für ein Brettspiel mit Schlangen und Leitern, wenn es für meine Frage sinnvoller ist.

Ich stelle mir die erste if-Anweisung vor, die ich verwenden muss, um den Modul zu verwenden if (num == 100%10) das richtig?

Den zweiten habe ich keine Ahnung. Ich kann es if (num > 10 && num is < 21 || etc)so ausschreiben, aber es muss etwas Klügeres geben.

Überprüfen Sie beim ersten Mal, ob eine Zahl ein Vielfaches der Verwendung ist:

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

Für den zweiten:

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

Aber das ist ziemlich dicht, und Sie sollten die Optionen besser explizit auflisten.

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

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

Es ist die gleiche Logik, aber durch die Verwendung der Funktion erhalten wir eine klarere Vorstellung davon, was dies bedeutet.

if (num ist ein Vielfaches von 10) {mach das}

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

if (num liegt innerhalb von 11-20, 31-40, 51-60, 71-80, 91-100) {do this}

Der Trick dabei ist, nach einer Art Gemeinsamkeit zwischen den Bereichen zu suchen. Natürlich können Sie immer die "Brute Force" -Methode verwenden:

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

Aber Sie können feststellen , dass, wenn Sie subtrahieren 1aus num, Sie werden die Bereiche haben:

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

Mit anderen Worten, alle zweistelligen Zahlen, deren erste Ziffer ungerade ist. Als nächstes müssen Sie eine Formel entwickeln, die dies ausdrückt. Sie können die erste Ziffer erhalten, indem Sie durch 10 teilen, und Sie können testen, ob sie ungerade ist, indem Sie beim Teilen durch 2 nach einem Rest von 1 suchen. Alles zusammen:

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

Angesichts des Kompromisses zwischen längerem, aber wartbarem Code und kürzerem "cleverem" Code würde ich jedes Mal länger und klarer wählen. Wenn Sie versuchen, klug zu sein, fügen Sie bitte einen Kommentar hinzu, der genau erklärt, was Sie erreichen möchten.

Es ist hilfreich anzunehmen, dass der nächste Entwickler, der an dem Code arbeitet, scharf ist und weiß, wo Sie leben. :-)

Wenn Sie GCC oder einen anderen Compiler verwenden, der dies unterstützt Fall Bereiche können Sie dies tun, aber Ihr Code nicht tragbar sein .

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

Dies ist für zukünftige Besucher mehr als für Anfänger. Für eine allgemeinere, algorithmische Lösung können Sie eine Liste von Start- und Endwerten erstellen und prüfen, ob sich ein übergebener Wert in einem von ihnen befindet:

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

Der Einfachheit halber habe ich anstelle eines expliziten pairArguments ein polymorphes Lambda (C ++ 14) verwendet . Dies sollte wahrscheinlich auch bei der Verwendung bleiben <und ==mit den Standardalgorithmen übereinstimmen, aber es funktioniert so, solange Elemes dafür <=definiert wurde. Wie auch immer, es kann so verwendet werden:

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

Es gibt ein anschauliches Beispiel hier .

Der erste ist einfach. Sie müssen nur den Modulo-Operator auf Ihren num-Wert anwenden:

if ( ( num % 10 ) == 0)

Da C ++ jede Zahl, die nicht 0 ist, als wahr auswertet, können Sie auch schreiben:

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

Für den zweiten denke ich, dass dies sauberer zu verstehen ist:

Das Muster wird alle 20 wiederholt, sodass Sie Modulo 20 berechnen können. Alle gewünschten Elemente befinden sich in einer Reihe, mit Ausnahme derjenigen, die durch 20 teilbar sind.

Um diese auch zu erhalten, verwenden Sie einfach num-1 oder besser num + 19, um den Umgang mit negativen Zahlen zu vermeiden.

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

Dies setzt voraus, dass sich das Muster für immer wiederholt, sodass es für 111-120 erneut gilt und so weiter. Andernfalls müssen Sie die Anzahl auf 100 beschränken:

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

Mit ein paar guten Kommentaren im Code kann es sehr präzise und lesbar geschrieben werden.

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

Sie haben die Antwort im Grunde selbst erklärt, aber hier ist der Code für alle Fälle.

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
}

Sie könnten dies überdenken.

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

Die erste Zeile if (x % 10)funktioniert, weil (a) ein Wert, der ein Vielfaches von 10 ist, als '0' berechnet wird, andere Zahlen zu ihrem Rest führen, (b) ein Wert von 0 in a ifberücksichtigt wird false, jeder andere Wert ist true.

Bearbeiten:

Verwenden Sie den gleichen Trick, um in den zwanziger Jahren hin und her zu wechseln. Diesmal lautet die zentrale Nummer 10:

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

x/10Gibt eine beliebige Zahl von 0 bis 9 als 0, 10 bis 19 als 1usw. zurück. & 1Wenn Sie auf gerade oder ungerade testen, erfahren Sie, ob es gerade oder ungerade ist. Da Ihre Bereiche tatsächlich "11 bis 20" sind, subtrahieren Sie 1 vor dem Testen.

Ein Plädoyer für Lesbarkeit

Obwohl Sie bereits einige gute Antworten haben, möchte ich eine Programmiertechnik empfehlen, die Ihren Code für zukünftige Leser besser lesbar macht - das können Sie in sechs Monaten sein, ein Kollege, der gebeten wurde, eine Codeüberprüfung durchzuführen, Ihr Nachfolger, .. .

Dies dient dazu, alle "cleveren" Anweisungen in eine Funktion zu packen, die genau (mit ihrem Namen) zeigt, was sie tut. Während es einen winzigen Einfluss auf die Leistung gibt (von "Funktionsaufruf-Overhead"), ist dies in einer Spielsituation wie dieser wirklich vernachlässigbar.

Unterwegs können Sie Ihre Eingaben bereinigen - beispielsweise auf "illegale" Werte testen. So könnte es sein, dass Sie Code wie diesen erhalten - sehen Sie, wie viel besser lesbar er ist? Die "Hilfsfunktionen" können irgendwo versteckt sein (sie müssen nicht im Hauptmodul sein: aus ihrem Namen geht hervor, was sie tun):

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

Für den ersten:

if (x % 10 == 0)

gilt für:

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

Für den zweiten:

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

wird beantragen für:

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

Wir tun x-1im Grunde zuerst, um zu bekommen:

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

Dann teilen wir sie durch 10, um zu erhalten:

1, 3, 5, ..

Wir prüfen also, ob dieses Ergebnis ungerade ist.

Sie können Folgendes versuchen:

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

Ich weiß, dass diese Frage so viele Antworten hat, aber ich werde meine trotzdem hierher werfen ...

Entnommen aus Steve McConnells Code Complete , 2. Auflage: "Stair-Step Access Tables:

Eine weitere Art des Tischzugangs ist die Treppenstufenmethode. Diese Zugriffsmethode ist nicht so direkt wie eine Indexstruktur, verschwendet jedoch nicht so viel Datenraum. Die in Abbildung 18-5 dargestellte allgemeine Idee von Treppenstufenstrukturen besteht darin, dass Einträge in einer Tabelle eher für Datenbereiche als für bestimmte Datenpunkte gültig sind.

Abbildung 18-5 Der Treppenstufenansatz kategorisiert jeden Eintrag, indem er die Ebene bestimmt, auf der er auf eine „Treppe“ trifft. Der „Schritt“, den es trifft, bestimmt seine Kategorie.

Wenn Sie beispielsweise ein Benotungsprogramm schreiben, kann der Eingabebereich „B“ zwischen 75 und 90 Prozent liegen. Hier ist eine Reihe von Noten, die Sie möglicherweise eines Tages programmieren müssen:

Um die Treppenstufenmethode zu verwenden, fügen Sie das obere Ende jedes Bereichs in eine Tabelle ein und schreiben dann eine Schleife, um eine Punktzahl gegen das obere Ende jedes Bereichs zu überprüfen. Wenn Sie den Punkt finden, an dem die Punktzahl zum ersten Mal die Spitze eines Bereichs überschreitet, wissen Sie, wie hoch die Note ist. Bei der Treppenstufentechnik müssen Sie darauf achten, die Endpunkte der Bereiche richtig zu handhaben. Hier ist der Code in Visual Basic, der einer Gruppe von Schülern anhand dieses Beispiels Noten zuweist:

Obwohl dies ein einfaches Beispiel ist, können Sie es leicht verallgemeinern, um mehrere Schüler, mehrere Bewertungsschemata (z. B. unterschiedliche Noten für unterschiedliche Punktebenen bei unterschiedlichen Aufgaben) und Änderungen im Bewertungsschema zu behandeln. "

Code Complete , 2. Auflage, Seiten 426 - 428 (Kapitel 18).

Wie andere bereits betont haben, beschleunigt eine präzisere Gestaltung der Bedingungen weder die Kompilierung noch die Ausführung, und dies trägt auch nicht unbedingt zur Lesbarkeit bei.

Dies kann Ihnen dabei helfen, Ihr Programm flexibler zu gestalten, falls Sie später entscheiden, dass Sie eine Kleinkindversion des Spiels auf einem 6 x 6-Brett oder eine erweiterte Version (die Sie die ganze Nacht spielen können) auf einem 40 x 50-Brett wünschen .

Also würde ich es wie folgt codieren:

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

Ja, es ist ausführlich, aber es macht deutlich, was genau auf dem Spielbrett passiert.

Wenn ich dieses Spiel für die Anzeige auf einem Telefon oder Tablet entwickeln würde, würde ich anstelle von Konstanten ROWS- und COLUMNS-Variablen erstellen, damit sie dynamisch (zu Beginn eines Spiels) an die Bildschirmgröße und -ausrichtung angepasst werden können.

Ich würde auch zulassen, dass die Bildschirmausrichtung jederzeit während des Spiels geändert wird - alles, was Sie tun müssen, ist, die Werte von ROWS und COLUMNS zu ändern, während Sie alles andere belassen (die aktuelle quadratische Zahl, auf der jeder Spieler ist, und die Start- / Endquadrate aller Schlangen und Leitern) unverändert. Dann müssen Sie "nur" die Tafel schön zeichnen und Code für Ihre Animationen schreiben (ich nehme an, das war der Zweck von Ihnenif Aussagen) ...