C 프로그램이 반올림에서 증가하는 숫자를 찾아야합니다.

Question

첫 번째로, 영어를 유감스럽게 생각하며, 충분히 설명하지 못한다면. 내 코드의 출력을 통해 그 아이디어가 무엇인지 알 수 있기를 바랍니다. 문제는 내가 만든 방식으로 최대 999 (3 자리 숫자)까지만 작동한다는 것입니다. 나는 거기에 얼마나 많은 자릿수가 있는지 신경 쓰지 않고 그냥해야 할 일을하는 루프가 있어야한다고 생각한다.

int main(){ 
int n, m, k, digit1, digit2, digit3, p, a = 0; 
do{ 
    printf("Enter m and n (m < n):\n"); scanf("%d %d", &m, &n); 
    if (m < n) { 
     break; 
    } 
    else printf("\Error - m > n! Try again.\n\n"); 
} while (a == 0); 

printf("Output:\n"); 
for (k = m; k <= n; k++){ 
    p = k; 
    do{ 
     digit3 = p % 10; //123 % 10 = 3   13%10 = 3 == p/10 +1 
     digit1 = p/100; //123/100 = 1 
     digit2 = (p/10) % 10; // (123 /10) = 12%10 = 2 
     if (p > 100){ 
      if (digit2 == digit1 + 1 && digit3 == digit2 + 1){ 
       printf("%d ", k); 
      } break; 
     } 
     if (digit3 == ((p/10) + 1)) { 
      printf("%d ", k); 
     } break; 
     p = p/10; 
    } while (p > 0); 
} 
getch(); 
return 0; 
} 

예 출력 :

Enter m and n (m < n): 
    1 999 
    Output: 
    1 12 23 34 45 56 67 78 89 123 234 345 456 567 678 789 

이 출력이 정확하고 프로그램을 수행하는 것입니다. 불행하게도 999 이상에서 작동하도록 루프를 만들 수 없습니다. 사용자가 입력 한 간격으로 각 숫자가 이전보다 1 씩 큰 모든 숫자를 출력해야합니다.

Answer 1

가 여기에 내 걸릴 것입니다. 문제를 부분으로 나눕니다. 숫자가 "증가"하는지 확인하는 함수가 필요합니다. 즉, 기본 10 표현의 모든 숫자가 다음의 10의 거듭 제곱에 해당하는 것이고, 가장 큰 0이 아닌 숫자까지의 숫자입니다 . (이 개념을 형식적으로 표현하는 것보다 더 열심히).

#include <stdlib.h> 
#include <stdio.h> 
#include <stdbool.h> 

bool growing(unsigned int x) 
{ 
    //if (x < 10) 
    // return false; 
    unsigned int last = x % 10 + 1; 
    while (x>0) { 
     unsigned int cur = x % 10; 
     x /= 10; 
     if (cur != last-1) 
      return false; 
     last = cur; 
    } 
    return true; 
} 

int main(void) 
{ 
    unsigned int m = 1; 
    unsigned int n = 123456789; 

    for (unsigned int i = m; i <= n; ++i) { 
     if (growing(i)) { 
      printf("%i ", i); 
     } 
    } 
} 

하나의 숫자를 수락할지 여부를 결정해야합니다. 그렇다면 첫 번째 두 줄의 주석 처리를 제거하십시오.

는 분명히 가장 높은 증가는 123456789

편집 : 직접으로 함수를 이동 인해 기능 버전은 루프 :

#include <stdlib.h> 
#include <stdio.h> 
#include <stdbool.h> 

int main(void) 
{ 
    unsigned int m = 1; 
    unsigned int n = 123456789; 

    for (unsigned int i = m; i <= n; ++i) { 
     unsigned int x = i; 
     bool growing = true; 
     //if (x < 10) 
     // growing = false; 
     unsigned int last = x % 10 + 1; 
     while (x>0) { 
      unsigned int cur = x % 10; 
      x /= 10; 
      if (cur != last - 1) 
       growing = false; 
      last = cur; 
     } 

     if (growing) { 
      printf("%i ", i); 
     } 
    } 
} 

당신은 휴식 후와 약간 빠른 버전을 얻을 수 있습니다 거짓으로 성장하는 설정.

쓸모없는 호언 : 학생들이 기본 자료를 이해하기 전에 왜 사람들이 I/O를 계속 가르치는 지 이해할 수 없습니다. 기능을 가르치지 않고, 그것을 깨닫지 않고 하나 (main)를 작성하고, 포인터에 대해 모르는 사이에 다른 사람 (scanf, printf)에게 전화하십시오. 선생님이 어떻게 &을 정당화하는지 궁금합니다.

Answer 2

한 번에 모든 자릿수를 추적 할 필요가 없습니다. 당신이 체크 할 필요가 마지막 숫자가 같은 두 번째 마지막

뭔가 이상 더 많은 것을 아마도

int main(){ 
int n, m, k, digit1, digit2, digit3, p, a = 0; 
do{ 
    printf("Enter m and n (m < n):\n"); scanf("%d %d", &m, &n); 
    if (m < n) { 
     break; 
    } 
    else printf("\Error - m > n! Try again.\n\n"); 
} while (a == 0); 

printf("Output:\n"); 
k = m; 
while(k++ <= n){ 
    int p = k; 
    int flag = 0; 
    int num; 

    while(p > 10){ 
     // Get the last digit 
     // in case of 123 -> 3 
     num = p % 10; 
     // Reduce p by 10 
     // 123 -> 12 
     p = p/10; 
     // check 3 == 12%10 + 1 
     // if this is correct go back to start of the loop 
     // we may have more digits 
     if(num == p % 10 + 1) continue; 
     // So the digits dont match, set the flag 
     // break out of the loop 
     flag = 1; 
     break; 
    }  
    // Outside the loop check the flag and print 
    if(k > 10 && !flag) 
     printf("%d ",k); 
} 
return 0; 
} 

Answer 3

여기에서 문제에 대한 해결 방안입니다. 그것은 문자열이 아닌 숫자와 함께 작동, 따라서 효율성이 떨어집니다하지만 어쩌면 쉽게 이해하기 위해 다음과 같은 이유로,

Enter m and n (m < n): 
1 999 
Output: 
1 2 3 4 5 6 7 8 9 12 23 34 45 56 67 78 89 123 234 345 456 567 678 789 

내가 실제 규칙이 무엇인지 궁금 :

#include <stdbool.h> 
#include <stdio.h> 
#include <stdlib.h> 

int main() 
{ 
    int m, n, i, j; 
    char buf[20], c, last; 
    _Bool ascending; 

    puts("Enter m and n (m < n):"); 
    scanf("%d %d", &m, &n); 
    if (m >= n) { 
     fprintf(stderr, "m must be smaller than n"); 
     exit(EXIT_FAILURE); 
    } 

    puts("Output:"); 
    for (i = m; i < n; i++) { 
     sprintf(buf, "%d", i); 
     ascending = true; 
     last = 0; 
     for (j = 0; buf[j] != 0; j++) { 
      c = buf[j]; 
      if (last != 0 && last != c - 1) { 
       ascending = false; 
       break; 
      } else { 
       last = c; 
      } 
     } 
     if (ascending) { 
      printf("%d ", i); 
     } 
    } 

    return EXIT_SUCCESS; 
} 

그러나, 출력의 약간 다른 모습 2와 9 사이의 숫자는 1보다 다소 오름차순으로 표시됩니다.

그리고 여기에 더 큰 수에 대한 출력입니다 :

Enter m and n (m < n): 
1 10000 
Output: 
1 2 3 4 5 6 7 8 9 12 23 34 45 56 67 78 89 123 234 345 456 567 678 789 1234 2345 3456 4567 5678 6789 

Answer 4

그래서 여기 연산에 따라 다른 버전의 :

#include <stdbool.h> 
#include <stdio.h> 
#include <stdlib.h> 

_Bool only_consecutive_figures(int number) 
{ 
    int figure, last; 

    for (last = 0; number > 0; number /= 10) { 
     figure = number % 10; 
     if ((last != 0 && last != figure + 1) || figure == 0) { 
      return false; 
     } 
     last = figure; 
    } 

    return true; 
} 

int main() 
{ 
    int m, n, i; 

    puts("Enter m and n (m < n):"); 
    scanf("%d %d", &m, &n); 
    if (m >= n) { 
     fprintf(stderr, "m must be smaller than n"); 
     exit(EXIT_FAILURE); 
    } 

    puts("Output:"); 
    for (i = m; i < n; i++) { 
     if (only_consecutive_figures(i)) { 
      printf("%d ", i); 
     } 
    } 
    putchar('\n'); 

    return EXIT_SUCCESS; 
}