Określanie, czy liczba jest wielokrotnością dziesięciu, czy w określonym zestawie zakresów

Mam kilka pętli, których potrzebuję w moim programie. Potrafię napisać pseudokod, ale nie jestem do końca pewien, jak napisać je logicznie.

Potrzebuję -

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

To jest dla gry planszowej węże i drabiny, jeśli ma to więcej sensu w przypadku mojego pytania.

Wyobrażam sobie pierwszą instrukcję if , w której będę musiał użyć modułu. Byłoby if (num == 100%10)poprawne?

Drugi nie mam pojęcia. Mogę to napisać w ten sposób if (num > 10 && num is < 21 || etc.), ale musi być coś mądrzejszego.

W przypadku pierwszego, aby sprawdzić, czy liczba jest wielokrotnością użycia:

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

W przypadku drugiego:

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

Ale to dość gęste i może być lepiej, jeśli po prostu wymień opcje bezpośrednio.

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

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

To ta sama logika, ale używając funkcji, uzyskujemy jaśniejsze pojęcie o tym, co ona oznacza.

if (num to wielokrotność 10) {zrób to}

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

if (num należy do 11-20, 31-40, 51-60, 71-80, 91-100) {zrób to}

Sztuczka polega na tym, aby szukać pewnego rodzaju podobieństwa między zakresami. Oczywiście zawsze możesz użyć metody „brutalnej siły”:

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

Ale możesz zauważyć, że jeśli odejmiesz 1od num, będziesz mieć zakresy:

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

Innymi słowy, wszystkie dwucyfrowe liczby, których pierwsza cyfra jest nieparzysta. Następnie musisz wymyślić formułę, która to wyraża. Możesz otrzymać pierwszą cyfrę, dzieląc przez 10, i możesz sprawdzić, czy jest nieparzysta, sprawdzając resztę 1, gdy dzielisz przez 2. Składając to wszystko razem:

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

Biorąc pod uwagę kompromis między dłuższym, ale możliwym do utrzymania kodem, a krótszym „inteligentnym” kodem, za każdym razem wybrałbym dłuższy i wyraźniejszy. Przynajmniej, jeśli starasz się być sprytny, dołącz komentarz, który dokładnie wyjaśnia, co próbujesz osiągnąć.

Pomaga założyć, że następny programista, który będzie pracował nad kodem, jest uzbrojony i wie, gdzie mieszkasz. :-)

Jeśli używasz GCC lub dowolnego kompilatora obsługującego zakresy wielkości liter, możesz to zrobić, ale Twój kod nie będzie przenośny .

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

To jest bardziej dla przyszłych gości niż początkujących. Aby uzyskać bardziej ogólne rozwiązanie podobne do algorytmu, możesz wziąć listę wartości początkowych i końcowych i sprawdzić, czy przekazana wartość znajduje się w jednej z nich:

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

Dla uproszczenia użyłem polimorficznej lambda (C ++ 14) zamiast jawnego pairargumentu. Powinno to również prawdopodobnie trzymać się używania <i ==być spójne ze standardowymi algorytmami, ale działa tak długo, jak Elemzostało <=to dla niego zdefiniowane. W każdym razie można go używać w następujący sposób:

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

Jest żywy przykład tutaj .

Pierwsza jest łatwa. Wystarczy zastosować operator modulo do wartości num:

if ( ( num % 10 ) == 0)

Ponieważ C ++ ocenia każdą liczbę inną niż 0 jako prawdę, możesz również napisać:

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

Po drugie, myślę, że jest to bardziej przejrzyste do zrozumienia:

Wzór powtarza się co 20, więc możesz obliczyć modulo 20. Wszystkie elementy, które chcesz, będą w rzędzie, z wyjątkiem tych, które są podzielne przez 20.

Aby je również uzyskać, po prostu użyj num-1 lub lepiej num + 19, aby uniknąć zajmowania się liczbami ujemnymi.

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

Zakłada się, że wzór będzie się powtarzał w nieskończoność, więc dla 111-120 będzie obowiązywał ponownie i tak dalej. W przeciwnym razie musisz ograniczyć liczby do 100:

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

Dzięki kilku dobrym komentarzom w kodzie można go napisać dość zwięźle i czytelnie.

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

W zasadzie sam wyjaśniłeś odpowiedź, ale na wszelki wypadek oto kod.

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
}

Możesz się nad tym zastanawiać.

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

Pierwsza linia if (x % 10)działa, ponieważ (a), to wartość, która jest wielokrotnością 10 oblicza jako „0”, inne liczby spowodować ich remainer, (b) wartość 0 w sposób ifjest uważany falsekażda inna wartość true.

Edytować:

Aby przełączać się tam iz powrotem w latach dwudziestych, użyj tej samej sztuczki. Tym razem kluczowa liczba to 10:

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

x/10zwraca dowolną liczbę od 0 do 9 jako 0, od 10 do 19 jako 1i tak dalej. Testowanie parzyste lub nieparzyste - & 1- mówi, czy jest parzyste czy nieparzyste. Ponieważ Twoje zakresy to w rzeczywistości „11 do 20”, przed testowaniem odejmij 1.

Apel o czytelność

Chociaż masz już kilka dobrych odpowiedzi, chciałbym polecić technikę programowania, która sprawi, że Twój kod będzie bardziej czytelny dla jakiegoś przyszłego czytelnika - możesz być za sześć miesięcy, kolega poprosił o dokonanie przeglądu kodu, twój następca ... .

Ma to na celu zawinięcie wszelkich „sprytnych” instrukcji w funkcję, która dokładnie (wraz ze swoją nazwą) pokazuje, co robi. Chociaż istnieje niewielki wpływ na wydajność (wynikający z „narzutu wywołań funkcji”), jest to naprawdę pomijalne w takiej sytuacji w grze.

Po drodze możesz oczyścić swoje dane wejściowe - na przykład przetestować pod kątem „niedozwolonych” wartości. Tak więc możesz skończyć z takim kodem - zobacz, o ile jest bardziej czytelny? „Funkcje pomocnicze” można gdzieś ukryć (nie muszą znajdować się w głównym module: z ich nazwy jasno wynika, co robią):

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

Na pierwszy:

if (x % 10 == 0)

będzie dotyczyć:

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

W przypadku drugiego:

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

będzie ubiegać się o:

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

Zasadniczo najpierw robimy, x-1aby uzyskać:

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

Następnie dzielimy je, 10aby otrzymać:

1, 3, 5, ..

Więc sprawdzamy, czy ten wynik jest dziwny.

Możesz spróbować następujących rzeczy:

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

Wiem, że na to pytanie jest tak wiele odpowiedzi, ale moje i tak wrzucę tutaj ...

Zaczerpnięte z książki Steve McConnell's Code Complete , 2. wydanie: „Tabele dostępu po schodach:

Jeszcze innym rodzajem dostępu do stołu jest metoda schodkowa. Ta metoda dostępu nie jest tak bezpośrednia jak struktura indeksu, ale nie marnuje tak dużo miejsca na dane. Ogólna idea struktur schodkowych, zilustrowana na rysunku 18-5, polega na tym, że wpisy w tabeli są prawidłowe dla zakresów danych, a nie dla odrębnych punktów danych.

Rysunek 18-5 Podejście schodkowe kategoryzuje każde wejście poprzez określenie poziomu, na którym uderza w „klatkę schodową”. „Krok”, który uderza, określa jego kategorię.

Na przykład, jeśli piszesz program oceniania, zakres pozycji „B” może wynosić od 75% do 90%. Oto szereg ocen, które pewnego dnia będziesz musiał zaprogramować:

Aby użyć metody schodkowej, należy umieścić górny koniec każdego zakresu w tabeli, a następnie napisać pętlę, aby porównać wynik z górnym końcem każdego zakresu. Kiedy znajdziesz punkt, w którym wynik po raz pierwszy przekracza górną granicę zakresu, wiesz, jaka jest ocena. W przypadku techniki schodkowej należy uważać, aby prawidłowo obsługiwać punkty końcowe zakresów. Oto kod w języku Visual Basic, który przypisuje oceny grupie uczniów na podstawie tego przykładu:

Chociaż jest to prosty przykład, można go łatwo uogólnić, aby uwzględnić wielu uczniów, wiele schematów oceniania (na przykład różne oceny dla różnych poziomów punktów za różne zadania) i zmiany w schemacie oceniania ”.

Code Complete , 2. wydanie, strony 426 - 428 (rozdział 18).

Jak zauważyli inni, bardziej zwięzłe warunki nie przyspieszą kompilacji ani wykonywania, a także niekoniecznie poprawią czytelność.

Może pomóc w uczynieniu programu bardziej elastycznym, na wypadek gdybyś później zdecydował, że chcesz wersję gry dla maluchów na planszy 6 x 6 lub wersję zaawansowaną (którą możesz grać całą noc) na planszy 40 x 50 .

Więc zakodowałbym to w następujący sposób:

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

Tak, jest rozwlekły, ale dokładnie wyjaśnia, co dzieje się na planszy.

Gdybym tworzył tę grę do wyświetlania na telefonie lub tablecie, zrobiłbym zmienne ROWS i COLUMNS zamiast stałych, aby można je było ustawić dynamicznie (na początku gry), aby dopasować rozmiar ekranu i orientację.

Pozwoliłbym również na zmianę orientacji ekranu w dowolnym momencie, w trakcie gry - wystarczy zmienić wartości ROWS i COLUMNS, pozostawiając wszystko inne (bieżący numer kwadratu, na którym jest każdy gracz, i kwadraty początku / końca wszystkich węży i ​​drabin) bez zmian. Następnie musisz „tylko” ładnie narysować planszę i napisać kod do swoich animacji (zakładam, że taki był cel twoich ifwypowiedzi) ...