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

依旧......

我正在考虑使用2个数组，然后乘以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

您可以保留前2个阵列。您可以分3个步骤完成此操作。

检查number是否在10^n and 5*(10^n)之间。如果是，请使用第一个数组。如果没有，请使用第二个数组。

然后将10^n的每个数字乘以n，以便10^n < number。

这可以通过for循环来检查

Answer 2

我会从这样的事情开始：

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 3

您必须首先注意，您无法返回自动数组。对于这个用例，最简单的就是使用静态的。

然后您的算法可以重写为：

从数组[1, 2, 3, 4, 5]
如果数字小于数组的最后一个数字，则返回数组
else将数组交替乘以2和5

在C ++中它给出了：

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 4

这是一个变体，可以完成你应该做的事情 - 显示那些输出 - 而不是返回一个数组它根本不使用任何阵列（请注意，所述问题包含重叠间隔。我假设间隔实际为0-5,6-10,11-50,51-100,101-500,501-1000和> 1000。）< / p>

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

如何动态显示数组

4 个答案: