求一道C程序设计题的做法？请高手帮忙

为了简化起见，我的第一串代码的输出格式是输出了A、B、C的饭量。望见谅！

x、y、z分别表示A、B、C的饭量

A说：x<y,x=z

B说：x>y,x>z

C说：y<z,x<y

这道题的意思就是，三个人桐谈凯每个人都给出了两个命题。饭量大的给的命题错误多，又由于饭量不相等，所以，对应的给出的命题的正确个数也不相同。他们三个中有一个人给出了两个错误的命题，还有一个人给出了一个错误的和一个正确的，剩余的一个给出了两个错误的命题。显然，由于饭量不能相等，所以A说的“x=z”显然是错的。也就是说，A说的两个命题至少有一个错的。如果用x、y、z分别表示A、B、C的饭量的话，A的饭量可能是1或者2（0表示饭量最小，1表示饭量适中，2表示饭量最大），B、C的饭量则不能立即确定。

★代码一及注释▲

#include<stdio.h>

void main()

{

 int x,y,z/*x、y、z分别表示A、B、C可能的饭量*/

 int a,b,c/*a、b、c分别表示经过判断后得出的A、B、C实际的饭量*/

 for(x=1x<=2x++)/*穷举x、y、z的所有可能取值情况*/

  for(y=0y<=2y++)

   for(z=0z<=2z++)

    if(x!=y&&x!=z&&y!=z)/*三个人的饭量不相等，这个if语句排除饭量相等的情况*/

    {

     a=b=c=2/*初始化为2，下面如果某个人的命题是正确的，其饭量将减去1*/

     if(x<y)

     {

      a--

      c--

     }

     else 

      b--

     if(x>z)

      b--

     if(y<z)

      c--

     if(a!=b&&b!=c&&c!=a)

      printf("A、B、C的饭量分别为：%d、%d、%d。\n",a,b,c)/*得出实际饭量，实际饭量不相等*/

    }    

}

执行结果：A、B、C的饭量分别为：2、0、1。

★代码二●

#include<stdio.h>

void main()

{

 int x,y,z/*x、y、z分别表示A、B、C可能的饭量*/

 int a,b,c/*a、b、c分别表示经过判断后得出的A、B、C实际的饭量*/

 for(x=1x<=2x++)/*穷举x、y、z的所有可能取值情况*/

  for(y=0y<=2y++)

   for(z=0z<=2z++)

    if(x!=y&&x!=z&&y!=z)/*三个人的饭量不相等，这个if语句排除饭量相等的情况*/

    {

     a=b=c=2/*初始化为2，下面如果某个人的命题是正确的，其饭量将减去1*/

     if(x<y)

     {

      a--

      c--

     }

     else 

      b--

     if(x>z)

      b--

     if(y<z)

      c--

     if(a!=b&&b!=c&&c!=a)

     {

      if(a==2)

      {

       printf("饭量最大的是：A\n")

       if(b==0)

        printf("饭量最小的是：B\n")

       else

        printf("饭量最小的是：C\n")

      }

      else if(b==2)

      {

       printf("饭量最大的是：B\n")

       if(a==0)

        侍磨printf("饭量最小的是：A\n")

    局唤   else

        printf("饭量最小的是：C\n")

      }

      else

      {

       printf("饭量最大的是：C\n")

       if(a==0)

        printf("饭量最小的是：A\n")

       else

        printf("饭量最小的是：B\n")

      }

     }

    }    

}

一、命题原则

全国计算机等级考试大纲明确规定：二级C语言考试由“二级公共基础知识”和“二级C语言程序设计”两大部分组成，考试内容严格按照“宽口径、厚基础”的原则设计，主要考核我们对该学科的基础理论、基本知识和基本技能的掌握程度，以及运用所学理论和知识解决实际问题的能力。

二、考试要求

根据命题原则，大纲对我们如何复习应试也提出了相应的要求。主要强调了两个方面：

一是 强调我们对基本概念、基本理论和和拿基本知识点的掌握

二是 强调我们综合运用所学知识进行实际应用到程序编写中的能力。

也就是说，我们要想通过二级C语言考试，不仅要熟练地掌握该学科的基本理论知识和 *** 作技能，还要具有较强的分析与解决实际问题的能力，真正做到学以致用。应做到以下两点：

1.学好基础知识

这里所说的基础知识是指C语言中基本概念、基本原理和规定关键字、基本结构等基本知识点。二级C语言考试中，概念性的知识点比较多。我们对这些基础知识要用心理解、记忆。这一类型题目一般都是考察教材中的概念，如果这样简单的题目都丢分，那就实在可惜。

2.掌握 *** 作技能和综合运用能力

二级C语言考试注重对程序设计实际 *** 作能力的考察，要求我们运用所学理论知识和 *** 作技能解决实际问题。二级C语言考试考核的主要内容就是程序设计的基本 *** 作和把所学理论知识和 *** 作技能综合起来，并能在实际应用中加强对这些知识的熟练掌握。

三、应试对策

我们在备考时，要针对考试大纲和考试要求进行复习，主要应注意以下几个方面：

1.牢固、清晰地掌握基本知识

二级C语言考试的重点是基本知识的掌握情况和实际编程应用，但其前提条件是对基本知识点的掌握。因此，我们正确地理解、熟记基本概念和原理是通过考试的前提条件。那么我们要如何才能做到这一点呢?我们可以通过以下3方面来实现：

① 在考前冲刺阶段要注意“比较总结”学习成果，特别是对一些关系复杂的知识点，通过比较、总结更容易理解、牢记。“比较总结”是一烂衡个好的学习方法，同时也是一个好的增强记忆方法，在C语言中有些问题只有通过综合比较、总结才容易在脑海中留下牢固的印烙

② 理解概念要准确，尤其是一些容易混淆、重要的概念，一定要在考前冲刺阶段准确地掌握它们之间在 *** 作步骤和实现功能上的细微区别，一定不能忽视

③ 通过联想记忆各考点，在C语言中有一部分考点不是孤立的，而是相互联系的，我们要能通过一个考点联想到与他相关的考点、这样就能扩大记忆了。

2.选择的习题要有针对性，切不可进行“题海战术”

现在关于二级C语言考试的习题很多，搞题海战术肯定是不行的。我们应根据考试大纲，在考前冲刺阶段适当地做一些与二级C语言考试题型相同饥棚做的题，我们可以做些试卷和历年试题(最近2~3年即可)。研究历年考试题型、分析现在考试形式是通过考试的一个重要法宝，这做可使我们较快地掌握考试题型，从而在最短的时间内达到的学习效果。

注意：根据分析这些年来考试的情况，每年都会有少数新的考点出现，所以在研究历年考题时，不要忽视了一些以往没有考过的知识点，应适当理解记忆。

3.上机实践笔试中程序设计类题目

学习笔试中程序设计类的题目方法是上机 *** 作，验证自己的解题思路和做题结果。通过在计算机上验证这类题，可以发现错误和纠正解题思路，加深我们的记忆。

A-Z + is OR * is AND _ is → # is⊕(圆圈里加个+) @ is ⊙

$ is ↑ 命题的"与友桐敏非" 运算( "与非门" )

% is ↓ 命题的"或非"运算( "或非门" )

Input the source formula:

A*!S+R

Here!

8countTerms

NORMALc: (A*!S*!R)+(!A*!S*R)+(A*!S*R)+(!A*S*R)+(A*S*R)

NORMALd (A+S+R)*(A+!S+R)*(!A+!S+R)

!A+S*!R

Input the source formula:

(!A+B)_R

Here!

8countTerms

NORMALc: (!A*!B*!R)+(A*!B*!R)+(!A*B*!R)+(A*B*!R)+(!A*!B*R)+(!A*B*R)+(A*B*R)

NORMALd (!A+B+!R)

Error!

Input the source formula:

A#B

Here!

4countTerms

NORMALc: (A*!B)+(!A*B)

NORMALd (A+B)*(!A+!B)

Error!

Input the source formula:

A@B

Here!

4countTerms

NORMALc: (!A*!B)+(A*B)

NORMALd (!A+B)*(A+!B)

Error!

#include <string>

#include <stack>

#include <vector>好枝

#include<iostream>

using namespace std

class formulaBase

{

private:

int numVar//The number of the variables in the formula

bool variables[100]//To store the value of the variables

string sourceFormula

string normalCFormula

string normalDFormula

string dualFormula

vector<轮逗char>vctofVar

vector<char>vctofPoland

stack<char>stk

bool isVar(char ch)const

void addMin(int minterm)

void addMax(int maxterm)

bool compute(int minterm)

void getInversePoland()

int countTerms(int n)

void assign(int minterm)

stack<bool>boolStk

public:

formulaBase()

formulaBase(const formulaBase&rhs)

~formulaBase()

void getSource()

string generateNormalC()

string generateNormalD()

string getDual()

void printSource()const{cout<<sourceFormula<<endl}

void printDNormal()const{cout<<normalDFormula<<endl}

void printCNormal()const{cout<<normalCFormula<<endl}

void printDual()const{cout<<dualFormula<<endl}

//void printTruthTable()

}

formulaBase::formulaBase()

{

for(int i=0i<100i++)variables[i]=false

numVar=0

}

formulaBase::formulaBase(const formulaBase&rhs)

{

sourceFormula=rhs.sourceFormula

for(int i=0i<100i++)variables[i]=false

numVar=0

}

formulaBase::~formulaBase()

{

while(!stk.empty())stk.pop()

vctofVar.clear()

vctofPoland.clear()

}

int formulaBase::countTerms(int n)

{

if(n==0)

{

cout<<"invalid input!"<<endl

exit(0)

}

switch(n)

{

case 1:return 2

case 2:return 4

default:

{

int tempA=2,tempB=2

for(int i=2i<=ni*=2)tempA*=tempA

i/=2

if(i==n)return tempA

i=n-i

for(int j=2j<=ij*=2)tempB*=tempB

for(j/=2j<ij++)tempB*=2

tempB*=tempA

return tempB

}

}

}

bool formulaBase::isVar(char ch)const

{

if (ch>='A'&&ch<='Z')

return true

return false

}

void formulaBase::getSource()

{

cout<<"Input the source formula:"<<endl

cin>>sourceFormula

/*if(!isValid(sourceFormula))

cout<<"Invalid input !"

"Operate again:"<<endl

cin>>sourceFormula*/

}

void formulaBase::getInversePoland()

{

char temp,temp1

for(int i=0sourceFormula[i]!='\0'i++)

{

temp=sourceFormula[i]

if(isVar(temp))

{

if(!variables[temp])

{

numVar++

vctofVar.push_back(temp)

variables[temp]=true

}

vctofPoland.push_back(temp)

}

else

switch(temp)

{

case'_':case'$': //

case'%':case'#':

case'@':

while(!stk.empty())

{

if(stk.top()==temp)

{

vctofPoland.push_back(temp)

stk.pop()

}

else break

}

stk.push(temp)

break

case '(':case '!':

stk.push(temp)

break

case '+':

while (!stk.empty())

{

if(stk.top()!='(')

{

temp1=stk.top()

vctofPoland.push_back(temp1)

stk.pop()

}

else break

}

stk.push(temp)

break

case '*':

while (!stk.empty())

{

temp1=stk.top()

if(stk.top()=='*'||stk.top()=='!')

{

vctofPoland.push_back(temp1)

stk.pop()

}

else

break

}

stk.push(temp)

break

case ')':

while (!stk.empty())

{

if(stk.top()!='(')

{

temp1=stk.top()

vctofPoland.push_back(temp1)

stk.pop()

}

else break

}

if(stk.empty())exit(0)

stk.pop()//pop the operator '('

break

}

}

while(!stk.empty())

{

temp1=stk.top()

vctofPoland.push_back(temp1)

stk.pop()

}

}

void formulaBase::assign(int minterm)

{

int temp=minterm

vector<char>::const_iterator itr=vctofVar.begin()

for(itr!=vctofVar.end()itr++)

{

variables[*itr]=bool(temp&1)

temp=temp>>1

}

}

bool formulaBase::compute(int minterm)

{

assign(minterm)

char temp

bool valueA,valueB

vector<char>::const_iterator itr=vctofPoland.begin()

while (itr!=vctofPoland.end())

{

temp=*itr

if(isVar(temp))boolStk.push(variables[temp])

else

switch(temp)

{

case '+':

{

if(boolStk.size()<2)exit(0)

valueA=boolStk.top()

boolStk.pop()

valueB=boolStk.top()

boolStk.pop()

valueA=valueA||valueB

boolStk.push(valueA)

}

break

case '*':

{

if(boolStk.size()<2)exit(0)

valueA=boolStk.top()

boolStk.pop()

valueB=boolStk.top()

boolStk.pop()

valueA=valueA&&valueB

boolStk.push(valueA)

}

break

case '!':

{

if(boolStk.empty())exit(0)

valueA=!(boolStk.top())

boolStk.pop()

boolStk.push(valueA)

}

break

case'_':

{

if(boolStk.size()<2)exit(0)

valueA=boolStk.top()

boolStk.pop()

valueB=boolStk.top()

boolStk.pop()

valueA=(!valueA)||valueB

boolStk.push(valueA)

}

break

case'$':

{

if(boolStk.size()<2)exit(0)

valueA=boolStk.top()

boolStk.pop()

valueB=boolStk.top()

boolStk.pop()

valueA=!(valueA&&valueB)

boolStk.push(valueA)

}

break

case'%':

{

if(boolStk.size()<2)exit(0)

valueA=boolStk.top()

boolStk.pop()

valueB=boolStk.top()

boolStk.pop()

valueA=!(valueA||valueB)

boolStk.push(valueA)

}

break

case'#':

{

if(boolStk.size()<2)exit(0)

valueA=boolStk.top()

boolStk.pop()

valueB=boolStk.top()

boolStk.pop()

valueA=(!valueA&&valueB)||(valueA&&!valueB)

boolStk.push(valueA)

}

break

case'@':

{

if(boolStk.size()<2)exit(0)

valueA=boolStk.top()

boolStk.pop()

valueB=boolStk.top()

boolStk.pop()

valueA=(valueA&&valueB)||(!valueA&&!valueB)

boolStk.push(valueA)

}

break

}

itr++

}

if(boolStk.size()!=1)

{

cout<<"Error in computing the value of minterm"<<endl

exit(0)

}

valueA=boolStk.top()

boolStk.pop()

return valueA

}

void formulaBase::addMin(int minterm)

{

int temp=minterm

vector<char>::const_iterator itr=vctofVar.begin()

normalCFormula+='('

while (itr!=vctofVar.end())

{

if(!variables[*itr])

normalCFormula+='!'

normalCFormula+=*itr

normalCFormula+='*'

itr++

}

normalCFormula+="\b)+"

}

void formulaBase::addMax(int maxterm)

{

int temp=maxterm

vector<char>::const_iterator itr=vctofVar.begin()

normalDFormula+='('

while (itr!=vctofVar.end())

{

if( variables[*itr])

normalDFormula+='!'

normalDFormula+=*itr

normalDFormula+='+'

itr++

}

normalDFormula+="\b)*"

}

string formulaBase::generateNormalC()

{

if(vctofPoland.size()==0)//This oeration has not been done yet!

getInversePoland()

cout<<"Here!"<<endl

int n=countTerms(numVar)

cout<<n<<"countTerms"<<endl

normalCFormula=' '

for(int i=0i<ni++)

{

if(compute(i))addMin(i)

}

normalCFormula+="\b "

return normalCFormula

}

string formulaBase::generateNormalD()

{

if(vctofPoland.size()==0)//This operation has not been done yet!!

getInversePoland()

int n=countTerms(numVar)

normalDFormula=' '

for(int i=0i<ni++)

{

if(!compute(i))addMax(i)

}

normalDFormula+="\b "

return normalDFormula

}

string formulaBase::getDual()

{

int i=0

char temp

dualFormula=' '

while ((temp=sourceFormula[i])!='\0')

{

switch(temp)

{

case '!':

{

i++

dualFormula+=sourceFormula[i]

break

}

case '+':dualFormula+='*'break

case '*':dualFormula+='+'break

case'(':case ')':dualFormula+=sourceFormula[i]

break

default:

if (isVar(temp))

{

dualFormula+='!'

dualFormula+=temp

}

else

{

cout<<"Error!"<<endl

exit(0)

}

}

i++

}

return dualFormula

}

/*void formulaBase::printTruthTable()//A const function is unable to call a nonconst function!!!

{

int i=0

int count=countTerms(numVar)

cout<<" TRUTH TABLE \n"

for( i=0i<=numVari++)cout<<"___"

cout<<endl

//for( i=0i<numVari++)cout<<'|'<<vctofVar[i]

//cout<<"|F|" <<endl

for( i=0i<=numVari++)cout<<"___"

cout<<endl

for(i=0i<counti++ )

{

int temp=i

for(int j=0j<numVarj++)

{

if(bool(temp&1))cout<<"|1"

else cout<<"|0"

temp=temp>>1

}

if(this->compute(i))cout<<"|1"

else cout<<"|0"

cout<<'|'<<endl

for( int k=0k<=numVark++)cout<<"___"

cout<<endl

}

}

*/

int main()

{

string str

formulaBase f

f.getSource()

str=f.generateNormalC()

cout<<"NORMALc:"<<str<<endl

str=f.generateNormalD()

cout<<"NORMALd"<<str<<endl

// cout<<"Coming here"<<endl

//f.printTruthTable()

str=f.getDual()

f.printDual()

return 0

}

---