Bir sayının onun katı mı yoksa belirli bir aralık kümesi içinde mi olduğunu belirleme

Programımda ihtiyacım olan birkaç döngüm var. Sözde kodu yazabilirim, ancak bunları mantıksal olarak nasıl yazacağımı tam olarak bilmiyorum.

İhtiyacım var -

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

Soruma daha mantıklı geliyorsa, bu bir yılan ve merdiven masa oyunu içindir.

Modulus kullanmam gerekecek ilk if ifadesini hayal ediyorum. Misiniz if (num == 100%10)doğru?

İkincisi hiçbir fikrim yok. Şöyle yazabilirim if (num > 10 && num is < 21 || etc.)ama bundan daha akıllıca bir şey olmalı.

İlki için, bir sayının çoklu kullanım olup olmadığını kontrol etmek için:

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

İkincisi için:

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

Ancak bu oldukça yoğun ve seçenekleri açıkça listelemeniz daha iyi olabilir.

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

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

Bu aynı mantık, ancak işlevi kullanarak ne anlama geldiğine dair daha net bir fikir ediniriz.

eğer (sayı 10'un katı ise) {bunu yap}

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

eğer (sayı 11-20, 31-40, 51-60, 71-80, 91-100 aralığındaysa) {bunu yapın}

Buradaki hile, aralıklar arasında bir tür ortaklık aramaktır. Elbette her zaman "kaba kuvvet" yöntemini kullanabilirsiniz:

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

Ama çıkarma eğer fark edebilirsiniz 1gelen num, aralıkları gerekecek:

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

Başka bir deyişle, ilk basamağı tek olan tüm iki basamaklı sayılar. Sonra, bunu ifade eden bir formül bulmanız gerekiyor. İlk basamağı 10'a bölerek elde edebilirsiniz ve 2'ye böldüğünüzde 1'in kalanını kontrol ederek tuhaf olduğunu test edebilirsiniz. Hepsini bir araya getirerek:

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

Daha uzun ancak bakımı yapılabilir kod ile daha kısa "akıllı" kod arasındaki denge göz önüne alındığında, her seferinde daha uzun ve daha net seçerdim. En azından, zeki olmaya çalışırsanız, lütfen tam olarak neyi başarmaya çalıştığınızı açıklayan bir yorum ekleyin.

Kod üzerinde çalışacak bir sonraki geliştiricinin silahlı olduğunu ve nerede yaşadığınızı bildiğini varsaymak yardımcı olur. :-)

GCC veya vaka aralıklarını destekleyen herhangi bir derleyici kullanıyorsanız bunu yapabilirsiniz, ancak kodunuz taşınabilir olmayacaktır .

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

Bu, yeni başlayanlardan çok gelecekteki ziyaretçiler için. Daha genel, algoritma benzeri bir çözüm için, başlangıç ​​ve bitiş değerlerinin bir listesini alabilir ve bunlardan birinde geçirilen bir değer olup olmadığını kontrol edebilirsiniz:

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

Basit olması için, açık bir pairargüman yerine polimorfik bir lambda (C ++ 14) kullandım . Bu aynı zamanda muhtemelen kullanarak tutması gerektiğini <ve ==standart algoritmalar ile tutarlı olması için, ancak sürece bu gibi çalışır Elemetti <=bunun için tanımlanmış. Neyse, şu şekilde kullanılabilir:

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

Burada canlı bir örnek var .

İlki kolaydır. Modulo operatörünü num değerinize uygulamanız yeterlidir:

if ( ( num % 10 ) == 0)

C ++, 0 olmayan her sayıyı doğru olarak değerlendirdiğinden, şunu da yazabilirsiniz:

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

İkincisi için, bunun anlaşılması daha temiz olduğunu düşünüyorum:

Desen her 20'de bir tekrar eder, böylece modulo 20'yi hesaplayabilirsiniz. 20'ye bölünebilenler dışında, istediğiniz tüm elemanlar arka arkaya olacaktır.

Bunları da almak için, negatif sayılarla uğraşmaktan kaçınmak için num-1 veya daha iyisi num + 19 kullanın.

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

Bu, desenin sonsuza kadar tekrar edeceğini varsayıyor, bu nedenle 111-120 için tekrar geçerli olacak ve bu böyle devam edecek. Aksi takdirde sayıları 100 ile sınırlamanız gerekir:

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

Koddaki birkaç iyi yorumla, oldukça kısa ve okunaklı bir şekilde yazılabilir.

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

Cevabı temelde kendiniz açıkladınız, ama işte her ihtimale karşı 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
}

Bunu çok düşünüyor olabilirsin.

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

İlk satır if (x % 10)çalışır çünkü (a) 10'un katı olan bir değer '0' olarak hesaplanır, diğer sayılar kalanları ile sonuçlanır, (b) an'da 0 değeri ifkabul edilir false, diğer herhangi bir değerdir true.

Düzenle:

Yirmili yaşlarda ileri geri geçiş yapmak için aynı numarayı kullanın. Bu sefer, önemli sayı 10:

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

x/100'dan 9'a kadar 0, 10'dan 19'a kadar herhangi bir sayıyı döndürür 1. Çift veya tek üzerinde test yapmak - bu & 1- size çift mi yoksa tek mi olduğunu söyler. Aralıklarınız gerçekte "11 ila 20" olduğundan, test etmeden önce 1 çıkarın.

Okunabilirlik talebi

Halihazırda bazı iyi yanıtlarınız olsa da, kodunuzu gelecekteki okuyucular için daha okunabilir hale getirecek bir programlama tekniği önermek isterim - bu altı ay içinde, bir meslektaşınız bir kod incelemesi gerçekleştirmesini istedi, halefiniz, .. .

Bu, herhangi bir "akıllı" ifadeyi tam olarak (adıyla) ne yaptığını gösteren bir işleve sarmaktır. Performans üzerinde çok küçük bir etki olsa da ("ek yükü çağıran işlevden") bu, böyle bir oyun durumunda gerçekten ihmal edilebilir.

Yol boyunca girdilerinizi dezenfekte edebilirsiniz - örneğin, "geçersiz" değerleri test edin. Böylece, bunun gibi bir kodla karşılaşabilirsiniz - ne kadar daha okunaklı olduğunu gördünüz mü? "Yardımcı işlevler" bir yere gizlenebilir (ana modülde olması gerekmez: ne yaptıkları isimlerinden anlaşılır):

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

İlki için:

if (x % 10 == 0)

şunlara uygulanacak:

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

İkincisi için:

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

için başvuracak:

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

Temel olarak ilk önce şunu x-1elde ederiz :

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

Sonra bunları 10elde etmek için böleriz :

1, 3, 5, ..

Yani bu sonucun tuhaf olup olmadığını kontrol ediyoruz.

Aşağıdakileri deneyebilirsiniz:

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

Bu sorunun pek çok cevabı olduğunu biliyorum ama yine de benimkini buraya atacağım ...

Steve McConnell's Code Complete , 2nd Edition'dan alınmıştır: "Stair-Step Erişim Tabloları:

Yine bir başka masa erişimi türü merdiven basamağı yöntemidir. Bu erişim yöntemi, bir dizin yapısı kadar doğrudan değildir, ancak çok fazla veri alanını boşa harcamaz. Şekil 18-5'te gösterilen merdiven basamağı yapılarının genel fikri, bir tablodaki girişlerin, farklı veri noktaları yerine veri aralıkları için geçerli olmasıdır.

Şekil 18-5 Merdiven basamağı yaklaşımı, bir "merdivene" çarptığı seviyeyi belirleyerek her girişi kategorize eder. Vurduğu "adım" kategorisini belirler.

Örneğin, bir not verme programı yazıyorsanız, "B" giriş aralığı yüzde 75 ile yüzde 90 arasında olabilir. İşte bir gün programlamanız gerekebilecek çeşitli notlar:

Merdiven basamağı yöntemini kullanmak için, her aralığın üst ucunu bir tabloya koyarsınız ve ardından her aralığın üst ucuna göre bir skoru kontrol etmek için bir döngü yazarsınız. Puanın bir aralığın üstünü ilk geçtiği noktayı bulduğunuzda, notun ne olduğunu bilirsiniz. Merdiven basamağı tekniğiyle, aralıkların uç noktalarını düzgün bir şekilde ele almak için dikkatli olmalısınız. İşte bu örneğe göre bir grup öğrenciye not atayan Visual Basic kodu:

Bu basit bir örnek olsa da, birden çok öğrenciyi, birden çok not verme şemasını (örneğin, farklı ödevlerde farklı puan seviyeleri için farklı notlar) ve not verme şemasındaki değişiklikleri ele alacak şekilde kolayca genelleştirebilirsiniz. "

Code Complete , 2. Baskı, sayfalar 426 - 428 (Bölüm 18).

Diğerlerinin de belirttiği gibi, koşulları daha özlü hale getirmek derlemeyi veya yürütmeyi hızlandırmaz ve okunabilirliğe de yardımcı olmaz.

Oyunun yeni yürümeye başlayan bir çocuk versiyonunu 6 x 6 tahtada veya gelişmiş bir versiyonunu (bütün gece oynayabileceğiniz) 40 x 50 tahtada istediğinize daha sonra karar verirseniz, programınızı daha esnek hale getirmenize yardımcı olabilir. .

Bu yüzden onu şu şekilde kodlardım:

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

Evet, ayrıntılı, ancak oyun tahtasında tam olarak ne olduğunu netleştiriyor.

Bu oyunu bir telefonda veya tablette görüntülenecek şekilde geliştiriyor olsaydım, sabitler yerine SATIRLAR ve SÜTUNLAR değişkenleri yapardım, böylece ekran boyutuna ve yönüne uyacak şekilde dinamik olarak (oyunun başında) ayarlanabilirler.

Ayrıca oyunun ortasında herhangi bir zamanda ekran yönünün değiştirilmesine de izin verirdim - tek yapmanız gereken SATIR ve SÜTUN değerlerini değiştirirken diğer her şeyi (her oyuncunun açık olduğu geçerli kare numarası ve tüm yılanların ve merdivenlerin başlangıç ​​/ bitiş kareleri) değişmedi. O zaman tahtayı güzelce çizmeniz ve animasyonlarınız için kod yazmanız gerekir ( ififadelerinizin amacının bu olduğunu varsayıyorum ) ...