绘制台球轨迹，不带容器

Drawing pool table ball trajectory w/o containers

本文关键字：轨迹 绘制      更新时间：2023-10-16

问题的陈述如下：

描述：

编写一个C++程序，读取台球桌的尺寸，并以 45º 的角度在左上角击中桌子后用 0 打印球的轨迹。

输入：

输入由多个事例组成，每个事例都有行数和列数。这两个数字至少是2。

输出：

打印每个台球桌，如示例中所示。

观察：

预期的解决方案不使用向量或类似方法。这包括向量、字符串、数组等。从数学上讲，预期的解决方案在最坏的情况下使用 O（1） 内存。

例：

示例输入：

7 4
10 16

示例输出：

######
#0   #
# 0  #
#  0 #
#   0#
#  0 #
# 0  #
#0   #
######
##################
#0     0     0   #
# 0   0 0   0 0  #
#  0 0   0 0   0 #
#   0     0     0#
#  0 0   0 0   0 #
# 0   0 0   0 0  #
#0     0     0   #
# 0   0 0   0 0  #
#  0 0   0 0   0 #
#   0     0     0#
##################
例如，

如果您可以使用矩阵在每次移动后不断标记球的位置，并遵循其轨迹直到它击中角落，那么这个问题的解决方案将相当容易。但是他们希望你不要使用这样的数据结构（这是一个入门编程课程，只是为了练习），所以这有点困难。

我想到了一个解决方案，可以每行打印输出台球表，跟踪球的位置，但我遇到的主要问题是能够在第二行（10,16）的情况下预测球的位置，当你打印第一行时，你已经需要知道球最终会在与桌子发生一些碰撞后再次到达它两次。

关于如何解决它的任何想法？

int positiveMod(int x, int y)
{
    return ((x % y) + y) % y;
}
int main()
{
    int x,y,sx,sy;
    int startX;
    int minStartX = 0;
    cin >> sy >> sx;
    startX = 0;
    // compute the various start points on x with y=0, keep the smallest to identify the repeating stride
    do
    {
        startX = (startX + 2 * (sy - 1)) % (2 * (sx - 1));
        if ((minStartX == 0) || (startX < minStartX) && (startX != 0))
        {
            minStartX = startX;
        }
    }
    while (startX != 0);

    for(y=0; y < sy; y++)
    {
        for(x=0; x < sx; x++)
        {
            if (
                    (minStartX == 0) && (x == y) || //identity line
                    (minStartX != 0) && positiveMod(x - y, minStartX) == 0 || // top-left quadrant
                    (minStartX != 0) && positiveMod( (2 * (sx - 1) - x) - y, minStartX) == 0 || // mirror against y axis
                    (minStartX != 0) && positiveMod( x - (2 * (sy - 1)) - y, minStartX) == 0 // mirror against x axis
                )
            {
                cout << '0';
            }
            else
            {
                cout << ' ';
            }
        }
        cout << endl;
    }
}

它仍然需要边框，并且需要修复 y>x 的情况。在这种情况下，您可以翻转 x/y 逻辑。从评论中获取的提示。

最简单的方法是预先分配要显示的字符串的缓冲区。也：

  • 一个数组 std：：strings， string[y + some]。
  • 一个二维数组，char[y + some][x + some]。
  • 或一个简单的字符数组，char[（x + some）*（y + some）]。

+一些是边界，"\0"终端等...您可能希望它使用 new 动态分配，以便您可以调整每个表的缓冲区大小。或者只是分配覆盖最大表的较大内容。

然后，用空格填充缓冲区，并在数组中绘制边框。从 （0,0） 开始球，在未完成时迭代，将 '0 放入缓冲区中。完成后，逐行打印整个缓冲区。

Jeffreys 建议的愚蠢实现。计算上很愚蠢，在数学上可能更容易做到这一点，但它回答了这个问题......

bool SimulateBallUntil(int width, int height, int x, int y)
{
    // start off heading down right
    int xInc = 1;
    int yInc = 1;
    // Start off at pos 0,0
    int curX = 0;
    int curY = 0;
    // Run the path...
    for(int iter=0;;++iter)
    {
        // Check if hit point
        if(curX == x && curY == y)
        {
            return true;
        }
        // Check if hit corner (ignoring the first iteration which is the left corner)
        if(iter && ((curY == 0) || (curY == height-1)) && ((curX == 0) || (curX == width-1)))
        {
            return false;
        }
        // Bounce off walls
        if(curX + xInc == width || ((curX + xInc)==-1))
        {
            xInc *= -1;
        }
        if(curY + yInc == height || (curY + yInc==-1))
        {
            yInc *= -1;
        }
        // Move it
        curX += xInc;
        curY += yInc;
    }
}
相关文章：