การพิจารณาว่าตัวเลขเป็นผลคูณของสิบหรือภายในช่วงที่กำหนด

ฉันมีสองสามลูปที่ฉันต้องการในโปรแกรมของฉัน ฉันสามารถเขียนรหัสหลอกได้ แต่ฉันไม่แน่ใจว่าจะเขียนอย่างไรอย่างมีเหตุผล

ฉันต้องการ -

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

เกมนี้มีไว้สำหรับเกมกระดานบันไดงูถ้ามันสมเหตุสมผลกว่าสำหรับคำถามของฉัน

ฉันคิดว่าคำสั่งifแรกฉันต้องใช้โมดูลัส จะif (num == 100%10)ถูกต้องหรือไม่?

อันที่สองฉันไม่รู้ ฉันเขียนออกมาได้เหมือนif (num > 10 && num is < 21 || etc.)แต่มันต้องมีอะไรที่ฉลาดกว่านั้น

สำหรับหมายเลขแรกหากต้องการตรวจสอบว่าตัวเลขสามารถใช้ได้หลายครั้งหรือไม่:

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

สำหรับอันที่สอง:

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

แต่ค่อนข้างหนาแน่นและคุณอาจจะดีกว่าเพียงแค่ระบุตัวเลือกอย่างชัดเจน

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

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

มันเป็นตรรกะเดียวกัน แต่การใช้ฟังก์ชันทำให้เราเข้าใจชัดเจนขึ้นว่ามันหมายถึงอะไร

ถ้า (num คือผลคูณของ 10) {do this}

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

ถ้า (ตัวเลขอยู่ภายใน 11-20, 31-40, 51-60, 71-80, 91-100) {do this}

เคล็ดลับที่นี่คือการมองหาความเหมือนกันระหว่างช่วงต่างๆ แน่นอนคุณสามารถใช้วิธี "brute force" ได้เสมอ:

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

แต่คุณอาจสังเกตเห็นว่าถ้าคุณลบ1จากnumคุณจะมีช่วง:

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

กล่าวอีกนัยหนึ่งคือตัวเลขสองหลักทั้งหมดที่มีหลักแรกเป็นเลขคี่ ถัดไปคุณต้องคิดสูตรที่แสดงถึงสิ่งนี้ คุณสามารถหาหลักแรกได้โดยหารด้วย 10 และคุณสามารถทดสอบว่ามันเป็นเลขคี่โดยการตรวจสอบเศษ 1 ส่วนที่เหลือเมื่อคุณหารด้วย 2 รวมทั้งหมดเข้าด้วยกัน:

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

เมื่อพิจารณาถึงการแลกเปลี่ยนระหว่างรหัสที่ยาวกว่า แต่ดูแลรักษาได้และรหัส "ฉลาด" ที่สั้นกว่าฉันจะเลือกให้ยาวขึ้นและชัดเจนขึ้นทุกครั้ง อย่างน้อยที่สุดถ้าคุณพยายามที่จะฉลาดโปรดใส่ความคิดเห็นที่อธิบายถึงสิ่งที่คุณพยายามทำให้สำเร็จ

ช่วยสมมติว่านักพัฒนาคนต่อไปที่ทำงานกับโค้ดนั้นมีอาวุธและรู้ว่าคุณอาศัยอยู่ที่ไหน :-)

หากคุณใช้ GCC หรือคอมไพเลอร์ใด ๆ ที่รองรับช่วงเคสคุณสามารถทำได้ แต่โค้ดของคุณจะไม่พกพาได้

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

สำหรับผู้เข้าชมในอนาคตมากกว่าผู้เริ่มต้น สำหรับโซลูชันที่เหมือนอัลกอริทึมทั่วไปคุณสามารถจดรายการค่าเริ่มต้นและค่าสิ้นสุดและตรวจสอบว่าค่าที่ส่งผ่านอยู่ภายในค่าใดค่าหนึ่ง:

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

เพื่อความง่ายฉันใช้แลมบ์ดาแบบหลายตัว (C ++ 14) แทนpairอาร์กิวเมนต์ที่ชัดเจน สิ่งนี้ควรยึดติดกับการใช้งาน<และ==เพื่อให้สอดคล้องกับอัลกอริทึมมาตรฐาน แต่จะทำงานเช่นนี้ตราบเท่าที่Elemได้<=กำหนดไว้ อย่างไรก็ตามสามารถใช้งานได้ดังนี้:

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

มีตัวอย่างจริงเป็นที่นี่

คนแรกเป็นเรื่องง่าย คุณต้องใช้ตัวดำเนินการโมดูโลกับค่า num ของคุณ:

if ( ( num % 10 ) == 0)

เนื่องจาก C ++ กำลังประเมินทุกจำนวนที่ไม่เป็น 0 ตามความเป็นจริงคุณจึงสามารถเขียน:

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

สำหรับข้อที่สองฉันคิดว่าสิ่งนี้เข้าใจได้ง่ายกว่า:

รูปแบบจะเกิดซ้ำทุกๆ 20 ดังนั้นคุณจึงคำนวณโมดูโล 20 ได้องค์ประกอบทั้งหมดที่คุณต้องการจะอยู่ในแถวยกเว้นรูปที่หารด้วย 20 ได้

หากต้องการรับสิ่งเหล่านี้ให้ใช้ num-1 หรือ num + 19 ที่ดีกว่าเพื่อหลีกเลี่ยงการจัดการกับจำนวนลบ

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

นี่คือสมมติว่ารูปแบบนั้นซ้ำไปเรื่อย ๆ ดังนั้นสำหรับ 111-120 มันจะใช้อีกครั้งและอื่น ๆ มิฉะนั้นคุณจะต้อง จำกัด ตัวเลขไว้ที่ 100:

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

ด้วยความคิดเห็นที่ดีสองสามข้อในโค้ดทำให้สามารถเขียนได้ค่อนข้างกระชับและอ่านง่าย

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

โดยพื้นฐานแล้วคุณอธิบายคำตอบด้วยตัวคุณเอง แต่นี่คือรหัสในกรณีนี้

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
}

คุณอาจคิดมากเกินไป

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

บรรทัดแรกif (x % 10)ทำงานเพราะ (ก) ค่าที่มีหลาย 10 คำนวณเป็น '0', หมายเลขอื่น ๆ ส่งผลให้ remainer ของพวกเขา (ข) ค่าเป็น 0 ในifถือว่าเป็นfalseค่าอื่น ๆ trueคือ

แก้ไข:

หากต้องการสลับไปมาในวัยยี่สิบให้ใช้เคล็ดลับเดียวกัน คราวนี้หมายเลขสำคัญคือ10:

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

x/10ส่งกลับตัวเลขใด ๆ จาก 0 ถึง 9 เป็น010 ถึง 19 เป็น1และอื่น ๆ การทดสอบคู่หรือคี่ - the & 1- บอกคุณว่ามันเป็นคู่หรือคี่ เนื่องจากจริงๆแล้วช่วงของคุณคือ "11 ถึง 20" ให้ลบ 1 ก่อนทดสอบ

ข้ออ้างสำหรับการอ่าน

ในขณะที่คุณมีคำตอบที่ดีอยู่แล้วฉันอยากจะแนะนำเทคนิคการเขียนโปรแกรมที่จะทำให้โค้ดของคุณอ่านง่ายขึ้นสำหรับผู้อ่านในอนาคตซึ่งอาจเป็นคุณในหกเดือนเพื่อนร่วมงานขอให้ทำการตรวจสอบโค้ดผู้สืบทอดของคุณ .. .

นี่คือการรวมข้อความที่ "ฉลาด" ไว้ในฟังก์ชันที่แสดงให้เห็นว่ามันกำลังทำอะไร (พร้อมชื่อ) แม้ว่าจะมีผลกระทบเล็กน้อยต่อประสิทธิภาพการทำงาน (จาก "ฟังก์ชั่นเรียกค่าใช้จ่าย") แต่ก็มีความสำคัญน้อยมากในสถานการณ์เกมเช่นนี้

คุณสามารถล้างข้อมูลที่ป้อนได้ตลอดวิธีเช่นทดสอบค่า "ผิดกฎหมาย" ดังนั้นคุณอาจลงเอยด้วยรหัสเช่นนี้ - ดูว่าอ่านได้มากขึ้นแค่ไหน? "ฟังก์ชันตัวช่วย" สามารถซ่อนอยู่ที่ไหนสักแห่งได้ (ไม่จำเป็นต้องอยู่ในโมดูลหลัก: มันชัดเจนจากชื่อของพวกเขาว่าพวกเขาทำอะไร):

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

สำหรับคนแรก:

if (x % 10 == 0)

จะนำไปใช้กับ:

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

สำหรับอันที่สอง:

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

จะสมัครสำหรับ:

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

โดยพื้นฐานแล้วเราต้องทำก่อนx-1เพื่อรับ:

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

จากนั้นเราหารด้วย10เพื่อให้ได้:

1, 3, 5, ..

เราจึงตรวจสอบว่าผลลัพธ์นี้เป็นเลขคี่หรือไม่

คุณสามารถลองทำสิ่งต่อไปนี้:

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

ฉันรู้ว่าคำถามนี้มีคำตอบมากมาย แต่ฉันก็จะทิ้งฉันไว้ที่นี่อยู่ดี ...

นำมาจากCode Completeของ Steve McConnell ฉบับที่ 2: "Stair-Step Access Tables:

การเข้าถึงตารางอีกประเภทหนึ่งคือวิธีขั้นบันได วิธีการเข้าถึงนี้ไม่ตรงเหมือนโครงสร้างดัชนี แต่ไม่สิ้นเปลืองพื้นที่ข้อมูลมากนัก แนวคิดทั่วไปของโครงสร้างแบบขั้นบันไดดังแสดงในรูปที่ 18-5 คือรายการในตารางใช้ได้กับช่วงของข้อมูลแทนที่จะเป็นจุดข้อมูลที่แตกต่างกัน

รูปที่ 18-5 แนวทางแบบขั้นบันไดแบ่งประเภทของแต่ละรายการโดยกำหนดระดับที่จะชน "บันได" "ขั้นตอน" จะกำหนดหมวดหมู่

ตัวอย่างเช่นหากคุณกำลังเขียนโปรแกรมตัดเกรดช่วงรายการ“ B” อาจอยู่ระหว่าง 75 เปอร์เซ็นต์ถึง 90 เปอร์เซ็นต์ นี่คือเกรดต่างๆที่คุณอาจต้องตั้งโปรแกรมสักวันหนึ่ง:

ในการใช้วิธีการแบบขั้นบันไดคุณใส่ปลายด้านบนของแต่ละช่วงลงในตารางจากนั้นเขียนลูปเพื่อตรวจสอบคะแนนกับส่วนบนสุดของแต่ละช่วง เมื่อคุณพบจุดที่คะแนนแรกเกินด้านบนสุดของช่วงคุณจะรู้ว่าเกรดคืออะไร ด้วยเทคนิคขั้นบันไดคุณต้องระมัดระวังในการจัดการจุดสิ้นสุดของช่วงอย่างเหมาะสม นี่คือรหัสใน Visual Basic ที่กำหนดเกรดให้กับกลุ่มนักเรียนตามตัวอย่างนี้:

แม้ว่านี่จะเป็นตัวอย่างง่ายๆ แต่คุณสามารถสรุปได้อย่างง่ายดายเพื่อจัดการกับนักเรียนหลายคนรูปแบบการให้เกรดหลายแบบ (เช่นเกรดที่แตกต่างกันสำหรับระดับคะแนนที่แตกต่างกันในงานที่แตกต่างกัน) และการเปลี่ยนแปลงในรูปแบบการให้คะแนน "

Code Complete , 2nd Edition, หน้าที่ 426 - 428 (บทที่ 18)

ตามที่คนอื่น ๆ ได้ชี้ให้เห็นการทำให้เงื่อนไขรัดกุมขึ้นจะไม่ทำให้การรวบรวมหรือการดำเนินการเร็วขึ้นและไม่จำเป็นต้องช่วยในเรื่องความสามารถในการอ่านด้วยเช่นกัน

มันสามารถช่วยในการทำให้โปรแกรมของคุณมีความยืดหยุ่นมากขึ้นในกรณีที่คุณตัดสินใจในภายหลังว่าคุณต้องการเกมเวอร์ชันสำหรับเด็กวัยเตาะแตะบนกระดาน 6 x 6 หรือเวอร์ชันขั้นสูง (ที่คุณสามารถเล่นได้ตลอดทั้งคืน) บนกระดาน 40 x 50 .

ดังนั้นฉันจะเขียนโค้ดดังนี้:

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

ใช่มันเป็นรายละเอียด แต่มันทำให้ชัดเจนว่าเกิดอะไรขึ้นบนกระดานเกม

หากฉันกำลังพัฒนาเกมนี้เพื่อแสดงบนโทรศัพท์หรือแท็บเล็ตฉันจะสร้างตัวแปร ROWS และ COLUMNS แทนค่าคงที่ดังนั้นจึงสามารถตั้งค่าแบบไดนามิก (เมื่อเริ่มเกม) เพื่อให้ตรงกับขนาดหน้าจอและการวางแนว

ฉันยังอนุญาตให้เปลี่ยนการวางแนวหน้าจอได้ตลอดเวลาในช่วงกลางเกมสิ่งที่คุณต้องทำคือเปลี่ยนค่าของ ROWS และ COLUMNS ในขณะที่ปล่อยทุกสิ่งทุกอย่างไว้ (หมายเลขสี่เหลี่ยมปัจจุบันที่ผู้เล่นแต่ละคนเปิดอยู่และ เริ่มต้น / สิ้นสุดกำลังสองของงูและบันไดทั้งหมด) ไม่เปลี่ยนแปลง จากนั้นคุณจะต้องวาดกระดานอย่างสวยงามและเขียนโค้ดสำหรับภาพเคลื่อนไหวของคุณ (ฉันคิดว่านั่นคือจุดประสงค์ของifข้อความของคุณ) ...