墙壁破坏

Question

有数字墙建造。 0意味着有一个洞，块不能坐在孔上。有人拥有一把特殊的枪，可以一次射出所有的数字。
所以我有一个名为墙的矩阵，必须写一把枪。我写了这个程序，但是我有一个问题，我不明白为什么会发生。在我的代码

#include <iostream> 
#include <cstdio> 

using namespace std; 

int createWall(int &height, int &length, int wall[][ 100 ], int shots) 
{ 
    int i; 
    int j; 
    cin >> height; 
    cin >> length; 
    cin >> shots; 
    for (i = 0; i < height; i++) 
    { 
     for (j = 0; j < length; j++) 
     { 
      cin >> wall[ i ][ j ]; 
     } 
    } 
    return shots; 
} 


void wallNow(int height, int length, int wall[][ 100 ]) 
{ 
    int i; 
    int j; 
    for (i = 0; i < height; i++) 
    { 
     for (j = 0; j < length; j++) 
     { 
      cout << wall[ i ][ j ] << " "; 
     } 
     cout << "\n"; 
    } 
} 

void destroyWall(int height, int length, int wall[][100], int shots) 
{ 
    int i; 
    int j; 
    int k; 
    int x; 
    int aimedBlocks;//number to be "destroyed" 
    //set all aimedBlocks to 0 
    for (x = 0; x < shots; x++) 
    { 
     cin >> aimedBlocks; 
     for (i = 0; i < height; i++) 
     { 
      for (k = 0; k < length; k++) 
      { 
       if (wall[ i ][ k ] == aimedBlocks) 
       { 
        wall[ i ][ k ] = 0; 
       } 
      } 
     } 
    } 

    int counter;//I use this variable because at some point I have a 0 followed only by 0's 
    for (i = 0; i < length; i++) 
    { 
     j = height - 1; 
     counter = 0; 
     //if I find a 0 then I move all elements higher that it one step down 
     while (counter < height) 
     { 
      if (wall[ j ][ i ] == 0) 
      { 
       for (k = j; k > 0; k--) 
       { 
        wall[ k ][ i ] = wall[ k - 1 ][ i ]; 
       } 
       wall[ height - j - 1 ][ i ] = 0; 
      } 
      else 
       j--;//I don't always go up ene step because the "block" droped in place of 0 may be 0 
      counter++; 
     } 
    } 
} 

int main() 
{ 
    int height; 
    int length; 
    int wall[ 100 ][ 100 ]; 
    int shots = 0; 
    shots = createWall(height, length, wall, shots); 
    destroyWall(height, length, wall, shots); 
    wallNow(height, length, wall); 
} 

我真的不明白，为什么线wall[ height - j - 1 ][ i ] = 0;在下面的例子正在为前4列，它不为最后一个工作。

格式输入：

height length shots 
wall_0_0 ... wall_0_length 
... ... ... 
wall_height ... wall_height_length 
shot_0 ... shot_shots 

输入：

4 5 3 
3 5 4 5 1 
2 1 1 5 3 
1 1 5 5 1 
5 5 1 4 3 
1 5 1 

删除与1，5，1匹配所有值。墙仍然必须落入底部。

输出：

0 0 0 0 0 
0 0 0 0 0 
3 0 0 0 0 
2 0 4 4 3 

预计：

0 0 0 0 0 
0 0 0 0 0 
3 0 0 0 3 
2 0 4 4 3 

请帮我解决这个问题。我找不到它调试代码。

Answer 1

你的算法很奇怪，我不明白你想做什么。

实现您的目的的一种简单方法是从墙的左侧到右侧迭代，然后从底部到顶部迭代。每次获得0时，您都会在顶部搜索非零值，并在发现它们时交换它们。

例（非常基本可以改善）：

for (size_t i = 0; i < length; i++) { // i is for iterate from left(0) to right(length - 1) 
    size_t j = height; // j is for iterate from bot(height - 1) to top(0) 
    while (j-- > 0) { 
    if (wall[j][i] == 0) { 
     size_t k = j; // k is for found a non zero value from j - 1 to the top(0) 
     while (k-- > 0) { 
     if (wall[k][i] != 0) { 
      wall[j][i] = wall[k][i]; 
      wall[k][i] = 0; 
      break; 
     } 
     } 
    } 
    } 
} 

注：

1. 我用size_t，因为这是指数的类型。
2. 我建议您切换为std::vector并在C++中使用迭代器。