숫자가 10의 배수인지 아니면 특정 범위 내에 있는지 확인

프로그램에 필요한 루프가 몇 개 있습니다. 의사 코드를 작성할 수 있지만 논리적으로 작성하는 방법을 완전히 모르겠습니다.

나는 필요하다 -

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

동일한 논리이지만 함수를 사용하면 의미를 더 명확하게 이해할 수 있습니다.

if (num은 10의 배수) {do this}

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

if (num is within 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으로 나누어 첫 번째 숫자를 얻을 수 있고 2로 나눌 때 나머지 1을 확인하여 홀수인지 테스트 할 수 있습니다. 모두 합치면 :

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

간단하게하기 위해 명시적인 pair인수 대신 다형성 람다 (C ++ 14)를 사용했습니다 . 이것은 또한 아마 사용에 충실해야 <하고 ==표준 알고리즘과 일치하도록하지만만큼이 같은 작품 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이 아닌 모든 숫자를 true로 평가하므로 다음과 같이 작성할 수도 있습니다.

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)은 (a) 10의 배수 인 값이 '0'으로 계산되고 다른 숫자는 나머지 값이되고 (b) an의 값이 0으로 if간주 false되고 다른 값은이므로 작동 true합니다.

편집하다:

20 대에 앞뒤로 전환하려면 동일한 트릭을 사용하십시오. 이번에 핵심적인 숫자는 10다음과 같습니다.

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

x/100에서 9까지의 숫자를 0, 10에서 19 까지 등으로 반환합니다 1. 짝수 또는 홀수 테스트-the-는 & 1그것이 짝수인지 홀수인지 알려줍니다. 범위가 실제로 "11-20"이므로 테스트하기 전에 1을 뺍니다.

가독성에 대한 간청

이미 몇 가지 좋은 답변이 있지만 향후 독자가 코드를 더 쉽게 읽을 수있는 프로그래밍 기술을 추천하고 싶습니다. 6 개월 후에 동료가 코드 검토를 수행하도록 요청했습니다. .

이것은 어떤 "영리한"문장을 그것이하는 일을 정확히 (이름과 함께) 보여주는 함수로 감싸는 것입니다. 성능에 약간의 영향이 있지만 ( "함수 호출 오버 헤드"에서) 이것은 이와 같은 게임 상황에서 정말 무시할 만합니다.

그 과정에서 입력 내용을 정리할 수 있습니다 (예 : "불법"값 테스트). 따라서 이와 같은 코드로 끝날 수 있습니다. 얼마나 더 읽기 쉬운 지 보시겠습니까? "도우미 기능"은 어딘가에 숨겨져있을 수 있습니다 (메인 모듈에있을 필요는 없습니다. 이름에서 무엇을하는지 명확합니다).

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

이 질문에 너무 많은 답변이 있다는 것을 알고 있지만 어쨌든 여기에 던질 것입니다 ...

Steve McConnell의 Code Complete , 2nd Edition에서 발췌 : "계단식 액세스 테이블 :

또 다른 종류의 테이블 액세스는 계단식 방법입니다. 이 액세스 방법은 인덱스 구조만큼 직접적이지는 않지만 많은 데이터 공간을 낭비하지 않습니다. 그림 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진술 의 목적이라고 가정합니다 ) ...