我得到了一個大小的填充陣列，WxH需要通過將寬度和高度縮放為 2 的冪來創建一個新陣列。例如，2x3 縮放為 4, 2^2 時變為 8x12。我的目標是確保陣列中的所有舊值都放置在新陣列中，以便舊陣列中的 1 個值填充縮放陣列中的多個新對應部分。例如：

old_array = [[1,2],
             [3,4]]

變成

new_array = [[1,1,2,2],
             [1,1,2,2],
             [3,3,4,4],
             [3,3,4,4]]

當按 2 倍縮放時。有人可以向我解釋我將如何進行編程的邏輯嗎？

uj5u.com熱心網友回復：

其實很簡單。為簡單起見，我使用向量向量，注意到二維矩陣效率不高。但是，任何使用[]索引語法的2D 矩陣類都可以并且應該為了效率而被替換。

#include <vector>
using std::vector;

int main()
{
    vector<vector<int>> vin{ {1,2},{3,4},{5,6} };
    size_t scaleW = 2;
    size_t scaleH = 3;
    vector<vector<int>> vout(scaleH * vin.size(), vector<int>(scaleW * vin[0].size()));
    for (size_t i = 0; i < vout.size(); i  )
        for (size_t ii = 0; ii < vout[0].size(); ii  )
            vout[i][ii] = vin[i / scaleH][ii / scaleW];

    auto x = vout[8][3];        // last element s/b 6

}

uj5u.com熱心網友回復：

這是我的看法。它與@Tudor 的非常相似，但我認為在我們兩者之間，你可以選擇你最喜歡或最理解的。

首先，讓我們定義一個合適的二維陣列型別，因為 C 的標準庫在這方面非常缺乏。我將自己限制在一個相當簡單的結構中，以防您對面向物件編程感到不舒服。

#include <vector>
// using std::vector

struct Array2d
{
  unsigned rows, cols;
  std::vector<int> data;
};

這個列印功能應該讓你了解索引是如何作業的：

#include <cstdio>
// using std::putchar, std::printf, std::fputs

void print(const Array2d& arr)
{
  std::putchar('[');
  for(std::size_t row = 0; row < arr.rows;   row) {
    std::putchar('[');
    for(std::size_t col = 0; col < arr.cols;   col)
      std::printf("%d, ", arr.data[row * arr.cols   col]);
    std::fputs("]\n ", stdout);
  }
  std::fputs("]\n", stdout);
}

現在到了心臟，陣列縮放。嵌套的數量是......麻煩。

Array2d scale(const Array2d& in, unsigned rowfactor, unsigned colfactor)
{
  Array2d out;
  out.rows = in.rows * rowfactor;
  out.cols = in.cols * colfactor;
  out.data.resize(std::size_t(out.rows) * out.cols);
  for(std::size_t inrow = 0; inrow < in.rows;   inrow) {
    for(unsigned rowoff = 0; rowoff < rowfactor;   rowoff) {
      std::size_t outrow = inrow * rowfactor   rowoff;
      for(std::size_t incol = 0; incol < in.cols;   incol) {
        std::size_t in_idx = inrow * in.cols   incol;
        int inval = in.data[in_idx];
        for(unsigned coloff = 0; coloff < colfactor;   coloff) {
          std::size_t outcol = incol * colfactor   coloff;
          std::size_t out_idx = outrow * out.cols   outcol;
          out.data[out_idx] = inval;
        }
      }
    }
  }
  return out;
}

讓我們把它們放在一起做一個小小的演示：

int main()
{
  Array2d in;
  in.rows = 2;
  in.cols = 3;
  in.data.resize(in.rows * in.cols);
  for(std::size_t i = 0; i < in.rows * in.cols;   i)
    in.data[i] = static_cast<int>(i);
  print(in);
  print(scale(in, 3, 2));
}

這列印

[[0, 1, 2, ]
 [3, 4, 5, ]
 ]
[[0, 0, 1, 1, 2, 2, ]
 [0, 0, 1, 1, 2, 2, ]
 [0, 0, 1, 1, 2, 2, ]
 [3, 3, 4, 4, 5, 5, ]
 [3, 3, 4, 4, 5, 5, ]
 [3, 3, 4, 4, 5, 5, ]
 ]

uj5u.com熱心網友回復：

老實說，我在演算法方面非常糟糕，但我試了一下。
我不確定這是否可以僅使用一個矩陣來完成，或者是否可以在更短的時間復雜度內完成。
編輯：您可以估計這將進行的運算元量，W*H*S*S其中S是比例因子，W是寬度，H是輸入矩陣的高度。

我使用了 2 個矩陣m和r，m你的輸入在哪里，r你的結果/輸出在哪里。所有需要做的就是從mat 位置復制每個元素，[i][j]并將其變成一個具有相同 size 值的元素的正方形scale_factorinside r。

簡單的說：

int main()
{
    Matrix<int> m(2, 2);

    // initial values in your example
    m[0][0] = 1;
    m[0][1] = 2;
    m[1][0] = 3;
    m[1][1] = 4;
    m.Print();

    // pick some scale factor and create the new matrix
    unsigned long scale = 2;
    Matrix<int> r(m.rows*scale, m.columns*scale);

    // i know this is bad but it is the most
    //  straightforward way of doing this
    // it is also the only way i can think of :(
    for(unsigned long i1 = 0; i1 < m.rows; i1  )
        for(unsigned long j1 = 0; j1 < m.columns; j1  )
            for(unsigned long i2 = i1*scale; i2 < (i1 1)*scale; i2  )
                for(unsigned long j2 = j1*scale; j2 < (j1 1)*scale; j2  )
                    r[i2][j2] = m[i1][j1];

    // the output in your example
    std::cout << "\n\n";
    r.Print();

    return 0;
}

我認為這與問題無關，但我使用了一個類Matrix來存盤擴展矩陣的所有元素。我知道這會讓人分心，但這仍然存在C ，我們必須管理記憶體。如果你想用這個演算法實作的目標scale_factor很大，那么我需要大量的記憶體，所以我用這個把它包起來：

template <typename type_t>
class Matrix
{
    private:
        type_t** Data;
    public:
        // should be private and have Getters but
        //  that would make the code larger...
        unsigned long rows;
        unsigned long columns;

        // 2d Arrays get big pretty fast with what you are
        //  trying to do.
        Matrix(unsigned long rows, unsigned long columns)
        {
            this->rows = rows;
            this->columns = columns;

            Data = new type_t*[rows];
            for(unsigned long i = 0; i < rows; i  )
                Data[i] = new type_t[columns];
        }

        // It is true, a copy constructor is needed
        //  as HolyBlackCat pointed out
        Matrix(const Matrix& m)
        {
            rows = m.rows;
            columns = m.columns;

            Data = new type_t*[rows];
            for(unsigned long i = 0; i < rows; i  )
            {
                Data[i] = new type_t[columns];
                for(unsigned long j = 0; j < columns; j  )
                    Data[i][j] = m[i][j];
            }
        }

        ~Matrix()
        {
            for(unsigned long i = 0; i < rows; i  )
                delete [] Data[i];
            delete [] Data;
        }

        void Print()
        {
            for(unsigned long i = 0; i < rows; i  )
            {
                for(unsigned long j = 0; j < columns; j  )
                    std::cout << Data[i][j] << " ";
                std::cout << "\n";
            }
        }

        type_t* operator [] (unsigned long row)
        {
            return Data[row];
        }
};

uj5u.com熱心網友回復：

首先，假設有一個合適的 2D 矩陣類，但不是問題。但我不知道你的 API，所以我會用一些典型的東西來說明：

struct coord {
    size_t x;  // x position or column count
    size_t y;  // y position or row count
};

template <typename T>
class Matrix2D {
       ?  // implementation details
public:
       ?  // all needed special members (ctors dtor, assignment)
    Matrix2D (coord dimensions);

    coord dimensions() const;  // return height and width
    const T& cell (coord position) const;  // read-only access
    T& cell (coord position);  // read-write access
    // handy synonym:
    const T& operator[](coord position) const { return cell(position); }
    T& operator[](coord position) { return cell(position); }
};

我剛剛展示了我需要的公共成員：創建一個具有給定大小的矩陣，查詢大小，以及對各個元素的索引訪問。

因此，鑒于此，您的問題描述是：

template<typename T>
Matrix2D<T> scale_pow2 (const Matrix2D& input, size_t pow)
{
    const auto scale_factor= 1 << pow;
    const auto size_in = input.dimensions();
    Matrix2D<T> result ({size_in.x*scale_factor,size_in.y*scale_factor});
         ? 
         ?  // fill up result
         ? 
    return result;
}

好的，現在問題被精確定義了：什么代碼出現在上面的大空白中？

輸入中的每個單元格都放入輸出中的一組單元格中。因此，您可以遍歷輸入并在輸出中寫入一組具有相同值的單元格，或者您可以遍歷輸出并在輸入中查找您需要其值的每個單元格。

后者更簡單，因為您不需要嵌套回圈（或一對回圈）來撰寫塊。

    for (coord outpos : /* ?? every cell of the output ?? */) {
        coord frompos {
            outpos.x >> pow,
            outpos.y >> pow };
        result[outpos] = input[frompos];
    }

現在這很簡單！
計算從位置給定輸出必須被定義規模的方式匹配：你將不得不pow放棄相對于此叢的位置位，高位將是其中那叢來自的指數

現在，我們要設定outpos輸出矩陣索引中的每個合法位置。這就是我需要的。如何真正做到這一點是另一個子問題，可以通過自上而下的分解來解決。

先進一點

也許嵌套回圈是完成此任務的最簡單方法，但我不會將它們直接放入此代碼中，從而將我的嵌套級別推得更深。回圈 0..max 并不是用沒有庫的裸 C 撰寫的最簡單的事情，所以這只會讓人分心。而且，如果您正在處理矩陣，這是您普遍需要的東西，包括（例如）列印出答案！

所以這里是雙回圈，放入自己的代碼中：

    struct all_positions {
        coord current {0,0};
        coord end;
        all_positions (coord end) : end{end} {}
        bool next() {
            if (  current.x < end.x)  return true; // not reached the end yet
            current.x = 0;  // reset to the start of the row
            if (  current.y < end.y)  return true;
            return false;  // I don't have a valid position now.
            }
    };

這并沒有遵循迭代器/收集API，你可以在基于范圍的使用for回圈。有關如何執行此操作的資訊，請參閱我關于 Code Project 的文章或使用 C 20 標準庫中的 Ranges 內容。

鑒于這個“老式”迭代助手，我可以將回圈撰寫為：

    all_positions scanner {output.dimensions};  // starts at {0,0}
    const auto& outpos= scanner.current;
    do {
           ? 
       } while (scanner.next());

Because of the simple implementation, it starts at {0,0} and advancing it also tests at the same time, and it returns false when it can't advance any more. Thus, you have to declare it (gives the first cell), use it, then advance&test. That is, a test-at-the-end loop. A for loop in C checks the condition before each use, and advances at the end, using different functions. So, making it compatible with the for loop is more work, and surprisingly making it work with the ranged-for is not much more work. Separating out the test and advance the right way is the real work; the rest is just naming conventions.

As long as this is "custom", you can further modify it for your needs. For example, add a flag inside to tell you when the row changed, or that it's the first or last of a row, to make it handy for pretty-printing.

summary

You need a bunch of things working in addition to the little piece of code you actually want to write. Here, it's a usable Matrix class. Very often, it's prompting for input, opening files, handling command-line options, and that kind of stuff. It distracts from the real problem, so get that out of the way first.

Write your code (the real code you came for) in its own function, separate from any other stuff you also need in order to house it. Get it elsewhere if you can; it's not part of the lesson and just serves as a distraction. Worse, it may be "hard" in ways you are not prepared for (or to do well) as it's unrelated to the actual lesson being worked on.

在將演算法（流程圖、偽代碼等）轉換為您正在使用的物件上的合法語法和 API 之前，先以一般方式找出演算法（流程圖、偽代碼等）。如果你只是在學習 C ，當你試圖弄清楚邏輯時不要陷入正式語法的泥潭。在進行這種規劃時，在您自然而然地開始用C 思考之前，不要強迫它。使用白板涂鴉、修補玩具，任何適合您的東西。

在您花時間編碼之前，從您的同行和導師（如果有）那里獲得對想法的反饋和審查，以及如何實作它的邏輯。為什么要寫一個行不通的想法？修復邏輯，而不是代碼。

最后，勾勒出您需要的控制流、函式和資料結構。使用偽代碼和占位符注釋。

然后填寫占位符并用合法的語法替換偽。您已經計劃好了，所以現在您可以專注于學習編程語言的語法和庫細節。您可以專注于“我如何在 C 中表達（一些微小的細節）”，而不是將整個程式留在腦海中。更一般地說，隔離你將要學習的部分；學習/練習一件事而不必擔心整個大廈。

在很大程度上，其中一些想法也轉化為代碼。 自上而下的設計意味著您在高層次上陳述事物，然后在其他地方單獨實施。它使代碼可讀和可維護，并且首先更容易撰寫。函式應該這樣寫：函式解釋如何做（它做了什么）作為一個細節串列，這些細節只是更進一步的一個細節級別。然后，這些步驟中的每一個都成為一個新功能。函式應該是簡短的，并在一個語意抽象層次上表達。 不要深入研究函式中最原始的細節，這些細節將任務解釋為一組更簡單的步驟。

祝你好運，并堅持下去！

標籤：C 数组

上一篇：如何在Python中創建一個非常大的陣列

下一篇：如何撰寫正則運算式模式以匹配php中的以下模式？