$ 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
}
为了简化起见，我的第一串代码的输出格式是输出了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")
}
}
}
}
考试是教育评价的有力工具，是人们普遍认为 *** 作起来最简单直接、也最公平的测量手段，它对教育活动具有很强的导向作用。而考试的导向作用主要体现在命题中，一份试卷，能引导教师日常教学行为，促进学生发展性评价，考试作为衡量学生学习情况的一种重要手段，能否出一份好的试卷是教师基本功的一个重要方面，同时，也能很好的反映一名教师的教学水平，所以出好一份试卷在教学中是一个非常关键的环节。下面我就怎样出好一份地理试卷谈谈我的一些想法。一、命题指导思想：
关注学生的学习，关注学生的积累，关注学生的运用与实践，关注学生情感与态度，关注学生综合素质。具体来说有以下几个方面：
1、注重学生所学知识量的测试，考查学生知识的掌握情况，命题中不能只注重重点而忽略非重点，应最大可能地把学生所学知识尽可能多地进行考查。
2、注重测试学生理解、方法和能力三个方面。
3、注重对学生综合素质的测试。
4、考查学生对所学课程基础知识、基本技能、掌握程度和综合运用所学知识、分析解决实际问题能力。
二、命题原则
教师总是要以教学测量为手段，经过分析、综合，进行判断，以得知自己的或他人的教授活动与学生的学习行为的状态，进而与教学目标和教学要求相对照，获取准确具体的结构；学生作为积极主动的认识主体，也总是要努力以教学目标和学习要求为标尺来评判自己的学习结果与进展。
1. 教学测量与评价应遵循的准则
(1) 准确、全面——理解地理学科教学的目的和要求 测验和评价包括：学生的知识、理解和思维、技能和能力、态度和方法等方面的内容
(2) 有计划、有目标——按学习进程，循序地实施测验和评价
（3）适量、适合——控制测验次数、科学选择测验时间、内容和形式
2、命题应遵循的原则
科学性——不能出现知识性的错误，保证试卷质量的关键
指导性—— 发挥考试的导向功能
适切性——试题的难度比例适当 独立性——试题独立相互不牵连
合理性—— 评分标准简便、准确
明确性--- 题目语意清楚，文句简明扼要，答案明确合理，无二义性
全面性---覆盖面既要大，又要突出重点，保证试题在所测内容上具有代表性，力
求做到各个部分的比例适当。
层次性---试题本身的层次性；整张试卷难度分布的层次性
以生为本---内容的新颖性、趣味性、激励性、人文性 形式的创新
3、为了减轻学生的记忆负担，促进创新能力的培养，应该严格按照明确规定的考试内容重点范围进行命题，记忆性的试题要少而精。在一份试卷中，有利于培养创新思维的试题要占较大的比例，非选择题等要把考生引向独立思考而不是死记硬背，让考生根据自己的理解和看法来回答问题。
4、考试内容与要求要与《课程标准》、考试说明中规定的内容相一致，不能脱离纲、本要求出偏题、怪题，应该按提出的层次性要求，既注重考查重点知识，又要适当考查知识的覆盖面；既考查地理双基，又要考查地理各种能力，尤其地理填图、读图、析图能力。注重试题题目易、中、较难三个层次的比例。
5、试卷中各种题型的采用和搭配要合理得当（地理题型一般分为选择题和综合题两类），试卷、试题、参考答案和评分标准必须科学严谨、公正无误。
6、要注意前后知识的融合，知识块间的联系，概念、原理、规律的合理搭配，知识与能力整合，以及各种类型题目的合理配置，同时也要注意结合与其他学科知识、生产生活实际问题、热点问题的联系与运用。
三、命题程序
出试卷分为三个阶段：准备、出卷、检查与校正，在这三个阶段中主要须解决好这样的几个问题：
①知识点全面覆盖：先首要对所考查对象加以梳理，选出必考的知识点，力求做到试卷对内容的全面覆盖。通常应着眼于《Ⅰ卷》的必考题型中对内容完成较为全面的覆盖。
②知识重点、难点考查：多以《Ⅱ卷》的题目加以考查，设问要严谨，过渡要自然，难易有层次，每小题都要有学生易答的问题，不要一难到底，更不要出现连环套。
③分值分布合理、答案要全面无争议；要使整卷版面美观，特别是要做到格式统一、字体行距合适；试卷易于评阅，易于同组内分工流水作业。①与②是在准备与出卷的主要工作。而检查与校正（包括地理图表或图幅的清晰度及大小）则是对三个方面的全面检查。
1、明确考试目的：
学校的各种考试都有一定的目的。由于各种性质的考试，其目的不同，那么命题的难易程度、各类知识的比例、试题形式就会有所不同。因此，命题前必须明确考试目的。
2、研读相关内容：
出题前要研究地理会考、中考、高考要求，认真研读教学大纲、教材内容，课程标准。内容包括知识点的层次类型（记忆、理解、应用）、知识点的重要程度（了解、熟悉、掌握、熟练掌握、拓展延伸）。确定基础题、中档题、提高题的比例；还要研究学生的实际；学校对考试的具体要求，准确掌握命题标准。要出一份好的试卷, 必须要吃透教材和教学大纲。试题要充分体现教学目的和大纲要求，尽量的突出重点，覆盖面广。同时，考试必须要考一些实质性的东西, 杜绝偏题、怪题和超纲题。
3、设计命题计划和制定“命题双向细目表”：
命题计划是编制试题的依据，是科学设计试题、周密安排考试内容、便于命题。命题计划应包括两项内容：
⑴编制试题的原则和要求，说明考试的内容范围、方法目标、试题类型、编制试题和组配试卷的要求。
⑵规定试卷中试题的分布，即具体考试内容中各部分试题的数量分布和所占比例。
制定“命题双向细目表”
双向细目表是一种考查目标（能力）和考查内容之间的列联表。一般地，表的纵向列出的各项是要考查的内容即知识点，横向列出的各项是要考查的能力，或说是在认知行为上要达到的水平，在知识与能力共同确定的方格内是考题分数所占的比例。
命题双向细目表具有三个要素：
考查目标、考查内容以及考查目标与考查内容的比例。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）