生成2向量的笛卡爾積 <string> 在就地？

Question

如果我想獲得這兩個vector<string>的笛卡爾積：

vector<string> final{"a","b","c"};
vector<string> temp{"1","2"};

但我想把結果放在final ，這樣最終將包含：

A1
a2
B1
B2
C1
C2

我想在不創建臨時數組的情況下這樣做。 是否有可能做到這一點？ 如果重要， final的順序並不重要。

Answer 1

您可以嘗試以下方法

#include <iostream>
#include <vector>
#include <string>

int main() 
{
    std::vector<std::string> final{ "a", "b", "c" };
    std::vector<std::string> temp{ "1", "2" };

    auto n = final.size();

    final.resize( final.size() * temp.size() );

    for ( auto i = n, j = final.size(); i != 0; --i )
    {

        for ( auto it = temp.rbegin(); it != temp.rend(); ++it )
        {
            final[--j] = final[i-1] + *it; 
        }

    }

    for ( const auto &s : final ) std::cout << s << ' ';
    std::cout << std::endl;

    return 0;
}

程序輸出是

a1 a2 b1 b2 c1 c2 

Answer 2

試試笛卡兒函數：

#include <vector>
#include <string>

using namespace std;

void cartesian(vector<string>& f, vector<string> &o) {
int oldfsize = f.size();
f.resize(oldfsize * o.size());
for (int i = o.size() - 1; i>=0; i--) {
  for (int j = 0; j < oldfsize; j++) {
     f[i*oldfsize + j] = f[j] + o[i];
  }
 }
}


int main() 
{
vector<string> f{"a","b","c"};
vector<string> temp{"1","2"};
cartesian(f, temp);
for (auto &s: f) {
  printf("%s\n", s.c_str());
 }
}

Answer 3

這對我有用：

void testCartesianString(vector<string>& final,
                         vector<string>const& temp)
{
   size_t size1 = final.size();
   size_t size2 = temp.size();

   // Step 1.
   // Transform final to : {"a","a","b","b","c","c"}
   final.resize(size1*size2);
   for ( size_t i = size1; i > 0; --i )
   {
      for ( size_t j = (i-1)*size2; j < i*size2; ++j )
      {
         final[j] = final[i-1];
      }
   }

   // Step 2.
   // Now fix the values and
   // change final to : {"a1","a2","b1","b2","c1","c2"}
   for ( size_t i = 0; i < size1; ++i )
   {
      for ( size_t j = 0; j < size2; ++j )
      {
         final[i*size2+j] = final[i*size2+j] + temp[j];
         cout << final[i*size2+j] << " ";
      }
      cout << endl;
   }
}

Answer 4

這只是莫斯科解決方案中Vald的個人偏好選擇。 我認為動態數組可能會更快，因為分支會更少。 但我還沒有去寫一個計時測試台。

給定輸入vector<string> final和vector<string> temp ：

const auto size = testValues1.first.size();

testValues1.first.resize(size * testValues1.second.size());

for (int i = testValues1.first.size() - 1; i >= 0; --i){
    testValues1.first[i] = testValues1.first[i % size] + testValues1.second[i / size];
}

編輯：

不，這個解決方案速度慢但不快： http ： //ideone.com/e.js/kVIttT

並且通常明顯更快，但我不知道為什么......

無論如何， 從莫斯科的回答中選擇弗拉德