C++ 如何打印子矩阵？

我想画出这个矩阵：

11 12 13 14  0  0 
0  22 23  0  0  0 
0  0  33 34 35 36 
0  0  0  44 45  0 
0  0  0   0  0 56 
0  0  0   0  0 66 

这样：

11 12
0  22

13 14
23  0

0  0 
0  0 

0  0
0  0 

23  0
33 34

35 36
45  0

0  0
0  0

0  0
0  0

0 56 
0 66

但我不知道该怎么做！ 我可以使用以下方法绘制第一个子块：

 for(auto i=0; i < sz ; i++ )
      {
           for(auto j=0 ; j < sz ; j++)
           {
               {
                  std::cout << dense[i][j] << ' ' ;
               }   
           }
           std::cout << std::endl;
      }   

好吧，很抱歉发了这篇愚蠢的帖子。。我已经解决了

 for(auto w=0; w<= bsz ; w+=2)
     {
      for(auto k=0; k <= bsz ; k+=2)
      {
        for(auto i=w; i < sz+w ; i++ )
        {
           for(auto j=k ; j < sz+k ; j++)
           {
               {
                  std::cout << dense[i][j] << ' ' ;
               }   
           }
           std::cout<< std::endl;
       }
       std::cout << std::endl;
      } 
    }
}

---

没有通过检查吗？

只需在内环体中每四个一组，然后跨2步

for(auto i=0; i < dense.size() ; i+=2 )
{
    for(auto j=0 ; j < dense[i].size() ; j+=2 )
    {
        {
            std::cout << dense[i  ][j  ] << ' ' ;
            std::cout << dense[i  ][j+1] << ' ' ;
            std::cout << std::endl;
            std::cout << dense[i+1][j  ] << ' ' ;
            std::cout << dense[i+1][j+1] << ' ' ;
            std::cout << std::endl;
        }   
    }
}

for（自动i=0；istd：：cout只需在内环的身体上做四个一组的动作，然后迈2步

for(auto i=0; i < dense.size() ; i+=2 )
{
    for(auto j=0 ; j < dense[i].size() ; j+=2 )
    {
        {
            std::cout << dense[i  ][j  ] << ' ' ;
            std::cout << dense[i  ][j+1] << ' ' ;
            std::cout << std::endl;
            std::cout << dense[i+1][j  ] << ' ' ;
            std::cout << dense[i+1][j+1] << ' ' ;
            std::cout << std::endl;
        }   
    }
}

for（自动i=0；istd:：cout您可以通过使用块大小的倍数作为索引，以一种非常类似的方式进行操作：

#include <iostream>
#include <vector>

// print the (i,j)-th block
template <typename T>
void print_block(const std::vector<std::vector<T>>& dense, std::size_t block_size, std::size_t i, std::size_t j) {   
   for(std::size_t m = i * block_size; m < block_size * (i + 1); ++m) {
      for(std::size_t n = j * block_size; n < block_size * (j + 1); ++n)
         std::cout << dense[m][n] << ' ';
      std::cout << '\n';
   }
}

int main() {
    std::vector<std::vector<double>> dense = { 
        { 1, 2, 3, 4 },
        { 0, 4, 3, 2 },
        { 4, 2, 1, 1 },
        { 9, 0, 8, 1 }
    };
    const std::size_t block_size = 2;

    for(std::size_t i = 0; i < dense.size() / block_size; ++i)
        for(std::size_t j = 0; j < dense[i].size() / block_size; ++j) {
            print_block(dense, block_size, i, j);
            std::cout << '\n';
        }
}

#包括
#包括
//打印（i，j）-th块
模板
无效打印块（常数std:：vector&density，std:：size\u t块大小，std:：size\u t i，std:：size\u t j）{
对于（std:：size\u t m=i*block\u size；mstd:：cout您可以通过使用块大小的倍数作为索引，以一种非常类似的方式进行操作：

#include <iostream>
#include <vector>

// print the (i,j)-th block
template <typename T>
void print_block(const std::vector<std::vector<T>>& dense, std::size_t block_size, std::size_t i, std::size_t j) {   
   for(std::size_t m = i * block_size; m < block_size * (i + 1); ++m) {
      for(std::size_t n = j * block_size; n < block_size * (j + 1); ++n)
         std::cout << dense[m][n] << ' ';
      std::cout << '\n';
   }
}

int main() {
    std::vector<std::vector<double>> dense = { 
        { 1, 2, 3, 4 },
        { 0, 4, 3, 2 },
        { 4, 2, 1, 1 },
        { 9, 0, 8, 1 }
    };
    const std::size_t block_size = 2;

    for(std::size_t i = 0; i < dense.size() / block_size; ++i)
        for(std::size_t j = 0; j < dense[i].size() / block_size; ++j) {
            print_block(dense, block_size, i, j);
            std::cout << '\n';
        }
}

#包括
#包括
//打印（i，j）-th块
模板
无效打印块（常数std:：vector&density，std:：size\u t块大小，std:：size\u t i，std:：size\u t j）{
对于（std:：size\u t m=i*block\u size；mstd:：cout首先为自己定义一个参考点。在这里，偶数行和偶数列都可以作为参考点。然后，使用额外的数组打印您需要的任何图案。这样，只需更改图案值，您就可以输出任何形状，而不仅仅是块

int pattern[2][4] = {
{0, +1, 0, +1},
{0, 0, +1, +1}
};

for(int i = 0; i < sz; i+=2){
    for(int j = 0; j < sz; j+=2){
        for(int k = 0; k < 4; k++){//size of pattern
            int new_i = i + pattern[0][k];
            int new_j = j + pattern[1][k];

            if(new_i >= sz || new_j >= sz)
                break;
            std::cout << arr[new_i][new_j] << " ";
            if(k == 1) std::cout << std::endl;
        }
        std::cout << std::endl;
    }
}

int模式[2][4]={
{0, +1, 0, +1},
{0, 0, +1, +1}
};
对于（int i=0；i=sz | new_j>=sz）
打破
std:：cout首先为自己定义一个参考点。在这里，偶数行和偶数列都可以作为参考点。然后，使用额外的数组打印您需要的任何图案。这样，只需更改图案值，您就可以输出任何形状，而不仅仅是块

int pattern[2][4] = {
{0, +1, 0, +1},
{0, 0, +1, +1}
};

for(int i = 0; i < sz; i+=2){
    for(int j = 0; j < sz; j+=2){
        for(int k = 0; k < 4; k++){//size of pattern
            int new_i = i + pattern[0][k];
            int new_j = j + pattern[1][k];

            if(new_i >= sz || new_j >= sz)
                break;
            std::cout << arr[new_i][new_j] << " ";
            if(k == 1) std::cout << std::endl;
        }
        std::cout << std::endl;
    }
}

int模式[2][4]={
{0, +1, 0, +1},
{0, 0, +1, +1}
};
对于（int i=0；i=sz | new_j>=sz）
打破
std：：你自己想得很好。：-）你自己想得很好。：-）不@Jodocus！你的方式非常有趣。。但是有一些错误！检查我在代码末尾写的东西！@Drudoxlebowsky这是一个与你原来的问题完全不同的问题。我无法复制你的错误，我的代码会产生错误ght结果：不@Jodocus！你的方法非常有趣..但是有一些错误！检查我在代码末尾写的东西！@Drudoxlebowsky这是一个与你原来的问题完全不同的问题。我无法重现你的错误，我的代码产生了正确的结果：
#include <iostream>
#include <vector>

// print the (i,j)-th block
template <typename T>
void print_block(const std::vector<std::vector<T>>& dense, std::size_t block_size, std::size_t i, std::size_t j) {   
   for(std::size_t m = i * block_size; m < block_size * (i + 1); ++m) {
      for(std::size_t n = j * block_size; n < block_size * (j + 1); ++n)
         std::cout << dense[m][n] << ' ';
      std::cout << '\n';
   }
}

int main() {
    std::vector<std::vector<double>> dense = { 
        { 1, 2, 3, 4 },
        { 0, 4, 3, 2 },
        { 4, 2, 1, 1 },
        { 9, 0, 8, 1 }
    };
    const std::size_t block_size = 2;

    for(std::size_t i = 0; i < dense.size() / block_size; ++i)
        for(std::size_t j = 0; j < dense[i].size() / block_size; ++j) {
            print_block(dense, block_size, i, j);
            std::cout << '\n';
        }
}

int pattern[2][4] = {
{0, +1, 0, +1},
{0, 0, +1, +1}
};

for(int i = 0; i < sz; i+=2){
    for(int j = 0; j < sz; j+=2){
        for(int k = 0; k < 4; k++){//size of pattern
            int new_i = i + pattern[0][k];
            int new_j = j + pattern[1][k];

            if(new_i >= sz || new_j >= sz)
                break;
            std::cout << arr[new_i][new_j] << " ";
            if(k == 1) std::cout << std::endl;
        }
        std::cout << std::endl;
    }
}