范式c语言

Ⅳ 请教：R(A,B,C,D)F={A->B,C->D}属于几范式为什么

我觉得这个是第一范式，应为主键是（A，C）组成的组合，当他有一个A或C可以单独推出另一个非主属性就是部分依赖，BCNF要（A，C）->B,（A，C）->D这样才能达到BC范式

Ⅳ 用C或C++编写程序，要求： 输入命题公式，给出它的主合取范式和主析取范式。

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 alFormula;
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<<alFormula<<endl;}
//void printTruthTable();

};
formulaBase::formulaBase()
{
for(int i=0;i<100;i++)variables[i]=false;
numVar=0;
}
formulaBase::formulaBase(const formulaBase& rhs)
{
sourceFormula=rhs.sourceFormula;
for(int i=0;i<100;i++)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=2;i<=n;i*=2)tempA*=tempA;
i/=2;
if(i==n)return tempA;
i=n-i;
for(int j=2;j<=i;j*=2)tempB*=tempB;

for(j/=2;j<i;j++)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=0;sourceFormula[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=0;i<n;i++)
{
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=0;i<n;i++)
{
if(!compute(i))addMax(i);
}
normalDFormula+="\b ";
return normalDFormula;

}

string formulaBase::getDual()
{
int i=0;
char temp;
alFormula=' ';
while ((temp=sourceFormula[i])!='\0')
{
switch(temp)
{
case '!':
{
i++;
alFormula+=sourceFormula[i];
break;
}
case '+':alFormula+='*';break;
case '*':alFormula+='+';break;

case'(':case ')':alFormula+=sourceFormula[i];
break;
default:
if (isVar(temp))
{
alFormula+='!';
alFormula+=temp;
}
else
{
cout<<"Error!"<<endl;
exit(0);
}
}
i++;
}
return alFormula;
}
/*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=0;i<=numVar;i++)cout<<"___";
cout<<endl;
//for( i=0;i<numVar;i++)cout<<'|'<<vctofVar[i];
//cout<<"|F|" <<endl;
for( i=0;i<=numVar;i++)cout<<"___";
cout<<endl;
for(i=0;i<count;i++ )
{
int temp=i;
for(int j=0;j<numVar;j++)
{
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=0;k<=numVar;k++)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;
}

Ⅵ AB→C，AC→D,各位大佬这是第几范式

你好

答案是第二范式

因为有部分依赖

祝你好运

望点赞

Ⅶ 数据库中的三大范式是什么

数据库中三大范式的定义如下：

1、第一范式：

当关系模式R的所有属性都不能在分解为更基本的数据单位时，称R是满足第一范式的，简记为1NF。满足第一范式是关系模式规范化的最低要求，否则，将有很多基本操作在这样的关系模式中实现不了。

2、第二范式：

如果关系模式R满足第一范式，并且R得所有非主属性都完全依赖于R的每一个候选关键属性，称R满足第二范式，简记为2NF。

3、第三范式：

设R是一个满足第一范式条件的关系模式，X是R的任意属性集，如果X非传递依赖于R的任意一个候选关键字，称R满足第三范式，简记为3NF。

(7)范式c语言扩展阅读：

数据库中引入范式概念的目的：

规范化目的是使结构更合理，消除存储异常，使数据冗余尽量小。便于插入、删除和更新。遵从概念单一化“一事一地”原则，即一个关系模式描述一个实体或实体间的一种联系。规范的实质就是概念的单一化。

一个关系模式接着分解可以得到不同关系模式集合，也就是说分解方法不是惟一的。最小冗余的要求必须以分解后的数据库能够表达原来数据库所有信息为前提来实现。

其根本目标是节省存储空问，避免数据不一致性，提高对关系的操作效率，同时满足应用需求。实际上，并不一定要求全部模式都达到BCNF不可。有时故意保留部分冗余可能更方便数据查询。尤其对于那些更新频度不高，查询频度极高的数据库系统更是如此。

参考资料来源：网络-数据库范式

Ⅷ 数据库中，关系R(A,B,C)，函数依赖为F=(AB->C)，关系R是第几范式，为什么

满足第三范式
因为：第一范式指每一列都是不可分割的原子数据项，A、B、C都不可再分了。所以满足第一范式了。
第二范式指要求实体的属性完全依赖于主关键字， C完全依赖AB（没有A->C、B->C），所以满足第二范式
第三范式在第二范式的基础上消除依赖传递，上述只有一个依赖关系，所以也满足第三范式。