C 数学运算顺序

我一直在做一项任务。我的代码似乎有正确的数学运算和正确的顺序（至少是顺序），但我的答案有点古怪。根据我的输入值，每个问题的部分都是正确的，但输入值改变时，同一部分永远不会正确。是不是我遗漏了一些关于C操作顺序的东西导致了这种情况

我觉得问题就在这里

intPeople = intCarCounter * intTrainCounter * CAR_CAPACITY;

对于样本运行#3，我在前两次输入中得到了120人（比正确答案多20人），剩余人数是样本运行#4中应该出现的人数。在第三次输入时，我得到了112人，这也是样本运行4的正确答案。最后，在样本运行4中，我得到了128人（比正确答案多16人），剩余人数是样本运行3中应该出现的人数。有什么想法吗

任务：

我的代码：

#include <stdio.h>
#include <stdlib.h>
#define FIRST_CAR_LENGTH 10
#define NORMAL_CAR_LENGTH 8
#define CAR_CAPACITY 4

int main(void)
{
    /* Initialize Variables */
    int intTrack,intMaxTrainSize,intActualTrainSize,intPeople,intCarCounter,intTrainCounter,n;

    /* Ask user for value of N */
    printf("What is the value for N?> ");
    scanf("%d",&n);
    for (int i=0; i<n;i++)
    {
        /* Ask user for total length of track */
        printf("\nWhat is the total length of the track, in feet?> ");
        scanf("%d",&intTrack);

        /* Ask user for maximum length of each train */
        printf("What is the maximum length of a train, in feet?> ");
        scanf("%d",&intMaxTrainSize);

        /* Set/Reset initial values of intActualTrainSize, intCarCounter and intTrainCounter */
        /* Each train will begin with FIRST_CAR_LENGTH -> intActualTrainSize=FIRST_CAR_LENGTH */
        /* Each train will begin with 1 car -> intCarCounter=1 */
        /* Train counter will begin at 0 -> intTrainCounter=0 */
        intActualTrainSize=FIRST_CAR_LENGTH;
        intCarCounter=1;
        intTrainCounter=0;

        /* Continue to add additional cars using NORMAL_CAR_LENGTH until the maximum train size has been reached */
        /* Count how many NORMAL_CAR_LENGTH cars are added -> intCarCounter++*/
        while (intActualTrainSize < intMaxTrainSize)
        {
            intActualTrainSize=intActualTrainSize+NORMAL_CAR_LENGTH;
            intCarCounter++;
        } 

        /* Count how many trains can be added until 25% of the track is used up -> intTrainCounter++ */
        while (intTrainCounter*intActualTrainSize < (int)(intTrack*.25)) 
        {
            intTrainCounter++;
        }

        /* Count how many people can be on the track at one time -> intPeople = intCarCounter * intTrainCounter * CAR_CAPACITY */
        intPeople = intCarCounter * intTrainCounter * CAR_CAPACITY;
        printf("\nYour ride can have at most %d people on it at one time.",intPeople);

        if (intActualTrainSize>intMaxTrainSize)
            printf("\nMaximum Train Length has surplus of %d feet.\n",intActualTrainSize-intMaxTrainSize);
        else if (intMaxTrainSize==intActualTrainSize)
            printf("\nMaximum Length fits exactly.\n");
    }
    system("pause");
    return 0;
}

#包括
#包括
#定义首车长度10
#定义正常车辆长度8
#定义车辆容量4
内部主（空）
{
/*初始化变量*/
int intTrack、intMaxTrainSize、intActualTrainSize、intPeople、INTCARCATER、intTrainCounter、n；
/*向用户询问N的值*/
printf（“N的值是多少？>”；
scanf（“%d”和“&n”）；
对于（int i=0；i intActualTrainSize=首车长度）*/
/*每列列车将以1节车厢开始->INTCARTER=1*/
/*列车计数器将从0开始->intTrainCounter=0*/
intActualTrainSize=第一辆车长度；
intCarCounter=1；
intTrainCounter=0；
/*继续使用正常轿厢长度添加额外轿厢，直到达到最大列车尺寸*/
/*计算添加的正常车长车数->intCarCounter++*/
while（intActualTrainSizeintTrainCounter++*/
而（intTrainCounter*intActualTrainSize<（int）（intTrack*.25））
{
intTrainCounter++；
}
/*计算一次可在轨道上的人数->intPeople=intCarCounter*intTrainCounter*车辆容量*/
intPeople=intCarCounter*intTrainCounter*车辆容量；
printf（“\n您的座驾一次最多可容纳%d人。”，intPeople）；
如果（intActualTrainSize>intMaxTrainSize）
printf（“\n最大列车长度剩余%d英尺。\n”，intActualTrainSize intMaxTrainSize）；
else if（intMaxTrainSize==intActualTrainSize）
printf（“\n最大长度正好合适。\n”）；
}
系统（“暂停”）；
返回0；
}

不确定它是否直接起作用，但您需要重新检查以下内容

while (intActualTrainSize +NORMAL_CAR_LENGTH  <= intMaxTrainSize )
{                         ^^^^^^^^^^^^^^^^^^    
    intActualTrainSize=intActualTrainSize+NORMAL_CAR_LENGTH;
    intCarCounter++;
} 

---

while（intActualTrainSize+正常车厢长度您的列车在上面写着

    while (intActualTrainSize < intMaxTrainSize)
    {
        intActualTrainSize=intActualTrainSize+NORMAL_CAR_LENGTH;
        intCarCounter++;
    } 

while（intActualTrainSize

由于您将执行此循环直到列车太长…
您使用了一个循环来计算列车计数器和车辆计数器，作为另一种选择，您可以使用整数算法来计算这些值。我附上了我的解决方案，它不涉及循环。这使调试更容易。我提供了两个版本。版本1 sassumes整数除法不进行四舍五入。版本2更安全，因为它在除法之前减去余数

    //VERSION 1:

    #include <stdio.h>

    #define FIRST_CAR_LENGTH 10
    #define NORMAL_CAR_LENGTH 8
    #define CAR_CAPACITY 4

    int main(void)
    {
      int N, i;
      int trackSize;
      int trainSize;
      int numberPeople;
      int numberCars;
      int trainsPerTrack;
      int surplus;

      printf("What is the value for N?");
      scanf("%d", &N);
      for(i=0; i < N; i++)
      {
         printf("What is the total length of the track, in feet?\n");
         scanf("%d", &trackSize);
         printf("What is the maximum length of a train, in feet?\n");
         scanf("%d", &trainSize);
         trainsPerTrack = trackSize / (4 * trainSize);
         numberCars = (trainSize -FIRST_CAR_LENGTH) / NORMAL_CAR_LENGTH + 1;

         numberPeople = trainsPerTrack * numberCars * CAR_CAPACITY;
         printf("Your ride can have at most %d people on it at one time.\n", numberPeople);

         surplus = (trainSize - FIRST_CAR_LENGTH) % NORMAL_CAR_LENGTH;
         if(surplus)
           printf("Maximum Train Length has surplus of %d feet\n\n", surplus);
         else
           printf("Maximum Length fits exactly\n\n");
      }
      return 0;
    }


VERSION 2:
#include <stdio.h>

#define FIRST_CAR_LENGTH 10
#define NORMAL_CAR_LENGTH 8
#define CAR_CAPACITY 4

int main(void)
{
  int N, i;
  int trackSize;
  int trainSize;
  int numberPeople;
  int numberCars;
  int trainsPerTrack;
  int surplus;

  printf("What is the value for N?");
  scanf("%d", &N);
  for(i=0; i < N; i++)
  {
     printf("What is the total length of the track, in feet?\n");
     scanf("%d", &trackSize);
     printf("What is the maximum length of a train, in feet?\n");
     scanf("%d", &trainSize);
     trainsPerTrack = (trackSize- (trackSize % (4*trainSize))) / (4 * trainSize);
     int forSmallerCars = trainSize - FIRST_CAR_LENGTH;
     numberCars = (forSmallerCars - (forSmallerCars % NORMAL_CAR_LENGTH)) / NORMAL_CAR_LENGTH + 1;

     numberPeople = trainsPerTrack * numberCars * CAR_CAPACITY;
     printf("Your ride can have at most %d people on it at one time.\n", numberPeople);

     surplus = (trainSize - FIRST_CAR_LENGTH) % NORMAL_CAR_LENGTH;
     if(surplus)
       printf("Maximum Train Length has surplus of %d feet\n\n", surplus);
     else
       printf("Maximum Length fits exactly\n\n");
  }
  return 0;
}

//第1版：
#包括
#定义首车长度10
#定义正常车辆长度8
#定义车辆容量4
内部主（空）
{
int N，i；
int轨道尺寸；
int列车尺寸；
整数人；
整数；
int trainsPerTrack；
国际贸易顺差；
printf（“N的值是多少？”）；
scanf（“%d”和“&N”）；
对于（i=0；i
输入变量名，不建议使用单字符变量名。使用固定值递增循环中的计数器是不可取的
const double occ = 0.25;

int track;
int max_train;

int cap;
int num_car;
int num_train = 0;
int train = 0;

printf( "Length of track? "); scanf( "%d", &track );
printf( "Max length of train? "); scanf( "%d", &max_train );

num_car = std::max( 0, max_train - FIRST_CAR_LENGTH + NORMAL_CAR_LENGTH ) / NORMAL_CAR_LENGTH;
if( 0 < num_car )
{
    train = FIRST_CAR_LENGTH + NORMAL_CAR_LENGTH * ( num_car - 1 );
    num_train = ( int ) ( occ * track ) / train;
}
cap = CAR_CAPACITY * num_car * num_train;
printf( "Capacity: %d; Train surplus: %d\n", cap, max_train - train );