Question

编写一个程序，提示用户将数据输入到整数向量中，并将第一个向量的值（乘以8乘以100递增）分配给另一个整数向量，然后按反向顺序排列。例：我们将第一个向量的值输入：

3   8   2   9   11  5  40 100 203 49

然后第二个向量具有值：

(49*8 +100) (203*8 +100) (100*8 +100) (40*8 +100) (5*8 +100) (11*8 +100) (9*8 +100)
(2*8 +100) (8*8 +100) (3*8 +100) .

所以这是一个要问的问题，但是到目前为止，我在代码中所能做的就是输入整数并将它们反序，但是我不知道如何将数学添加到编码中（相加100倍） 8）

#include <iostream>
using namespace std;

int main(){
    int input[500], output[500], count, i;

    cout << "Enter number of elements in array\n";
    cin >> count;

    cout << "Enter " << count << " numbers \n";

    for(i = 0; i < count; i++){
        cin >> input[i];
    }

    // Copy numbers from inputArray to outputArray in 
    // reverse order 
    for(i = 0; i < count; i++){
        output[i] = input[count-i-1];
    }    

    cout << "Reversed Array\n";
    for(i = 0; i < count; i++){
        cout << output[i] << " ";
    }
    return 0;
}

Answer 1

好吧，您没有在代码中的任何地方使用std::vector<int>，而是拥有两个大小均为500的普通数组。这不是必需的。

通过{em>仅分配用户想要的大小来了解std::vector<>，并使用它们代替那些数组。（即，用户输入count）。

第二，您可以在复制/填充到input向量数组时对output向量中的每个元素进行计算。

下面是示例代码： DEMO HERE

#include <iostream>
#include <vector>

int main()
{
    std::cout << "Enter number of elements in array\n";
    std::size_t count; std::cin >> count;

    std::cout << "Enter " << count << " numbers \n";
    std::vector<int> input(count, 0);
    // input element
    for (int& element : input) std::cin >> element;

    std::vector<int> output; output.reserve(count); // reserve memory for elements

    // apply to the output vector: for that    
    // simply reverse iterate input array using the while loop, 
    // emplace back the calculated result to the output array
    while (count--)
    {
        output.emplace_back((input[count] * 8) + 100);
    }

    // print out the output
    std::cout << "Reversed Array\n";
    for (const int element : output)    std::cout << element << " ";
    return 0;
}

输出：

Enter number of elements in array
10
Enter 10 numbers
1 2 3 4 5 6 7 8 9 10
Reversed Array
180 172 164 156 148 140 132 124 116 108

话虽如此，您也可以通过标准算法函数 std::trasform 来实现。为此，iterate reversely input中的std::transform向量，并使用 lambda函数（计算必要值），并将insert back应用于向量{ {1}}。

SEE LIVE

output

或者您甚至可以通过在整个程序中仅使用一个矢量数组来欺骗用户，您将在计算后直接存储用户输入，如下所示：

SEE LIVE

#include <algorithm> // std::transform

auto doMath = [](int element) { return (element * 8) + 100; }; // lambda which does the calculation
std::transform(input.crbegin(), input.crend(), std::back_inserter(output), doMath);

Answer 2

以相反的顺序将数字从inputArray复制到outputArray时，基本上可以访问inputArray的每个元素，然后将它们放入新数组，因此您也可以在此步骤中更改它们：

//take the element index (count - 1 - i) from inputArray, 
//multiply by 8, then increment by 100, 
//then assign output element index i equal to the result 

cout << "Reversed Array\n";
for(i = 0; i < count; i++){
    output[i] = ((input[count-i-1]) * 8) + 100;
}

Answer 3

实际计算是单线的：

std::vector<int> input(count);
// populate input vector here...
std::vector<int> result(count);

// one-liner, formatted for easier readability
std::transform(std::cbegin(input), std::cend(input),
    std::rbegin(result),
    [](int incoming) { return 8 * incoming + 100; } );

对std::cbegin和std::cend的调用分别返回指向input的第一个元素和input的末尾的迭代器。

对std::rbegin的调用将一个反向迭代器返回到result中；它从向量的末尾开始一直到开始。

最后一行是 lambda函数-通过名为int的{{1}}参数调用它并返回计算出的值。

标准算法incoming在输入范围（std::transform）内运行，并且对于每个元素，应用lambda函数并将结果存储在输出范围内（std::cbegin(input) .. std::cend(input)；没有结束迭代器，因为算法会在输入范围用尽时终止。

这看起来比其他答案中的一次性解决方案更为复杂。但是一旦您习惯了使用迭代器和算法，这便成为自然的表述，具有更大的清晰度和灵活性。例如，如果您的需求发生了变化，而您需要按顺序而不是相反的顺序编写值，则只需将std::rbegin(output)更改为std::rbegin(result)。

乘和加到整数向量

3 个答案: