sushu.cpp

求得一个4*4的方阵

#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <math.h>
using namespace std;

ofstream out("D:\\C++代码\\书上的练习\\sushu.txt");

int reverse(int num); //将一个四位数倒过来
void vec_display(vector<int> &ivec); //显示一个vector
vector<int>& vec_cmp(vector<int> &ivec1,vector<int> &ivec2,vector<int> &ivec); //比较两个vector是否有相同的数据，并返回一个由这些相同数据组成的vector
bool is_right(int num);//判断一个数是否是素数
int* to_array(int &num,int *pt);//将一个四位数变成一个一维数组
void array_display(int[][4]);
bool find_vec(int result[][4],vector<int> &ivec);//
bool find_diag(int result[][4],vector<int> &ivec);//判断对角线
bool judge(int result[][4]);
void trans(int &num1,int &num2,int &num3,int &num4,int array[][4]);//将四个数变成一个数租4*4
inline int get_qian(int &num) {return (num/1000);}
inline int get_bai(int &num)  {return ((num-get_qian(num)*1000)/100);}
inline int get_shi(int &num)  {return ((num-get_qian(num)*1000-get_bai(num)*100)/10);}
inline int get_ge(int &num){return ((num-get_qian(num)*1000-get_bai(num)*100-get_shi(num)));}

void main()
{
   vector<int> ivec;
   vector<int> ivec_opt;
   vector<int> ivec_equ;
   int result[4][4]={0};
   bool find,find2;
   int m=1000;
   int m_opt;
   int count=0;
   
   while(m<10000 )
   {    if(is_right(m))
		{
			ivec.push_back(m);
			count++;
		}
		m++;
	}
   cout<<"count="<<count<<endl;
  
   for(int k=0;k<ivec.size();k++)
   {
		m_opt=reverse(ivec[k]);
		ivec_opt.push_back(m_opt);

   }
   

      ivec_equ=vec_cmp(ivec,ivec_opt,ivec_equ);
	 vec_display(ivec_equ);
	  cout<<"\nsize="<<ivec_equ.size()<<endl;
	  out<<"*************************************"<<endl;

     int a,b,c,d;int not_count=0;int yes_count=0;
	  
	 for(int x=0;x<ivec_equ.size();x++)
	 {   
		 if((get_bai(ivec_equ[x]))==0 ||(get_shi(ivec_equ[x]))==0 ||(get_ge(ivec_equ[x]))==0)
			 continue;
		for(int xx=0;xx<ivec_equ.size();xx++)
	   {
		    
			for(int xxx=0;xxx<ivec_equ.size();xxx++)
		   {
			    
				for(int xxxx=0;xxxx<ivec_equ.size();xxxx++)
			   {
				   
					if((get_bai(ivec_equ[xxxx]))%2==0||(get_shi(ivec_equ[xxxx]))%2==0)//||(get_ge(ivec_equ[xxxx]))%2==0)
			          continue;
				  a=ivec_equ[x];
				  b=ivec_equ[xx];
				  c=ivec_equ[xxx];
				  d=ivec_equ[xxxx];
				  trans(a,b,c,d,result);
				
                  find=find_diag(result,ivec_equ);
				  if(!find)
					continue;
                  find2=find_vec(result,ivec_equ);
				  if(!find2)
					  continue;
				
					if(find && find2)
					{
						array_display(result); 
						cout<<endl;
					}
					
			   }//for4
           }//for 3
        
	 } //for2*///****************/***********/
				
	 }// for1
	 
cout<<"it is over!";
}



/****************函数实现**********************/
bool is_right(int num)
{
   for(int i=2;i<sqrt(num);i++)
		   if(num%i==0)
			   break;
	if(i>sqrt(num))
		return true;
	else
	    return false;
}

int reverse(int num)
{
	int num_reverse;
	int g,s,b,q;
	 q=num/1000;
	 b=(num-q*1000)/100;
	 s=(num-q*1000-b*100)/10;
	 g=(num-q*1000-b*100-s*10);

     num_reverse=g*1000 + s*100 + b*10 + q;
	 return num_reverse;
}

void vec_display(vector<int> &ivec)
{int j;
  // for(j=0;j<ivec.size();j++)
  // {
//	   cout.width(8);
//	   cout<<ivec[j];
//	   if(j%8==0)
//		   cout<<endl;
 //  }
   for(j=0;j<ivec.size();j++)
   {
	   out.width(8);
	   out<<ivec[j];
	   if(j%8==0)
		   out<<endl;
   }
}

vector<int>& vec_cmp(vector<int> &ivec1,vector<int> &ivec2,vector<int> &ivec)
{
	int k,m;
	int len1,len2;
	
	if(ivec1.size()<=ivec2.size())
	{
		len1=ivec1.size(); len2=ivec2.size();
	}
	else
	{
		len1=ivec2.size(); len2=ivec1.size();
	}
	for(k=0;k<len2;k++)
	{
		for(m=0;m<len1;m++)
		{
			if(ivec1[k]==ivec2[m])
            ivec.push_back(ivec1[k]);
		}
	}

	return ivec;

}

int* to_array(int &num,int *pt)
{
	pt=new int[4]; 
	int g,s,b,q;
	 q=num/1000;
	 b=(num-q*1000)/100;
	 s=(num-q*1000-b*100)/10;
	 g=(num-q*1000-b*100-s*10);

	 pt[0]=q;
	 pt[1]=b;
	 pt[2]=s;
	 pt[3]=g;
     return pt;
}

void array_display(int array[][4])
{
  /*
	for(int i=0;i<4;i++)
   {
		for(int j=0;j<4;j++)
		{
			cout.width(3);
			cout<<array[i][j];
		}
		cout<<endl;
   }
 */
   for(int i=0;i<4;i++)
   {
		for(int j=0;j<4;j++)
		{
			out.width(3);
			out<<array[i][j];
		}
		out<<endl;
   }
  

}

bool find_diag(int result[][4],vector<int> &ivec)
{
  int temp1,temp2;
  int count=0;
   //主对角线
   temp1=result[0][0]*1000 + result[1][1]*100 + result[2][2]*10 + result[3][3];
   vector<int> ::iterator it1;
   it1=find(ivec.begin(),ivec.end(),temp1);
   if(it1!=ivec.end())
	   count++;
   else return false;
   //副对角线
   temp2=result[0][3]*1000 + result[1][2]*100 + result[2][1]*10 + result[3][0];
   vector<int>::iterator it2;
   it2=find(ivec.begin(),ivec.end(),temp2);
   if(it2!=ivec.end())
	   count++;
    else return false;

	if(count==2)	   
      return true;
   
   return false;

}
bool find_vec(int result[][4],vector<int> &ivec)
{
   int temp3,temp4,temp5,temp6;//
   int count=0;
  //第一列
   temp3=result[0][0]*1000 + result[1][0]*100 + result[2][0]*10 + result[3][0];
   vector<int>::iterator it3;
   it3=find(ivec.begin(),ivec.end(),temp3);
   if(it3!=ivec.end())
	   count++;
    else return false;
 
	if(result[3][1]%2==0) return false;
	if(result[3][2]%2==0) return false;
	if(result[3][3]%2==0) return false;
 
   //第二列
   temp4=result[0][1]*1000 + result[1][1]*100 + result[2][1]*10 + result[3][1];
   vector<int>::iterator it4;
   it4=find(ivec.begin(),ivec.end(),temp4);
   if(it4!=ivec.end())
	   count++;
    else return false;

 //第三列
   temp5=result[0][2]*1000 + result[1][2]*100 + result[2][2]*10 + result[3][2];
   vector<int>::iterator it5;
   it5=find(ivec.begin(),ivec.end(),temp5);
   if(it5!=ivec.end())
	   count++;
   else return false;

 //第四列
   temp6=result[0][3]*1000 + result[1][3]*100 + result[2][3]*10 + result[3][3];
   vector<int>::iterator it6;
   it6=find(ivec.begin(),ivec.end(),temp6);
   if(it6!=ivec.end())
	   count++;
   else return false;
	
	if(count==4)	   
      return true;
   
   return false;
}
bool judge(int result[][4])
{
   if(result[0][1]==0 || result[0][2]==0 || result[0][3]==0 || result[3][1]%2==0 ||result[3][2]%2==0||result[3][3]%2==0) //第一行的元素不能为零,最后一行元素不能是偶数
	   return false;
   return true;
}
void trans(int &num1,int &num2,int &num3,int &num4,int array[][4])
{
	int q1,b1,s1,g1;
    int q2,b2,s2,g2;
	int q3,b3,s3,g3;
	int q4,b4,s4,g4;
	q1=num1/1000;
	b1=(num1-q1*1000)/100;
	s1=(num1-q1*1000-b1*100)/10;
	g1=(num1-q1*1000-b1*100-s1*10);
	q2=num2/1000;
	b2=(num2-q2*1000)/100;
    s2=(num2-q2*1000-b2*100)/10;
	g2=(num2-q2*1000-b2*100-s2*10);
	q3=num3/1000;
	b3=(num3-q3*1000)/100;
	s3=(num3-q3*1000-b3*100)/10;
	g3=(num3-q3*1000-b3*100-s3*10);
	q4=num4/1000;
	b4=(num4-q4*1000)/100;
	s4=(num4-q4*1000-b4*100)/10;
	g4=(num4-q4*1000-b4*100-s4*10);

	array[0][0]=q1;array[0][1]=b1;array[0][2]=s1;array[0][3]=g1;
	array[1][0]=q2;array[1][1]=b2;array[1][2]=s2;array[1][3]=g2;
	array[2][0]=q3;array[2][1]=b3;array[2][2]=s3;array[2][3]=g3;
	array[3][0]=q4;array[3][1]=b4;array[3][2]=s4;array[3][3]=g4;

   
}

/*********************************************************************
for(int j=0;j<ivec_equ.size();j++)
		 for(int t=j+1;t<ivec.size();t++)
			 for(int n=j+2;j<ivec.size();n++)
				 for(int s=j+3;s<ivec.size();s++)
				 {
					//int j=0;int t=1;int n=2;int s=3;
					pt[j]=to_array(ivec_equ[j],result[j]);
					pt[t]=to_array(ivec_equ[t],result[t]);
					pt[n]=to_array(ivec_equ[n],result[n]);
					pt[s]=to_array(ivec_equ[s],result[s]);
	
					 // for(int i=0;i<4;i++)
					 // {
						//cout.width(6);
						//cout<<*(pt[j]+i);
						//cout<<*(pt[t]+i);
						//cout<<*(pt[n]+i);
						//cout<<*(pt[s]+i);
						result[j][i]=*(pt[j]+i);
						result[t][i]=*(pt[t]+i);
						result[n][i]=*(pt[n]+i);
						result[s][i]=*(pt[s]+i);
					 // }
	                    cout<<endl;
						bool find;
						find=find_vec(result[0][0],result[1][1],result[2][2],result[3][3],ivec_equ);
						if(find)
						{
							array_display(result);
						}
		 
				 }
				 *******************/