Question

如何创建打印每三个数字的运行产品的C ++代码。

我不知道我是否理解。

Answer 1

不知道你在运行这个（32位架构，64位？）但是你可能会溢出一个int。你的答案会变得非常大。

Answer 2

变量sum溢出。即使将其设为unsigned long long也只能处理最多136个。double使用sum会让你接近 - 481 - 但C ++中没有可用的数据类型可以处理到500。

如果绝对必须转到500，那么您将需要使用可支持大整数值的类。您不会说出您正在使用的平台和编译器，但请查看BigInteger class之类的内容。

Answer 3

unsigned long product(100);
for (unsigned long i(103); i<=500; i+=3)
{
  product *= i;
  std::cout << product << std::endl;
}

所以这个步骤为3，每个数字从100到500迭代，然后计算产品然后输出。

虽然正如RobP所说，这可能会溢出，因此我在上面的代码中使用了无符号长整数。要了解检测到溢出，请参阅：

How to detect integer overflow?

Answer 4

我不确定这是否可以接受，但这会打印一个产品（在未指定所有格式之后，对吧？）。

unsigned long long  product = 1;
std::vector<int> fct;
for (int i = 100; i <= 500; i = i +3)
{
    if ( (i%2) == 0) {
        int r = i / 2;
        fct.push_back( r);
        std::cout << "product:" << product << " * 2";
        std::vector<int>::iterator it = fct.begin();
        while ( it != fct.end()) {
            std::cout << " * " << *it++;
        }
        std::cout << std::endl;
    } else {
    product = product * i;
    std::cout << "product:" << product << " * 2";
        std::vector<int>::iterator it = fct.begin();
        while ( it != fct.end()) {
            std::cout << " * " << *it++;
        }
        std::cout << std::endl;
    }
}

输出：

产品：1 * 2 * 50

产品：103 * 2 * 50

产品：103 * 2 * 50 * 53

产品：11227 * 2 * 50 * 53

产品：11227 * 2 * 50 * 53 * 56

产品：1291105 * 2 * 50 * 53 * 56

产品：1291105 * 2 * 50 * 53 * 56 * 59

（...）

产品：2557801186831291169 * 2 * 50 * 53 * 56 * 59 * 62 * 65 * 68 *   71 * 74 * 77 * 80

产品：2557801186831291169 * 2 * 50 * 53 * 56 * 59 * 62 * 65 * 68 *   71 * 74 * 77 * 80 * 83

（...）

产品：9086141910361656411 * 2 * 50 * 53 * 56 * 59 * 62 * 65 * 68 *   71 * 74 * 77 * 80 * 83 * 86 * 89 * 92 * 95 * 98 * 101 * 104 * 107 *   110 * 113 * 116 * 119 * 122 * 125 * 128 * 131 * 134 * 137 * 140 * 143   * 146 * 149 * 152 * 155 * 158 * 161 * 164 * 167 * 170 * 173 * 176 * 179 * 182 * 185 * 188 * 191 * 194 * 197 * 200 * 203 * 206 * 209 * 212   * 215 * 218 * 221 * 224 * 227 * 230 * 233 * 236 * 239 * 242 * 245

产品：9086141910361656411 * 2 * 50 * 53 * 56 * 59 * 62 * 65 * 68 *   71 * 74 * 77 * 80 * 83 * 86 * 89 * 92 * 95 * 98 * 101 * 104 * 107 *   110 * 113 * 116 * 119 * 122 * 125 * 128 * 131 * 134 * 137 * 140 * 143   * 146 * 149 * 152 * 155 * 158 * 161 * 164 * 167 * 170 * 173 * 176 * 179 * 182 * 185 * 188 * 191 * 194 * 197 * 200 * 203 * 206 * 209 * 212   * 215 * 218 * 221 * 224 * 227 * 230 * 233 * 236 * 239 * 242 * 245 * 248

产品：14532515211626403169 * 2 * 50 * 53 * 56 * 59 * 62 * 65 * 68 *   71 * 74 * 77 * 80 * 83 * 86 * 89 * 92 * 95 * 98 * 101 * 104 * 107 *   110 * 113 * 116 * 119 * 122 * 125 * 128 * 131 * 134 * 137 * 140 * 143   * 146 * 149 * 152 * 155 * 158 * 161 * 164 * 167 * 170 * 173 * 176 * 179 * 182 * 185 * 188 * 191 * 194 * 197 * 200 * 203 * 206 * 209 * 212   * 215 * 218 * 221 * 224 * 227 * 230 * 233 * 236 * 239 * 242 * 245 * 248

Answer 5

您使用整数数据类型的最大数字是， unsigned long long int b = 0XFFFFFFFFFFFFFFFF; （18446744073709551615）

在您的情况下，结果甚至大于此数字。

这就是这个问题的转折点。您可能必须找到处理大数字的方法。我建议找到现有的API或算法。

我编写了一个程序来执行此操作...我没有对边缘情况进行测试，并且可以有更好的方法来执行此操作。

目前，

#include <iostream>
#include <deque>

using namespace std;

void print_num(deque<int> &num) {
  for(int i=0;i < num.size();i++) {
    cout<<num[i];
  }
  cout<<endl;
}

deque<int> sum(deque<int> &oppA, deque<int> &oppB) {
  if (oppA.size() == 0) return oppB;
  if (oppB.size() == 0) return oppA;

  deque<int> result;
  unsigned int carry = 0;

  deque<int>::reverse_iterator r_oppA = oppA.rbegin();
  deque<int>::reverse_iterator r_oppB = oppB.rbegin();
  while ((r_oppA != oppA.rend()) && (r_oppB != oppB.rend())) {

    int tmp = *r_oppA + *r_oppB + carry;
    result.push_front(tmp % 10);
    carry = tmp / 10;

    r_oppB++;
    r_oppA++;

  }
  while (r_oppA != oppA.rend()) {
    int tmp = *r_oppA + carry;
    result.push_front(tmp % 10);
    carry = tmp / 10;
    r_oppA++;
  }

  while (r_oppB != oppB.rend()) {
    int tmp = *r_oppB + carry;
    result.push_front(tmp % 10);
    carry = tmp / 10;
    r_oppB++;
  }

  return result;
}

deque<int> multiply(deque<int>& multiplicand, deque<int>& multiplier) {

  unsigned int carry = 0;
  deque<int> result;
  int deci_cnt = 0;

  deque<int>::reverse_iterator r_multiplier = multiplier.rbegin();
  deque<int> tmp_result;

  while (r_multiplier != multiplier.rend()) {

    for (int i=0; i<deci_cnt ;i++) {
      tmp_result.push_front(0);
    }

    deque<int>::reverse_iterator r_multiplicand = multiplicand.rbegin();
    while (r_multiplicand != multiplicand.rend()) {
      int tmp = (*r_multiplicand) * (*r_multiplier) + carry;
      tmp_result.push_front(tmp % 10);
      carry = tmp / 10;
      r_multiplicand++;
    }

    if (carry != 0) {
      tmp_result.push_front(carry);
      carry = 0;
    }

    result = sum(result, tmp_result);

    deci_cnt++;
    tmp_result.clear();
    r_multiplier++;
  }

  return result;
}

deque<int> int_to_deque(unsigned long num) {
  deque<int> result;

  if (num == 0) {
    result.push_front(0);
  }

  while (num > 0) {
    result.push_front(num % 10);
    num = num / 10;
  }

  return result;
}

int main() {

  deque<int> num1 = int_to_deque(18446744073709551615ULL);
  deque<int> num2 = int_to_deque(18446744073709551615ULL);

  deque<int> result = multiply(num1, num2);
  print_num(result);

  return 0;
}

输出：340282366920928463426481119284349108225

打印正在运行的产品的代码

5 个答案: