华为机试考试题目

//1、牛客网-数据分类
/*
题目描述：
信息社会，有海量的数据需要分析处理，比如公安局分析身份证号码、 QQ 用户、手机号码、银行帐号等信息及活动记录。
采集输入大数据和分类规则，通过大数据分类处理程序，将大数据分类输出。
一组输入整数序列I和一组规则整数序列R，I和R序列的第一个整数为序列的个数（个数不包含第一个整数）；整数范围为0~0xFFFFFFFF，序列个数不限
链接：https://www.nowcoder.com/questionTerminal/9a763ed59c7243bd8ab706b2da52b7fd
来源：牛客网
从R依次中取出R，对I进行处理，找到满足条件的I：
I整数对应的数字需要连续包含R对应的数字。比如R为23，I为231，那么I包含了R，条件满足 。
按R从小到大的顺序:
(1)先输出R；
(2)再输出满足条件的I的个数；
(3)然后输出满足条件的I在I序列中的位置索引(从0开始)；
(4)最后再输出I。
附加条件：
(1)R需要从小到大排序。相同的R只需要输出索引小的以及满足条件的I，索引大的需要过滤掉
(2)如果没有满足条件的I，对应的R不用输出
(3)最后需要在输出序列的第一个整数位置记录后续整数序列的个数(不包含“个数”本身)
序列I：15,123,456,786,453,46,7,5,3,665,453456,745,456,786,453,123（第一个15表明后续有15个整数）
序列R：5,6,3,6,3,0（第一个5表明后续有5个整数）
输出：30, 3,6,0,123,3,453,7,3,9,453456,13,453,14,123,6,7,1,456,2,786,4,46,8,665,9,453456,11,456,12,786
说明：
30----后续有30个整数
3----从小到大排序，第一个R为0，但没有满足条件的I，不输出0，而下一个R是3
6— 存在6个包含3的I
0— 123所在的原序号为0
123— 123包含3，满足条件
*/
//代码：

//2、CSDN-数字排列
/*
题目描述：
有7对数字：两个1，两个2，两个3，…两个7，把它们排成一行。
要求，两个1间有1个其它数字，两个2间有2个其它数字，以此类推，两个7之间有7个其它数字。
如下就是一个符合要求的排列： 17126425374635 当然，如果把它倒过来，也是符合要求的。
请你找出另一种符合要求的排列法，并且这个排列法是以74开头的。
注意：只填写这个14位的整数，不能填写任何多余的内容，比如说明注释等。
7447****
*/

//代码：
#if 0
/*

思路：
定义一个数组，大小为14，初始化为 0 。
回溯： 在数组第 i 个位置，依次赋值为 t ，而在第 i+t+1 个位置，也赋值为 t 。
赋值的条件便是第 i 个元素的位置和第 i+t+1 个元素的位置的值为 0 。并且 i+t+1 要小于 N 。
赋完值之后要把数组还原。
回溯截止条件：传值 t 等于 (N/2)+1。
最后输出满足第 0 个元素为 7 ，并且第 1 个元素为 4 的结果。

*/

//c++代码
#include
using namespace std;
#define N 14
int a[14]={0};
void backtrack(int t)
{
	int i;
	if(t==(N/2)+1 && a[0]==7 && a[1]==4)
	{
		for(int j = 0;j<N;j++)
		{
			cout<<a[j];
		}
		cout<<endl;
	}

	for(i=0;i<N;i++)
	{
		if(a[i]==0 && a[i+t+1]==0 && i+t+1<N)
		{
			a[i]=t;
			a[i+t+1]=t;
			backtrack(t+1);
			a[i]=0;
			a[i+t+1]=0;
		}
	}
}

int main()
{
	backtrack(1);
	return 0;
}

#if 0
//c代码  https://blog.csdn.net/github_38927899/article/details/72742209?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160593131719725255530612%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=160593131719725255530612&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-72742209.first_rank_ecpm_v3_pc_rank_v2&utm_term=CSDN-%E6%95%B0%E5%AD%97%E6%8E%92%E5%88%97&spm=1018.2118.3001.4449
#include 
#define N 14

int a[14]={0};

void backtrack(int t)       //传值：t为在该位置添加的数字
{
    int i;
	printf("*******************************t=%d",t);
    printf("\n");
	for(i=0;i<N;i++)
        printf("%d",a[i]);
    printf("\n");
    if(t==(N/2)+1 && a[0]==7 && a[1]==4)
    {
        for(i=0;i<N;i++)
            printf("%d",a[i]);
        printf("\n");
    }

    for(i=0;i<N;i++)
    {
        if(a[i]==0 && a[i+t+1]==0 && i+t+1<N)
        {
			printf("i=%d",i);
			printf("\n");
            a[i]=t;
            a[i+t+1]=t;
			printf("a[i]=%d",a[i]);
			printf("\n");
			printf("a[i+t+1]=%d",a[i]);
			printf("\n");
            backtrack(t+1);
            a[i]=0;
            a[i+t+1]=0;
        }
    }
}

int main()
{
    backtrack(1);
    return 0;
}
#endif
#endif 

//3、CSDN-求简单四则运算
/*
题目描述：
输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注：
3.1、表达式只含 +, -, *, / 四则运算符，不含括号
3.2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况
3.3、要考虑加减乘除按通常四则运算规定的计算优先级
3.4、除法用整数除法，即仅保留除法运算结果的整数部分。比如8/3=2。输入表达式保证无0作为除数情况发生
3.5、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况
*/
//代码：

#if 0
#include
#include
using namespace std;

int caluate(const char *input)
{
	int length = strlen(input)+1;
	int result =0;
	if(NULL==input || length <=0)
	{
		cout<<"erro"<<endl;
		return NULL;
	}
	char *temp = new char[length];
	char *temp2= temp;
	memset(temp,0,length);

	for(int i=0;i<length;i++)
	{
		if(*(input+i)!='*'&& *(input+i)!='/')
		{
			*temp = *(input+i);
			temp++;
		}
		else if(*(input+i)=='*')
		{
			int a = *(input+i-1)-'0';
			int b= *(input+i+1)-'0';
			temp --;
			*(temp) = a*b+'0';
			temp++;
			i++;
		}
		else
		{
			int a = *(input+i-1)-'0';
			int b= *(input+i+1)-'0';
			if(0==b)
			{
				cout<<"erro"<<endl;
				return NULL;
			}
			else
			{
				temp--;
				*(temp) = a/b+'0';
				temp++;
				i++;
			}

		}

	}
	for(int j=0;j<strlen(temp2);j++)
		{
			if(*(temp2+j)>='0'&&*(temp2+j)<='9')
			{
				result+=*(temp2+j)-'0';
			}
			else if(*(temp2+j)=='+')
			{
				result += *(temp2+j+1)-'0';
				j+=1;
			}
			else
			{
				result -= *(temp2+j+1)-'0';
				j+=1;
			}
		}
		
	return result;
}
int main()
{
	string ss;
	cin>>ss;
	cout<<"ss = "<<ss<<endl;
	const char *a = ss.c_str();
	int R = caluate(a);
	cout<<"R="<<R<<endl;
	system("pause");
	return 0;

}
#endif

//4、CSDN-文本逐词反转
/*
题目描述：
将字符串按单词反转输出，如输入：hello sir 输出：olleh ris 。
借助C++ vector容器实现，主要思路是：按空格将字符串拆分为单词，将各个单词进行反转，然后拼接成新的字符串。出现计算溢出情况
*/

//代码：
#if 0
#include
#include
#include
#include
using namespace std;

int main()
{
	string str;
	getline(cin,str);
	int len = str.length();
	vector<string> vtr;
	int pre =0;
	int pos =0;
	string temp;
	for(int i=0;i<len+1;i++)
	{
		if(str[i]==' ')
		{
			pos = i;
			temp.insert(temp.begin(),str.begin()+pre,str.begin()+pos);
			vtr.push_back(temp);
			pre  =pos+1;
			temp.clear();
		}
		if(str[i]=='\0')
		{
			temp.insert(temp.begin(),str.begin()+pre,str.end());
			vtr.push_back(temp);
		}

	}

	vector<string>::iterator it;
	for(it=vtr.begin();it!=vtr.end();it++)
	{
		reverse((*it).begin(),(*it).end());
		cout<<*it<<" ";
	}
	cout<<endl;

	system("pause");
	return 0;
}
#endif

//5、CSDN-检测链表中的循环
/*
题目描述：
https://blog.csdn.net/ccmlove123/article/details/104052556?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160593681019724839236319%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=160593681019724839236319&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allfirst_rank_v2~rank_v28-3-104052556.first_rank_ecpm_v3_pc_rank_v2&utm_term=%E6%A3%80%E6%B5%8B%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E5%BE%AA%E7%8E%AFc%2B%2B&spm=1018.2118.3001.4449
循环链表：
https://blog.csdn.net/qq_43570024/article/details/100546814
*/
//代码：

#if 0
#include
#include
using namespace std;

struct node
{
    int data;
    struct node* next;
};
void detectLoop(struct node *head)
{
    struct node *slowPtr,*fastPtr;
    slowPtr = head;
    fastPtr = head;
     
    while(slowPtr!=NULL && fastPtr!=NULL && fastPtr->next!=NULL)
    {
       slowPtr = slowPtr->next;
       fastPtr = fastPtr->next->next;
       if (slowPtr == fastPtr)
       {
           printf("%s","Loop Detected");
           exit(0);
        }
    }
}

#endif

//6、CSDN-打印任务排序
/*
题目描述：
一台打印机有若干个任务，但是打印机每次只能打印一个任务，每个任务是有优先级的，从1到9。打印的时候从序列的第一个开始，如果第一个的 优先级不是最大的，则将其出队，并加入队尾。若其优先级是最大的，则直接打印该任务。设计算法实现如下功能：
输入：
（1）第一行：输入测试案例的个数，第二行：第一个数字是打印任务个数，第二个数据是目标任务在当前任务序列的位置
输出：
（2）目前任务打印完成需要的时间（假设打印一个任务需要1个单位时间，转移、判断任务不需要时间）
（3）所有任务的打印顺序
例如：
1（只有一个测试用例）
2 1（一共两个任务，目标任务的位置是1–任务是从0开始的）
2 3（序列）
输出：
2 1 0
*/
//代码：

#if 0
#include 
#include 
#include 
 
using namespace std;
 
struct point {
	int id;
	int pry;
};
 
int main()
{
	int casenum = 0;
	int n = 0;
	int m = 0;
	int j;
	int i;
	scanf_s("%d", &casenum);
	while (casenum--)
	{
		int pty[115];
		point pt[115];
		int lst[115];
		int lstcnt = 0;
		int time = 1;
		queue<point>Q;
		scanf_s("%d%d", &n, &m);
		for (i = 0; i<n; i++)
		{
			scanf_s("%d", &pty[i]);
			pt[i].pry = pty[i];
			pt[i].id = i;
			Q.push(pt[i]);
		}
		// 上面是没有问题的
		int T = n;
		while (T != 0)
		{
			int count = 0;
			point crt = Q.front();
			Q.pop();
			int ij;
			for (ij = 0; ij < n; ++ij)
			{
				if (crt.pry < pty[ij])
				{
					count++;
					break;
				}
			}
			if (count == 0)
			{
				lst[lstcnt++] = crt.id;
				pty[crt.id] = 0;
				T--;
			}
			else
				Q.push(crt);
		}
		for (j = 0; j < n; j++)
		{
			printf("%d ", lst[j]);
		}
		printf("\n");
 
		for (j = 0; j < n; j++)
		{
			if (lst[j] != m)
			{
				time++;
			}
			else
				break;
		}
		printf("%d\n", time);
	}
	system("pause");
	return 0;
}


#endif

/*
7、CSDN-jam计数法
Jam是个喜欢标新立异的科学怪人。他不使用阿拉伯数字计数，而是使用小写英文字母计数，他觉得这样做，会使世界更加丰富多彩。在他的计数法中，每个数字的位数都是相同的（使用相同个数的字母），英文字母按原先的顺序，排在前面的字母小于排在它后面的字母。我们把这样的“数字”称为Jam数字。在Jam数字中，每个字母互不相同，而且从左到右是严格递增的。每次，Jam还指定使用字母的范围，例如，从2到10，表示只能使用{b,c,d,e,f,g,h,i,j}这些字母。如果再规定位数为5，那么，紧接在Jam数字“bdfij”之后的数字应该是“bdghi”。（如果我们用U、V依次表示Jam数字“bdfij”与“bdghi”，则U 输入格式
输入有2行，第1行为3个正整数，用一个空格隔开：
s t w
（其中s为所使用的最小的字母的序号，t为所使用的最大的字母的序号。w为数字的位数，这3个数满足：1≤s 第2行为具有w个小写字母的字符串，为一个符合要求的Jam数字。
所给的数据都是正确的，不必验证。
输出格式
输出最多为5行，为紧接在输入的Jam数字后面的5个Jam数字，如果后面没有那么多Jam数字，那么有几个就输出几个。每行只输出一个Jam数字，是由w个小写字母组成的字符串，不要有多余的空格。
具体思路：参考C语言的Jam的计数法
实例：
输入：
2 10 5
bdfij
输出：
bdghi
bdghj
bdgij
bdhij
befgh
*/

//代码：

#if 0
#include 
#include 
#include 
int num = 0;
using namespace std;

void fun(string str, int s, int t, int w)
{
    int i, j;
    int flag = 0;
    int n[33] = {0};
    for(i=0; i<w; i++)
    {
        n[str[i]-96] = 1;
    }
    for(i=w-1; i>=0; i--)
    {
        for(j=str[i]-95; j<=t-(w-i-1); j++)
        {
            if(n[j] == 0)
            {
                for( ; i<w; j++, i++)
                {
                    str[i] = j+96;
                }
                num++;
                cout << str <<endl;
                flag = 1;
                break;
            }
        }
        if(flag == 1)
            break;
    }
    if(flag == 1 && num<5)
    {
        memset(n, 0, 33);
        fun(str, s, t, w);

    }
    return;
}

int main()
{
    string str;
    int s, t, w;
    cin >> s >> t >> w;
    cin >> str;
    fun(str, s, t, w);
    return 0;
}

#endif

/*
8、CSDN-单词排序输出
题目描述：
输入一行单词序列，相邻单词之间由1个或多个空格间隔，
请按照字典序输出这些单词，要求重复的单词只输出一次。（区分大小写）
输入：
一行单词序列，最少1个单词，最多100个单词，每个单词长度不超过50，
单词之间用至少1个空格间隔。数据不含除字母、空格外的其他字符。
输出：
按字典序输出这些单词，重复的单词只输出一次。
输入样例：
She wants to go to Peking University to study Chinese
输出样例：
Chinese
Peking
She
University
go
study
to
wants
*/

//代码：

#if 0
#include
#include
#include
const int N=100;
using namespace std;
int main()
{
    char s[N];
    char str[N][N];
    int i=0,j=0,t=0;
    cin.get(s,N);
    int len=strlen(s);
    for(i=0;i<len;i++)
    //while(s[i++]!='\n')
    {
        if(s[i]!=' ')
            str[j][t++]=s[i];
        else
        {
            str[j][t]='\0';
            j++;
            t=0;
        }
    }
    str[j][t]='\0';

    for(i=0;i<=j-1;i++)//i=j-1不是<
        for(t=i+1;t<=j;t++)
            if(strcmp(str[i],str[t])>0)
            {
                char temp[N];
                strcpy(temp,str[i]);
                strcpy(str[i],str[t]);
                strcpy(str[t],temp);
            }
    for(i=0;i<=j;i++)//i<=j不是<
        cout<<str[i]<<" ";
    return 0;
}

#endif

/*
9、CSDN-德州扑克
题目描述：
游戏的完整代码在下面的链接：
https://blog.csdn.net/hellowd123/article/details/89892793?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160594490919724839204099%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=160594490919724839204099&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_click~default-2-89892793.first_rank_ecpm_v3_pc_rank_v2&utm_term=%E5%BE%B7%E5%B7%9E%E6%89%91%E5%85%8Bc%2B%2B&spm=1018.2118.3001.4449
判定德州扑克的牌型。给5张牌，返回它的牌型，
4个的，3个+对子，顺子，3个+2个单张散牌，2对+散牌，1对+散牌，其他。
*/

//代码：

#if 0
#include
#include
using namespace std;
#define N 5
void judgementshunzi(int a[N],string ss)
{
	for(int i = 0;i<N;i++)
	{
		for(int j=i+1;j<N;j++)
		{
			if(a[i]>a[j])
			{
				int temp = a[j];
				a[j] = a[i];
				a[i] = temp;
			}
		}
	}
	cout<<"排序之后的牌："<<endl;
	 for(int i =0;i<N;i++)
	 {
		 cout<<a[i];
	 }
	 cout<<endl;
	for(int i = 0;i<N-1;i++)
	{
		if(a[i]-a[i+1] != -1)
		{
			cout<<"你拿到了杂牌"<<endl;
			return ;
		}
	}
	int huase_count =0 ;
	for(int i=0;i<N;i++)
	{
		if(ss[i]==ss[0])
		{
			huase_count++;
		}
	}
	if(huase_count ==5)
	{
		cout<<"你拿到了同花顺"<<endl;
		return ;
	
	}
	else
	{
		cout<<"你拿到了顺子"<<endl;
		return ;
		
	}
}
void judgement(int a[N],string ss)
{
	int judgenum_count1 = 0;
	int judgenum_count2 = 0;
	int judgenum_count3 = 0;
	int judgenum_count4 = 0;
	int judgenum_count5 = 0;
	for(int i=0;i<N;i++)
	{
		if(a[0]==a[i])
		{
			judgenum_count1++;
		}
	   if(a[1]==a[i])
		{
			judgenum_count2++;
		}
		if(a[2]==a[i])
		{
			judgenum_count3++;
		}
		if(a[3]==a[i])
		{
			judgenum_count4++;
		}
		if(a[4]==a[i])
		{
			judgenum_count5++;
		}
	}
	int num = judgenum_count5+ judgenum_count4+judgenum_count3+judgenum_count2+judgenum_count1;
	cout<<"num="<<num<<endl;
	if(num==17)
	{
		cout<<"你拿到了炸弹---4个一样的"<<endl;
		return ;
	}
	else if(num == 13)
	{
		cout<<"你拿到了3带2---3个一样的"<<endl;
		return ;
	}
	else if(num == 9)
	{
		cout<<"你拿到了2个对子"<<endl;
		return ;
	}
	else if(num == 6)
	{
		cout<<"你拿到了1个对子"<<endl;
		return ;
	}
	else
	{
		judgementshunzi(a,ss);
	}
}
int main()
{
	int a[N]= {0};
	string  ss;
	cout<<"请输入牌的花色："<<endl;
	cin>>ss;
	cout<<"请输入牌的大小："<<endl;
	for(int i = 0;i<N;i++)
	{
		cin>>a[i];
	}
	cout<<endl;
#if 0
	for(int i = 0;i<N;i++)
	{
		cout<<a[i];
		cout<<ss[i];
	}
	cout<<endl;
#endif
	judgement(a,ss);
}
#endif

/*

10、CSDN-电报内容为空字符串
假设电报中用点（.）表示1，用中划线（-）表示0，点与中划线的序列，能够翻译成一个二进制数（可以看做无符号数）。将此二进制转换为整数后，通过一个映射表，可以将整数映射成一个英文字母。多个点、中划线序列间，用#隔开（多个连续的#号，算作一个#号），表示多个英文字母。
当电报中没有点、中划线，只有#时，电报内容为空字符串。
每个点、中划线序列，可以看做是无符号数。如果有点、中划线序列的二进制值超出如下映射表的范围，则输出”ERROR”。
映射表：

请将输入的点、中划线序列集合，转换为英文字母集合。
输入描述:
由点（.）、中划线（-）、#集合构成的原始报文。输出描述:
经过转换后生成的英文字符序列（英文区分大小写）

二进制值超出如下映射表的范围，则输出”ERROR”
示例1
输入
复制
–.#.#-.-
输出
复制
GGR

*/
//代码:

#if 0
	#include 
	#include 
	#include 
 
	char NumToInt(unsigned int number)
	{
		char map[] = { 'F', 'G', 'R', 'S', 'T', 'L', 'M', 'N', 'O', 'P', 'Q',\
			'W', 'X', 'Y', 'Z', 'U', 'A', 'G', 'H', 'I', 'J', 'K',\
			'B', 'C', 'D', 'E', 'l', 'm', 'n', 'o', 'p', 'i', 'j', 'k', 'f', 'g', 'h',\
			'a', 'b', 'c', 'd', 'e', 'q', 'r', 'w', 'x', 'y', 'z', 's', 't', 'u', 'v' };
 
		return map[number];
	}
 
	bool anylise(std::vector<unsigned int> value, char &character)
	{
		if (value.size() == 0)
			return true;
 
		unsigned int result=0;
		for (unsigned int i = 0; i < value.size(); i++)
		{
			result += value[i] << (2, value.size() - i-1);
		}
		if (result > 52 )
			return false;
		character = NumToInt(result);
		return true;
	}
 
	void test(const char* str, unsigned int len)
	{
		int count = 0; //num of #
		std::vector<unsigned int> num;
 
		for (unsigned int i = 0; i < len; i++)
		{
			switch (str[i])
			{
			case '.':
				num.push_back(1);
				count = 0;
				break;
			case '-':
				num.push_back(0);
				count = 0;
				break;
			case '#':
				if (count == 0 && num.size() >0)
				{
					char character = ' ';
					bool success = anylise(num, character);
					num.clear();
					if (success)
						std::cout << character;
					else
						std::cout << "ERROR";
					count++;
				}
				break;
			default:
				break;
			}
		}
		char cha = ' ';
		bool success = anylise(num, cha);
		num.clear();
		if (success)
			std::cout << cha;
		else
			std::cout << "ERROR";
	}
 
	int main(int argc, char** argv)
	{
		std::string s("--.");
		test(s.c_str(), s.length());
 
		return 0;
	}


#endif

/*
11、CSDN-华为机试（仿LISP字符串运算）
仿LISP字符串运算
时间限制：3秒
空间限制：32768K
题目描述
LISP语言唯一的语法就是括号要配对。
形如 (OP P1 P2 …)，括号内元素由单个空格分割。
其中第一个元素OP为操作符，后续元素均为其参数，参数个数取决于操作符类型
注意：参数 P1, P2 也有可能是另外一个嵌套的 (OP P1 P2 …)
当前OP类型为 quote / reverse / search / combine 字符串相关的操作：

• quote: 引用一个字符串，即返回字符串本身内容
  参数个数 1
• reverse: 把字符串反转，并返回
  参数个数 1
• search: 在第一个字符串中查找第二个字符串的第一次出现，返回从这开始到结束的所有字符串
  如果查找不到，返回空字符串
  参数个数 2
• combine: 把所有字符串组合起来
  参数个数不定，但至少 1 个
  其中P1, P2 等参数可能是带双引号的字符串,如 “abc”，也有可能是另外一个 (OP P1 P2 …)
  上述字符串包括引号；引号中间的所有字符，均为 ASCII 可打印字符，且不会再出现引号 (“)
  输出也为带双引号的字符串
  举例:
  输入字符串 输出结果
  (quote “!@#%”
  (reverse “a b c”) “c b a”
  (search “abcdef” “cd” ) “cdef”
  (search “abcdef” “xy” ) “”
  (combine “a” “b” “cde) “) “abcde) ”
  (search (combine “1234567890” “abcdefgh” “1234567890”) (reverse “dc”)) cdefgh123456789

输入描述:
合法C字符串，字符串长度不超过512；用例保证了无语法错误.

输出描述:
合法C字符串，需要带括号

输入例子:
(search “huawei” “we”)

输出例子:
“wei”
*/

//代码：
#if 0
#include 
#include 
#include 
#include 
#include 

int main()
{
    char chs[512];
    gets(chs);
    //在牛客OJ上，用std::getling(std::cin, str);会出错
    std::string str(chs);
    std::stack<std::string> op;
    std::stack<std::string> strs;
    for (int i = 0; i < str.size();)
    {
        if (str[i] == ' ')
        {
            i = i + 1;
            continue;
        }
        if (str[i] == '(')
        {
            strs.push(std::string("("));
            int spaceIndex = str.find(' ', i);
            std::string tmp = str.substr(i + 1, spaceIndex - i - 1);
            op.push(tmp);
            i = spaceIndex;
        }
        else if (str[i] == ')')
        {
            std::string curOp = op.top();
            op.pop();
            std::vector<std::string> tmps;  //存放操作的字符串
            while (strs.top() != "(")
            {
                tmps.push_back(strs.top());
                strs.pop();
            }
            strs.pop();
            if (curOp == "quote")
            {
                strs.push(tmps.back());
            }
            else if (curOp == "reverse")
            {
                std::reverse(tmps.back().begin(), tmps.back().end());
                strs.push(tmps.back());
            }
            else if (curOp == "search")
            {
                std::string str1 = tmps.back();
                std::string str2 = tmps[tmps.size() - 2];
                auto index = str1.find(str2);
                if (index == std::string::npos)
                {
                    strs.push("");
                }
                else
                {
                    strs.push(str1.substr(index));
                }
            }
            else if (curOp == "combine")
            {
                std::string tmp;
                for (int i = tmps.size() - 1; i >= 0; --i)
                {
                    tmp += tmps[i];
                }
                strs.push(tmp);
            }
            ++i;
        }
        else
        {
            auto index = str.find('"', i + 1);
            strs.push(str.substr(i + 1, index - i - 1));
            i = index + 1;
        }
    }

    std::cout << "\"" << strs.top() << "\"" << std::endl;

    system("pause");
    return 0;
}

#endif

/*
12、CSDN-华为集五福机试题
题目：以0和1组成的长度为5的字符串代表每个人所得到的福卡，每一位代表一种福卡，1表示已经获得该福卡，单类型福卡不超过1张，随机抽取一个小于10人团队，求该团队最多可以集齐多少套五福？
输入描述:
输入若干个"11010"、”00110"的由0、1组成的长度等于5位字符串,代表的指定团队中每个人福卡获得情况
注意1：1人也可以是一个团队
注意2：1人可以有0到5张福卡，但福卡不能重复
输出描述:
输出该团队能凑齐多少套五福
示例1
输入
11001
输出
0
*/
//代码：

#if 0
#include
#include
//集齐五福多少套
//给出0 1 序列
using namespace std;
int fu(string &str){
	//cout << str << endl;
	int matrix[6]={0};
	//int people_num = 1;
	int fu_num = 1;
	for (auto i : str){
		if (i == '1')
		{
			//cout << 'i ' << i << endl;
			matrix[fu_num] = matrix[fu_num] + 1;
			fu_num = fu_num + 1;
		}
		else if (i == '0')
		{
			fu_num = fu_num + 1;
		}
		else{
			fu_num = 1;
			continue;
		}	
	}
	int min_num = matrix[1];
	for (int j = 1; j < 6; j++){
		if (min_num > matrix[j]){
			min_num =  matrix[j];
		}
		cout << matrix[j] << endl;
	}
	return min_num;
}
 
int main(){
 
	string str = " 01010 10101 11100 11111 00011";
	//01101 00011 10100
 
	int maxum;
	maxum = fu(str);
	cout << maxum << endl;
	while(1);
	return 0;
}
#endif

/*
13、CSDN-python3 算法题：七进制加法

*/

/*
14、CSDN-华为笔试算法：清一色胡牌问题
题目描述：
清一色是麻将番种之一，指由一种花色的序数牌组成的和牌.
数字1-9，每个数字最多有4张牌
我们不考虑具体花色，我们只看数字组合。
刻子：三张一样的牌；如: 111, 222, 333, …, 999
顺子：三张连续的牌；如: 123, 234, 345, …, 789
对子：两张相同的牌；如: 11, 22, 33, …, 99
需要实现一个程序，判断给定牌，是否可以和牌（胡牌）。
和牌要求：

麻将牌张数只能是 2, 5, 8, 11, 14
给定牌可以组合成，除1个对子以外其他都是刻子或顺子
举例： - “11” -> “11”, 1对子，可以和牌
“11122233” -> “111”+“222”+“33”, 2刻子，1对子，可以
“11223344567” -> “11”+“234”+“234”+“567”, 1对子，3顺子，可以
-> “123”+“123”+“44”+“567”, 另一种组合，也可以
输入描述:
合法C字符串，只包含’1’-‘9’，且已经按从小到大顺序排好；字符串长度不超过15。同一个数字最多出现4次，与实际相符。
输出描述:
C字符串，“yes"或者"no”
示例1
输入
2244
输出
24 //此处是试题原本模样,应该输出no
*/
//代码：

#if 0
#include 
#include 
using namespace std;

// 判断麻将是否和牌
bool canSuccess(const string &s) {
	// 字符串长度不符合
	if (s.length() < 2 || s.length() >= 15) return false;
	// 剩下的2张牌为对子则和牌否则不能和牌
	if (s.length() == 2) return s[0] == s[1];
	bool flag = false;
	auto begin= s.begin(), end = s.end();
	while (end - begin > 2)
	{
		// 判断是否有刻子
		if (*begin == *(begin + 1) && *begin == *(begin + 2))
		{
			// 去掉刻子后递归处理
			string tmp1(s.begin(), begin);
			string tmp2(begin + 3, end);
			flag |= canSuccess(tmp1 + tmp2);
		}
		// 判断是否有顺子
		else if (*begin + 1 == *(begin + 1)) {
			// 顺子中间的牌可能有多张相同的，遍历找到第一个不同的
			int midSameCount = 0;
			char mid = *(begin + 1);
			auto iter = begin + 1;
			while (*iter == mid)
			{
				midSameCount++;
				// 如果递归到字符串末则标记后退出循环
				if (++iter == end)
				{
					midSameCount = -1;
					break;
				}
			}
			// 处理有顺子的情况
			if (midSameCount > 0 && mid + 1 == *iter) {
				// 去掉顺子后递归处理
				string tmp1(s.begin(), begin);
				string tmp2;
				tmp2.insert(0, midSameCount - 1, mid);
				string tmp3(iter + 1, end);
				flag |= canSuccess(tmp1 + tmp2 + tmp3);
			}

		}
		++begin;
	}
	return flag;
}

int main()
{
	string input;
	getline(cin, input);
	bool flag = canSuccess(input);
	cout << (flag ? "yes" : "no") << endl;
}
#endif
/*

15、CSDN-华为机试题目：删除重复字符

*/
//代码：

#if 0
#include 
#include 
 
//pInputStr中是原来待处理的字符串，m是其大小
//pOutputStr是删除重复后的字符串，其大小用n返回
void RemoveRepeatChar(const char* pInputStr, int m,char* pOutputStr, int* n)
{
	int k = 0;	//开始时，pOutputStr是空的，所以赋值0
	//遍历pInputStr中的字符
	for( int i = 0; i < m; i++)
	{
		char Test_char = pInputStr[i];	//检测这个字符是否出现过
		int j =0; //用于遍历pOutputStr
		for( j = 0; j  < k; j++)
		{
			//如果有重复的字符，直接结束循环
			if( pOutputStr[j] == Test_char)		
				break;
		}
 
		//判断Test_char是否出现过，如果j遍历到了最后，那么一定没有重复了
		if( j == k)
		{
			pOutputStr[k] = Test_char;
			k++;	//长度加1
		}
	}
 
	//遍历结束， 在pOutputStr后面加'\0'
	pOutputStr[k] = '\0';
	//将k赋值给n，返回
	*n = k;
}
 
 
//测试
int main()
{
	char buf[] = "abcdefbcd";
	char res[32];
	int k = 0; //用于返回res大小
	RemoveRepeatChar(buf,sizeof(buf),res,&k);
	printf("%s",res);
}


#endif

/*
16、CSDN-字符串压缩（华为）
通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。
压缩规则：
1、仅压缩连续重复出现的字符。比如字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc"。
2、压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz"。
要求实现函数：
void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr);
输入pInputStr ： 输入字符串lInputLen： 输入字符串长度
输出 pOutputStr ： 输出字符串，空间已经开辟好，与输入字符串等长；
注意： 只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例
输入：“cccddecc” 输出：“3c2de2c”
输入：“adef” 输出：“adef”
输入：“pppppppp” 输出：“8p”

*/
//代码：

#if 0
#include
#include
using namespace std;

void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr)
{
	char *tmp=new char[lInputLen+1];
	strcpy(tmp,pInputStr);
	int i=0,k=0,count=1;
	while(i<lInputLen)
	{
		if(tmp[i]==tmp[i+1])
		{
			count++;
		}
		else
		{
			if(count!=1)
			pOutputStr[k++]=count+'0';
			pOutputStr[k++]=tmp[i];
			count=1;
		}
		i++;
		
	}
	pOutputStr[k]='\0';
	delete []tmp;
}
 
void main()
{
	char p1[100];
	char p2[200];
	cin>>p1;
	stringZip(p1,strlen(p1), p2);
	cout<<p2<<endl;
	system("pause");
}


#endif

/*
17、CSDN-第一个只出现一次的字符
输入：
aadddsde
输出：
s

*/
//代码：

#if 0
 
#include
#include
#include
using namespace std;
int main()
{
    string str;
    while(getline(cin,str))
    {
        map<char,int>res;
        for(int i=0;i<str.size();i++)
        {
            res[str[i]]++;
        }
        for(int i=0;i<str.size();i++)
        {
            if(res[str[i]]==1)
            {
                cout<<str[i]<<endl;
                break;
            }
            //如果到最后一个元素还没有找到跳出，则输出“-1”
            if(i==str.size()-1)
                 cout<<"-1"<<endl;
        }
       
    }    
}
#endif

/*
18、CSDN-寻找字符串中出现次数最多的字符
问题：找出字符串(只含小写字母)中出现次数最多的字符，如果有多个出现次数最多，按字典序输出第一个
思路：先统计（按字典序）每个字符出现的次数，再按冒泡排序的第一趟将出现最多次的字符冒出来，这样可以保证字典序
复杂性分析：
时间O(n)：统计字符出现次数扫描一趟为n，冒泡第一趟为26个字符，故复杂度为26+n，即O(n)
空间O(1):只使用了26+3个额外变量空间，故为常数级
*/
//代码：
#if 0
/**
	@lkxiaolou
	找出字符串(只含小写字母)中出现次数最多的字符，
	如果有多个出现次数最多，按字典序输出第一个
**/
#include
#include
 
int sum[26];//记录每个字母出现的次数，初始为0
 
int main()
{
	char s[80];
	int i,len,max;
	printf("请输入字符串:\n");
	gets(s);
 
	len=strlen(s);
 
	for(i=0;i<len;i++)
	{
		sum[s[i]-97]++;
	}
	max=0;
 
	for(i=0;i<26;i++)
	{	
		if(sum[i]>sum[max]) max=i;
	}
 
	printf("出现最多的是%c\n",(max+97));
 
	return 1;
	
}
#endif

/*
19、CSDN-掷骰子游戏
问题描述：
在掷骰子游戏中，会根据所掷数字在地图中前进几步，前进完成后需要根据当前地图位置所示的障碍进行相应操作，其中障碍表示：
1） 9：无障碍
2） 1：停掷一轮，即下轮所掷数字无效； 3） 2：后退两步，如果已经到起点不再后退； 4） 3：奖励前进一步
如果在游戏过程中，已经走到地图终点，则游戏结束。根据输入的地图数组，和5个骰子数的数组，返回最终玩家前进了多少步。
要求实现函数：
void dice(int map_len, int* map, int* dice_val, int* output)
【输入】 int map_len，地图数组的长度
int* map，地图数组，值表示障碍
int* dice_val，5个骰子数的数组
【输出】 int *output，玩家共前进了多少步 【返回】 无
注：玩家是从起始位置开始，即地图数组的第一位，骰子数只能是1~6
示例
1） 输入：map_len = 15, map = {9,1,9,9,9,2,9,9,9,9,9,9,9,9,9}，dice_val = {1,2,1,3,1}，
返回：4 2） 输入：map_len = 16, map = {9,9,9,9,9,1,9,3,9,9,2,9,9,9,9,9}，dice_val = {2,1,4,1,6}，
返回：15

题意不清！！每次筛子zhi完一次后，是否只执行一次操作？？这里假设就一次操作
*/

//代码：

#if 0
#include 
using namespace std;
//void dice(int map_len, int* map, int* dice_val, int* output); 
void dice(int map_len,int *map,int *dice_val,int* output)
{
	int i;
	int j;
	j=0;
	int len=map_len;
	int suspend=0;
	for(i=0;i<5;i++)
	{
		if(suspend==1)
		{
			suspend=0;
			continue;
		}
		j+=dice_val[i];
		if(j>=len-1)
		{
			*output=len-1;
			return;
		}
		if(map[j]==2)
			j=((j-2<0)?(0):(j-2));
		else if(map[j]==3)
		{
			j+=1;
			if(j>=len-1)
			{
				*output=len-1;
				return;
			}
		}
		else if(map[j]==1)
			suspend=1;
	}
	*output=j;
	return;
}
int main(void)
{
	int map_len=15;
	int map[15]={9,1,9,9,9,2,9,9,9,9,9,9,9,9,9};
	int dice_val[5]={1,2,1,3,1};
	int output;
	dice(map_len,map,dice_val,&output);
	cout<<output<<endl;
	
 
	int map_len2=16;
	int map2[16]={9,9,9,9,9,1,9,3,9,9,2,9,9,9,9,9};
	int dice_val2[5]={2,1,4,1,6};
	int output2;
	dice(map_len2,map2,dice_val2,&output2);
	cout<<output2<<endl;
	system("pause");
	return 0;
}
#endif