⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 netsafe.cpp

📁 爱因斯坦在20世纪初出的这个谜语。他说世界上有98％的人答不出来。某家公司在面试应聘者时借用了爱因斯坦的这个IQ题
💻 CPP
字号:
🔍 
#include <iostream.h>
#include <math.h>
#include <string.h>
class MyString
{
public:
    MyString();
    MyString(const char*s);
    MyString(const MyString & s);
    ~MyString();
    MyString & operator = (const MyString & s);

    MyString operator + (char * str);
    MyString operator + (const MyString & s);
    friend MyString operator + (char * str, const MyString & s);

    void operator += (char * str);
    void operator += (const MyString & s);

    int operator > (char * str) const;
    int operator > (const MyString & s) const;
    friend int operator > (char * str, const MyString & s);

    int operator >= (char * str) const;
    int operator >= (const MyString & s) const;
    friend int operator >= (char * str, const MyString & s);

    int operator < (char * str) const;
    int operator < (MyString & s) const;
    friend int operator < (char * str, const MyString & s);

    int operator <= (char * str) const;
    int operator <= (const MyString & s) const;
    friend int operator <= (char * str, const MyString & s);

    int operator != (char * str) const;
    int operator != (const MyString & s) const;
    friend int operator != (char * str, const MyString & s);

    int operator == (char * str) const;
    int operator == (const MyString & s) const;
    friend int operator == (char * str, const MyString & s);

    char & operator [] (int n);
    operator char * (void) const;

    friend ostream & operator << (ostream & ostr, const MyString & s);
    friend istream & operator >> (istream & istr, MyString & s);

    int length();
    int isempty();
    void clear();

    int find(char c, int start) const;
    int findlast(char c) const;
    int findstring(char * str) const;
    int findstring(MyString & s) const;

    MyString substr(int index, int count) const;

    void insert(char * s, int index);
    void insert(const MyString & s, int index);

    void remove(int index, int count);

protected:
    char * string;
    int size;
};
MyString::MyString()
{
    string = new char[1];
    *string = '\0';
	size = 1;
}

MyString::MyString(const char * s)
{
    if (s == NULL)
    {
	string = new char[1];
	*string = '\0';
    }
    else
    {
	size = strlen(s) + 1;
	string = new char[size];
	if (string!=NULL)
	{
	    strcpy(string, s);
	    string[size-1] = NULL;
	}
	else
	    size = 0;
    }
}

MyString::MyString(const MyString & s)
{
    size = strlen(s.string)+1;  //s.size;
    string = new char[size];
    if (string != NULL)
    {
	strcpy(string, s.string);
	string[size-1] = NULL;
    }
    else
	size = 0;
}

MyString::~MyString()
{
    if (string!=NULL && size!=0)
    {
	delete []string;
	size = 0;
    }
}

/*
MyString & MyString::operator = (const char * str)
{
    int len = strlen(str) + 1;
    if (size != len)
    {
	if (string != NULL)
	    delete []string;
	string = new char[len];
    }
    size = len;
    if (string != NULL)
    {
	strcpy(string, str);
	string[len-1] = NULL;
    }
    else
	size = 0; //??
    return * this;
} */

MyString & MyString::operator = (const MyString & s)
{
    if (this==&s)
	return *this;

    if (size != s.size)
    {
	if (string != NULL)
	    delete []string;
	string = new char[s.size];
    }
    size = s.size;
    if (string != NULL)
    {
	strcpy(string, s.string);
	string[size-1] = NULL;
    }
    else
	size = 0;
    return * this;
}

MyString MyString::operator + (char * str)
{
    MyString temp;
    int len;

    delete []temp.string;

    len = size + strlen(str);
    temp.size = len;
    temp.string = new char[len];
    if (temp.string != NULL)
    {
	strcpy(temp.string, string);
	strcat(temp.string, str);
	temp.string[temp.size-1] = NULL;
    }
    else
	temp.size = 0;
    return temp;
}


MyString MyString::operator + (const MyString & s)
{
    MyString temp;
    int len;

    delete []temp.string;

    len = size + s.size - 1; //only one NULL char
    temp.size = len;
    temp.string = new char[len];
    if (temp.string != NULL)
    {
	strcpy(temp.string, string);
	strcat(temp.string, s.string);
	temp.string[temp.size-1] = NULL;
    }
    else
	temp.size = 0;
    return temp;
}

MyString operator + (char * str, const MyString & s)
{
    MyString temp;
    int len;

    delete []temp.string;

    len = strlen(str) + s.size; //only one NULL char
    temp.size = len;
    temp.string = new char[len];
    if (temp.string != NULL)
    {
	strcpy(temp.string, str);
	strcat(temp.string, s.string);
	temp.string[temp.size-1] = NULL;
    }
    else
	temp.size = 0;
    return temp;
}

void MyString::operator += (char * str)
{
    int len = size + strlen(str);
    char * newstr = new char[len];
    if (newstr != NULL)
    {
	strcpy(newstr, string);
	strcat(newstr, str);
	newstr[len-1] = NULL;
	delete []string;
	string = newstr;
	size = len;
    }
}

void MyString::operator += (const MyString & s)
{
    int len = size + s.size - 1;
    char * newstr = new char[len];
    if (newstr != NULL)
    {
	strcpy(newstr, string);
	strcat(newstr, s.string);
	newstr[len-1] = NULL;
	delete []string;
	string = newstr;
	size = len;
    }
}

int MyString::operator > (char * str) const
{
    return (strcmp(string, str)>0);
}

int MyString::operator > (const MyString & s) const
{
    return (strcmp(string, s.string)>0);
}

int operator > (char * str, const MyString & s)
{
    return (strcmp(str, s.string)>0);
}

int MyString::operator >= (char * str) const
{
    return (strcmp(string, str)>=0);
}

int MyString::operator >= (const MyString & s)  const
{
    return (strcmp(string, s.string)>=0);
}

int operator >= (char * str, const MyString & s)
{
    return (strcmp(str, s.string)>=0);
}

int MyString::operator < (char * str)  const
{
    return (strcmp(string, str)<0);
}

int MyString::operator < (MyString & s) const
{
    return (strcmp(string, s.string)<0);
}

int operator < (char * str, const MyString & s)
{
    return (strcmp(str, s.string)<0);
}

int MyString::operator <= (char * str)  const
{
    return (strcmp(string, str)<=0);
}

int MyString::operator <= (const MyString & s)  const
{
    return (strcmp(string, s.string)<=0);
}

int operator <= (char * str, const MyString & s)
{
    return (strcmp(str, s.string)<=0);
}

int MyString::operator != (char * str) const
{
    return (strcmp(string, str)!=0);
}

int MyString::operator != (const MyString & s) const
{
    return (strcmp(string, s.string)!=0);
}

int operator != (char * str, const MyString & s)
{
    return (strcmp(str, s.string)!=0);
}

int MyString::operator == (char * str) const
{
    return (strcmp(string, str) == 0);
}

int MyString::operator == (const MyString & s) const
{
    return (strcmp(string, s.string) == 0);
}

int operator == (char * str, const MyString & s)
{
    return (strcmp(str, s.string) == 0);
}

char & MyString::operator [] (int n)
{
    if (n>=0 && n<size)
	return string[n];
    else
	return *(string+size);
}

MyString::operator char * (void) const
{
    return string;
}

ostream & operator <<(ostream & ostr, const MyString & s)
{
    ostr<<s.string;
    return ostr;
}

istream & operator >>(istream & istr, MyString & s)
{
    istr>>s.string;
    return istr;
}

int MyString::length()
{
    return (size - 1);
}

int MyString::isempty()
{
    return (strlen(string)==0);
}

void MyString::clear()
{
    if (string != NULL)
    {
	delete []string;
	string = 0;
	size = 0;
    }
}

int MyString::find(char c, int start) const
{
    int ret;
    char * p = string + start;
    while (*p)
    {
	if (*p == c) break;
	p++;
    }
    if (*p)
	ret = int (p - string - 1);
    else
	ret = -1;
    return ret;
}

int MyString::findlast(char c) const
{
    int ret;
    char * p;
    p = strrchr(string, c);
    if (p != NULL)
	ret = int (p - string);
    else
	ret = -1;
    return ret;
}

int MyString::findstring(char * str) const
{
    char * p;
    p = strstr(string, str);
    return int(p-string);
}

int MyString::findstring(MyString & s) const
{
    char * p;
    p = strstr(string, s.string);
    return int(p-string);
}

MyString MyString::substr(int index, int count) const
{
    MyString temp;
    if (index>=size || index<0)
	return temp;

    if ((index + count + 1)>=size)
	count = size - 1 - index; //if out of range, get all the
				  //last string(start at INDEX)

    delete []temp.string; //释放原有的空间
    temp.string = new char[count+1];
    if (temp.string == NULL)
	return temp;
    else
    {
	char * p = temp.string;
	char * q = string+index;
	for (int n=0; n<count; n++)
	     if (*q) *p++ = *q++;
	*p = NULL;
	temp.size = count + 1;
    }
    return temp;
}

void MyString::insert(char * s, int index)
{
    if (index<0 || index>=size)
	return;
    int len = size + strlen(s);
    char * str = new char[len];
    if (str != NULL)
    {
	char * source = string;
	char * dest = str;
	char * ins = s;
	int n;
	//devide into 3 parts
	for (n=0; n<index; n++)
	     *dest++ = *source++;
	for (n=0; n<(int)strlen(s); n++)
	     *dest++ = *ins++;
	for (n=0; n<len-index-(int)strlen(s)-1; n++)
	     *dest++ = *source++;
	*dest = NULL;
	delete []string; //释放原来的空间
	string = str;
	size = len;
    }
}

void MyString::insert(const MyString & s, int index)
{
    insert(s.string, index);
}

void MyString::remove(int index, int count)
{
    if (index<0 || index>=size || count>=size)
	return;
    char * s = new char[size-count];
    if (s != NULL)
    {
	char * p = s + index;
	char * q = string + index + count;
	if (index + count < size)
	{
	    strncpy(s, string, index);
	    while (*q)
		*p++ = *q++;
	}
	*p = NULL;
	delete []string;
	string = s;
	size = size - count;
    }
    //如果内存空间不够，则不做任何动作
}



MyString data[5][5]=	{{"黄房子","蓝房子","白房子","红房子","绿房子"},
						{"挪威人","英国人","德国人","丹麦人","瑞典人"},
						{"DUNHILL","PRINCE","BLENDS", "PALL MALL","BLUE MASTER"},
						{"咖啡","水","茶","牛奶"," 啤酒 "},
						{"鱼"," 猫","马",	"鸟","狗"}};
		/// ＜summary＞/// answer用来存放答案
		/// ＜/summary＞
		
void p();
void run();
void writeall();
int find(int i, int j);
void write_answer();
int answer[6][6]={0};
int ALL[6][122]={0};
int	count=1;
int	nLevel	= 0;
int List[6];
void main()
{		
	p();	
	run();
}
void run()
{
	int	i1,i2,i3,i4,i5;///通过逻辑条件顺序的有效选择来优化程序
	for	(i1=1;i1<=120;i1++)///房子
	{
		///9 、挪威人住第一间房子
		///14 、挪威人住在蓝房子旁边
		///不满足条件就短路
		///	
		if (ALL[2][i1]!=2)continue;
		for(int	j=0;j<5;j++,answer[j][1]=ALL[j][i1]);
		for	(i2=1;i2<=120;i2++)///人种
		{			
			for(int	j=0;j<5;j++,answer[j][2]=ALL[j][i2]);
			///9 、挪威人住第一间房子
			if (ALL[1][i2]!=1)continue;
			///1、 英国人住在红房子里 
			///
			if (find(1,4)!=find(2,2))continue;
			///4 、绿房子在白房子左边 
			///	
			if ((find(1,3)-find(1,5))!=1)continue;
			for	(i3=1;i3<=120;i3++)///烟
			{
				for(int	j=0;j<5;j++,answer[j][3]=ALL[j][i3]);
				///13、 德国人抽PRINCE烟
				///		
				if(find(2,3)!=find(3,2))continue;
				///7 、黄房子主人抽DUNHILL烟
				///		
				if(find(1,1)!=find(3,1))continue;
				for	(i4=1;i4<=120;i4++)///饮料
				{	
					for(int	j=0;j<5;j++,answer[j][4]=ALL[j][i4]);
					///8 、住在中间那间房子的人喝牛奶	
					///		
					if(ALL[3][i4]!=4)continue;
					///5 、绿房子主人喝咖啡 
					///	
					if (find(1,5)!=find(4,1))continue;
					///3 、丹麦人喝茶 
					///		
					if(find(2,4)!=find(4,3))continue;
					///15 、抽混合烟的人的邻居喝矿泉水	
					if(abs(find(3,3)-find(4,2))!=1)continue;
					///12 、抽BLUE	MASTER烟的人喝啤酒
					///		
					if(find(3,5)!=find(4,5))continue;
					for	(i5=1;i5<=120;i5++)///宠物
					{					
						for(int	j=0;j<5;j++,answer[j][5]=ALL[j][i5]);
						///10 、抽混合烟的人住在养猫人的旁边
						///	
						if(abs(find(3,3)-find(5,2))!=1)continue;
						///2 、瑞典人养了一条狗 
						///		
						if(find(2,5)!=find(5,5))continue;
						///6 、抽PALL MALL烟的人养了一只鸟	
						///		
						if(find(3,4)!=find(5,4))continue;
						///11 、养马人住在DUNHILL烟的人旁边 
						///	
						if(abs(find(5,3)-find(3,1))!=1)continue;
						///
						///能活到这里的data,当然是答案喽
						///
						write_answer();
					}
				}
			}
		}
	}
}
		/// ＜summary＞
		/// 非常典型的用递归实现排列组合算法。
		/// ＜/summary＞
void p()    
{
	int	nCount,nJudge,key;
	nLevel++;
	if(nLevel>5)
	{
		writeall();///有一种排列就写到All数组里
		nLevel--;
		return;
	}
	for(nCount=1;nCount<=5;nCount++)
	{
		key=0;
		for(nJudge=0;nJudge<=nLevel-1;nJudge++)
			if(nCount==List[nJudge])
			{																					 
				key=1;
				break;
			}
			if(key==0)
			{
				List[nLevel]=nCount;
				p();
			}
	}
	nLevel--;
}
		/// ＜summary＞
		/// 写入all数组
		/// ＜/summary＞
void writeall()
{
	int	i;
	for	(i=1;i<=5;i++)
	{
		ALL[i][count]=List[i];
	}		
	count++;
}
int	 find(int i,int	j)
{
	int	k;
	for(k=0;k<=5;k++)
	{
		if (answer[k][i]==j)
		{
			return k;
		}
	}
	return -1;
}
		/// ＜summary＞
		/// 将答案打印出来
		/// ＜/summary＞
void write_answer()
{
	for	(int i = 1;i<=5;i++)
	{
		for(int	j=1	;j<=5;j++)
		{
			cout<<data[i-1][answer[j][i]-1]<<",";
		}
		cout<<endl;
		
	}
	cout<<endl;
}

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -