배열을 표시하는 방법 동적으로 나는 다음과 같은 표시하는 함수를 작성해야

Question

:에 거는 그때이 배열을 사용하기 생각하고 등등

if number is between 0 - 5 then display values 1, 2, 3, 4, 5 
if number is between 5 - 10 then display values 2, 4, 6, 8, 10 
if number is between 10 - 50 then display values 10, 20, 30, 40, 50 
if number is between 50 - 100 then display values 20, 40, 60, 80, 100 
if number is between 100 - 500 then display values 100, 200, 300, 400, 500 
if number is between 500 - 1000 then display values 200, 400, 600, 800, 1000 
if number is between 1000 - 5000 then display values 1000, 2000, 3000, 4000, 5000 

및 ...

및 10.

int *MyFunct(int number) { 

    int a[5] = { 1, 2, 3, 4, 5 }; 
    int b[5] = { 2, 4, 6, 8, 10 }; 


    if (number >= 0 && number <= 5) {  
     return a; 
    } 
    else if (number > 5 && number <= 10) { 
     return b; 
    } 
    else if (number > 10 && number <= 50) { 
     a[1] *= 10; 
     a[2] *= 10; 
     a[3] *= 10; 
     a[4] *= 10; 
     a[5] *= 10; 
    } 
    . 
    . 
    . 
} 

동적으로 또는 더 간단하게 수행 할 가능성이 있습니까?

Answer 1

먼저해야 자동 배열을 반환 할 수 없습니다. 이 사용 사례의 경우 가장 간단한 방법은 정적 인 것을 사용하는 것입니다. 배열 수는 배열의 마지막 번호보다 작은 경우 [1, 2, 3, 4, 5]

와

가

• 시작, 배열
다른
• 교대로 배열을 곱을 반환 :
  는 그런 다음 알고리즘으로 재 진술 할 수있다 C에서

2 5 ++는 범 :

int *MyFunc(int n) { 
    static const int init[] = {1, 2, 3, 4, 5}; // the initial array 
    static int result[5]; 
    int& max = result[4]; // alias for the last value 

    // copy init to result: 
    for (int i=0; i<5; i++) result[i] = init[i]; 

    // find the range of n 
    for (;;) { 
     if (n <= max) { 
      break; 
     } 
     // multiply alternatively by 2 and by 5 
     for (int i=0; i<5; i++) result[i] *= 2; 
     if (n <= max) { 
      break; 
     } 
     for (int i=0; i<5; i++) result[i] *= 5; 
    } 
    return result; 
} 

간단하고 컴팩트 한 ...

Answer 2

처음 두 개의 어레이를 유지할 수 있습니다. 3 단계로이 작업을 수행 할 수 있습니다.

number이 10^n and 5*(10^n) 사이에 있는지 확인하십시오. 그럴 경우 첫 번째 배열을 사용하십시오. 그렇지 않은 경우 두 번째 배열을 사용하십시오.

그 후 n에 대해 10^n을 각 숫자에 곱하면 10^n < number입니다.

이

는 내가 그런 일 시작하는 것

Answer 3

을 확인하는 for 루프를 수행 할 수 있습니다

std::vector<unsigned int> MyFunct(unsigned int number) { 
    std::vector<unsigned int> numbers = { 1,2,3,4,5 }; 
    unsigned int factor = 1; 
    while(number >= 10) 
    { 
    number /= 10; 
    factor *= 10; 
    } 
    if(number >= 5) 
    { 
    factor *= 2; 
    } 

    for(unsigned int i = 0; i < numbers.size(); ++i) 
    { 
    numbers[i] *= factor; 
    } 

    return numbers; 
} 

당신은 또한베이스의 로그와 함께 일할 수 (10)

Answer 4

여기에 배열을 반환하는 대신 출력을 표시하는 방법이 있습니다.
배열을 전혀 사용하지 않습니다.
(위에서 언급 한 문제에는 겹치는 간격이 포함되어 있습니다. 간격은 실제로 0-5, 6-10, 11-50, 51-100, 101-500, 501-1000 및> 1000이라고 가정했습니다.)

int factor(int x) 
{ 
    if (x > 1000) 
    { 
     return 1000; 
    } 
    if (x > 500) 
    { 
     return 200; 
    } 
    if (x > 100) 
    { 
     return 100; 
    } 
    if (x > 50) 
    { 
     return 20; 
    } 
    if (x > 10) 
    { 
     return 10; 
    } 
    if (x > 5) 
    { 
     return 2; 
    } 
    return 1; 
} 


void display(int x) 
{ 
    auto f = factor(x); 
    for (int i = 1; i <= 5; ++i) 
    { 
     std::cout << f * i << " "; 
    } 
    std::cout << std::endl; 
} 

int main(int argc, char* argv[]) 
{ 
    std::vector<int> test = { 1, 6, 11, 52, 103, 504, 1005 }; 
    for (auto i: test) 
    { 
     display(i); 
    } 
} 

출력 :

1 2 3 4 5 
2 4 6 8 10 
10 20 30 40 50 
20 40 60 80 100 
100 200 300 400 500 
200 400 600 800 1000 
1000 2000 3000 4000 5000 

그리고 조건문 장쇄 대신 테이블을 사용 factor의 변화 :

int factor(int x) 
{ 
    struct interval { int limit; int factor; }; 
    interval intervals[] = {{1000, 1000}, 
          {500, 200}, 
          {100, 100}, 
          {50, 20}, 
          {10, 10}, 
          {5, 2}}; 
    for (auto i: intervals) 
    { 
     if (x > i.limit) 
     { 
      return i.factor; 
     } 
    } 
    return 1; 
}