我不明白我的程序出了什么问题

Question

this is a programming question and it doesn't give right answer to all cases

you are playing a video game in which several stacks of boxes are lined up on the floor, with a crane on top to rearrange the boxes

The crane supports the following commands:

• Move one position left (does nothing if already at the leftmost position)

• Move one position right (does nothing if already at the rightmost position)

• Pick up a box from the current stack (does nothing if the crane already has a box)

• Drop a box on the current stack (does nothing if the crane doesn't already have a box)

Further, there is a limit H on the number of boxes on each stack. If a 'drop' command would result in a stack having more than H boxes, the crane ignores this drop command. If the current stack has no boxes, a 'pick up' command is ignored.

You are given the initial number of boxes in each stack and the sequence of operations performed by the crane. You have to compute the final number of boxes in each stack.

Input format • Line 1 : The width of the game (the number of stacks of boxes), N, followed by the max height H of each stack.

• Line 2 : N integers, the initial number of boxes in each stack, from left to right. Each number is ≤ H.

• Line 3 : A sequence of integers, each encoding a command to the crane.

The commands are encoded as follows:

1 : Move left

2 : Move right

3 : Pick up box

4 : Drop box

0 : Quit

• The command Quit (0) appears exactly once, and is the last command.

• The initial position of the crane is above the leftmost stack, with the crane not holding any box.

#include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
using namespace std;
int main()
{
    long long x, y, t;
    cin >> x >> y;
    cout << endl;
    vector<long long> stack(x);
    for (long long i = 0; i < x; i++)
    {
        cin >> stack[i];
    }
    cout << endl;
    vector<long long>::pointer ptr = &stack[0];
    while (cin >> t)
    {
        if (t == 1)
        {
            if (ptr != &stack[0])
                ptr--;

        }
        if (t == 2)
        {
            if (ptr != &stack[x - 1])
                ptr++;
        }
        if (t == 3)
        {
            if (*ptr != 0)
                *ptr = *ptr - 1;
        }
        if (t == 4)
        {
            if (*ptr < y)
                *ptr = *ptr + 1;
        }
        if (t == 0)
            break;
    }
    cout << endl;
    for (long long i = 0; i < x; i++)
    {
        cout << stack[i];
    }
    return 0;
}

Answer 1

There are multiple things wrong with the program:

• The program does not check if the crane is holding a box when picking up or dropping. This is what is causing the unexpected output.

• The program puts all logic in a single function ( main ), which makes it more difficult to follow the program logic.

• The program uses a pointer to the stack where the crane is over, instead of simply using an index to the position. This also makes the logic more difficult to read.

• The program uses a sequence of if statements instead of a single switch statement, which again obscures the logic.

• The program uses variable names x and y , which are not descriptive of their function, again making the program more difficult to follow. Instead use numberOfStacks and maxHeight or something like that, or at least N and H to relate to the problem description.

All but the first point are maybe "small" things, it's a short program and not difficult to read, but it would be easier if you follow this advice, making it easier to spot bugs (and figure out the first point).

---

An example using the position instead of a pointer, using a switch statement, and separating into its own function:

void processCommands(vector<std::size_t>& stack, std::size_t maxHeight) {
   std::size_t position = 0;
   bool holdingBox = false;
   while (cin >> t) {
      switch (t) {
      case 1:
         if (position != 0)
            --position;
         break;
      case 2:
         if (position != stack.size() - 1)
            ++position;
         break;
      case 3:
         if (!holdingBox && stack[position] != 0) {
            --stack[position];
            holdingBox = true;
         }
         break;
      case 4:
         if (holdingBox && stack[position] != maxHeight) {
            ++stack[position];
            holdingBox = false;
         }
         break;
      case 0:
         return; // Exits current function, return to main where stack is printed
      }
   }
}

(I have also replaced long long for std::size_t , which I think better represents the function of those values (sizes of arrays and sizes of stacks). std::size_t is an unsigned long long on 64-bit machines. Maybe unsigned int would be good enough.

Main could look like this:

int main() {
   vector<std::size_t> stack;
   std::size_t maxHeight = initializeStack(stack);
   processCommands(stack, maxHeight);
   printStack(stack);
}