华为机试题目 若干

闲着无聊，刷了几题华为机试题，适应下。

1 最小长方形

描述:

给定一系列2维平面点的坐标(x, y)，其中x和y均为整数，要求用一个最小的长方形框将所有点框在内。长方形框的边分别平行于x和y坐标轴，点落在边上也算是被框在内。

运行时间限制: 10 Sec

内存限制: 128 MByte

输入:

测试输入包含若干测试用例，每个测试用例由一系列坐标组成，每对坐标（x y) 占一行，其中|x|和|y|小于 1000；一对(0,0) 坐标标志着一个测试用例的结束。注意(0, 0)不作为任何一个测试用例里面的点。一个没有点的测试用例标志着整个输入的结束。

输出:

对每个测试用例，在1行内输出2对整数，其间用一个空格隔开。第1对整数是长方形框左下角的坐标，第2对整数是长方形框右上角的坐标。

如果只是一个点或者一条线，不输出。例如：

12 34

0 0

只是一个点，不是长方形，不输出。

样例输入:

12 56

23 56

13 10

0 0

12 34

0 0

0 0

样例输出:

12 10 23 56

/*
最小长方形
描述:	
给定一系列2维平面点的坐标(x, y)，其中x和y均为整数，要求用一个最小的长方形框将所有点框在内。长方形框的边分别平行于x和y坐标轴，点落在边上也算是被框在内。
运行时间限制:	10 Sec
内存限制:	128 MByte
输入:	
测试输入包含若干测试用例，每个测试用例由一系列坐标组成，每对坐标（x y) 占一行，其中|x|和|y|小于 1000；一对(0,0) 坐标标志着一个测试用例的结束。注意(0, 0)不作为任何一个测试用例里面的点。一个没有点的测试用例标志着整个输入的结束。
输出:	
对每个测试用例，在1行内输出2对整数，其间用一个空格隔开。第1对整数是长方形框左下角的坐标，第2对整数是长方形框右上角的坐标。
如果只是一个点或者一条线，不输出。例如：
12 34
0 0
只是一个点，不是长方形，不输出。
样例输入:	
12 56
23 56
13 10
0 0
12 34
0 0
0 0
样例输出:	
12 10 23 56
*/ 
#include<iostream>
#include<stdio.h>
using namespace std;
#define MAX 1005
int minLeft,minRight,maxLeft,maxRight;

int main()
{
	int a,b;
	//freopen("text.txt","r",stdin);
	while(scanf("%d%d",&a,&b)!=EOF)
	{
		if(a==0&&b==0)
			break;
		minLeft=minRight=MAX;
		maxLeft=maxRight=-MAX;
		
		minLeft=a<minLeft?a:minLeft;
		minRight=b<minRight?b:minRight;
		maxLeft=a>maxLeft?a:maxLeft;
		maxRight=b>maxRight?b:maxRight;
		
		int k=1;//点的个数
		while(scanf("%d%d",&a,&b))
		{
			if(a==0&&b==0)
				break;
			k++;
			minLeft=a<minLeft?a:minLeft;
			minRight=b<minRight?b:minRight;
			maxLeft=a>maxLeft?a:maxLeft;
			maxRight=b>maxRight?b:maxRight;
		} 
		
		if(k==1)
			continue;
		else
		{
			printf("%d %d %d %d\n",minLeft,minRight,maxLeft,maxRight);
		}
	}
	return 0;
}

2 判断一个数字中是否包含两个相同的子串

描述:

判断给定的一个数字，把它当成字符串以后，该字符串中是否包含相同的两个子串，子串的长度要求大于等于2。

比如：12123，该数字包含两个“12”子串；

又比如：1223122，该数字包含两个“122”子串。



运行时间限制: 无限制

内存限制: 无限制

输入:

待判断的正整型数字，最大长度为9。

输出:

0：不包含；

1：包含。



样例输入:

12123

样例输出:

1

/*
判断一个数字中是否包含两个相同的子串
描述:	
判断给定的一个数字，把它当成字符串以后，该字符串中是否包含相同的两个子串，子串的长度要求大于等于2。
比如：12123，该数字包含两个“12”子串；
又比如：1223122，该数字包含两个“122”子串。
 
运行时间限制:	无限制
内存限制:	无限制
输入:	
待判断的正整型数字，最大长度为9。
输出:	
0：不包含；
1：包含。
 
样例输入:	
12123
样例输出:	
1
*/
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define N 10
char str
;

int main()
{
	int a,b;
	//freopen("text.txt","r",stdin);
	while(scanf("%s",str)!=EOF)
	{
		int len=strlen(str);
		int flag=0;
		for(int i=0;i<len && flag==0 ;i++)
		{
			for(int j=i+1;j<len && flag==0;j++)
			{
				int l=i,r=j,k=0;
				while(str[l]==str[r])
				{
					l++;r++;
					k++;
				}
				if(k>=2)
					flag=1;
			}
		}
		if(flag==1)
			printf("1\n");
		else
			printf("0\n");
	}
	return 0;
}

3 取石子游戏

描述:

1堆石子有n个,两人轮流取.先取者第1次可以取任意多个，但不能全部取完.以后每次取的石子数不能超过上次取子数的2倍。

取完者胜.先取者负输出2.先取者胜输出1.

运行时间限制: 无限制

内存限制: 无限制

输入:

大于2的正整数。表示石子的个数

输出:

1或者2

样例输入:

3

样例输出:

2

/*
取石子游戏
描述:	
1堆石子有n个,两人轮流取.先取者第1次可以取任意多个，但不能全部取完.以后每次取的石子数不能超过上次取子数的2倍。
取完者胜.先取者负输出2.先取者胜输出1.
运行时间限制:	无限制
内存限制:	无限制
输入:	
大于2的正整数。表示石子的个数
输出:	
1或者2
样例输入:	
3
样例输出:	
2
*/ 
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int f[47];
//斐波那契数列 则第二人赢 

void getResult()
{
	f[0]=2;
	f[1]=3;
	for(int i=2;i<=45;i++)
	{
		f[i]=f[i-1]+f[i-2];
	}
}

int main()
{
	int a,flag;
	//freopen("text.txt","r",stdin);
	getResult();
	while(scanf("%d",&a)!=EOF)
	{
		flag=1;
		for(int i=0;i<46;i++)
		{
			if(f[i]==a)
			{
				flag=2;
				break;
			}
			if(f[i]>a)
				break;
		}
		printf("%d\n",flag);
	}
	return 0;
}

1 测试自动化6】城市电话号码

描述:

某城市电话号码由三部分组成，分别是：

地区码：空白或者三位数字；

前缀：非0开头的三位数字

后缀：4位数字

假定被测程序能接受一切符合上述规定的电话号码，输出0

拒绝一切不符合规定的电话号码，输出1.

请编写程序实现上述描述的功能.



运行时间限制: 10 Sec

内存限制: 200 MByte

输入:

地区码：空白或者三位数字；

前缀：非0开头的三位数字

后缀：4位数字



输出:

0或者1



样例输入:

111

111

1111

样例输出:

0

/*
【测试自动化6】城市电话号码
描述:	
某城市电话号码由三部分组成，分别是：
地区码：空白或者三位数字；
前缀：非0开头的三位数字
后缀：4位数字
假定被测程序能接受一切符合上述规定的电话号码，输出0
 拒绝一切不符合规定的电话号码，输出1.
请编写程序实现上述描述的功能.
 
运行时间限制:	10 Sec
内存限制:	200 MByte
输入:	
地区码：空白或者三位数字；
前缀：非0开头的三位数字
后缀：4位数字
 
输出:	
0或者1
 
样例输入:	
111
111
1111
样例输出:	
0
*/
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define N 10
char a
,b
,c
;
//题目描述 不严谨  空白？ 

int main()
{
	int i;
	//freopen("text.txt","r",stdin);

	while(gets(a))
	{
		gets(b);
		gets(c); 
		int flag=1;
		int lenA=strlen(a);
		int lenB=strlen(b);
		int lenC=strlen(c);
		if(!(lenA==0||lenA==3)||lenB!=3||lenC!=4)
			flag=0;
		if(flag==0)
			printf("1\n");
		else
		{
			for(i=0;i<lenA;i++)
				if(!(a[i]>='0'&&a[i]<='9')) 
					flag=0;
			if(b[0]=='0')
				flag=0;
			for(i=0;i<lenB;i++)
				if(!(b[i]>='0'&&b[i]<='9')) 
					flag=0;
			for(i=0;i<lenC;i++)
				if(!(c[i]>='0'&&c[i]<='9')) 
					flag=0;
			printf("%d\n",!flag);
		}
	}
	return 0;
}

2 超长正整数相加

描述:

题目描述：请设计一个算法完成两个超长正整数的加法。

要求实现函数：

void AddLongInteger(char * pcAddend, char * pcAugend, char * pcAddResult);

输入参数：

char * pcAddend：加数

char * pcAugend：被加数

char * pcAddResult：加法结果

返回值：无

运行时间限制: 1 Sec

内存限制: 128 MByte

输入:

两个超长正整数的字符串

输出:

相加后结果的字符串

样例输入:

123456789123456789 123456789123456789

样例输出:

246913578246913578

/*
超长正整数相加
描述:	
题目描述：请设计一个算法完成两个超长正整数的加法。 
要求实现函数：
  void AddLongInteger(char * pcAddend, char * pcAugend, char * pcAddResult);
输入参数：
        char * pcAddend：加数
        char * pcAugend：被加数
        char * pcAddResult：加法结果
返回值：无
运行时间限制:	1 Sec
内存限制:	128 MByte
输入:	
两个超长正整数的字符串
输出:	
相加后结果的字符串
样例输入:	
123456789123456789 123456789123456789
样例输出:	
246913578246913578
*/
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<string>
using namespace std;
#define N 100
char a
,b
;
//大数相加 

int main()
{
	int i;
	//freopen("text.txt","r",stdin);

	while(scanf("%s%s",a,b)!=EOF)
	{
		int len1=strlen(a),len2=strlen(b);
		string c;
		int i,j,t=0;
		for(i=len1-1,j=len2-1;i>=0&&j>=0;i--,j--)
		{
			t=a[i]-'0'+b[j]-'0'+t;
			c=(char)(t%10+'0')+c;
			t=t/10;
		}
		while(i>=0)
		{
			t=a[i]-'0'+t;
			c=(char)(t%10+'0')+c;
			t=t/10;
			i--;
		}
		while(j>=0)
		{
			t=b[j]-'0'+t;
			c=(char)(t%10+'0')+c;
			t=t/10;
			j--;
		}
		while(t>0)
		{
			c=(char)(t%10+'0')+c;
			t=t/10;
		}
		cout<<c<<endl;
	}
	return 0;
}

3 循环报数

描述:

输入1个数字和多个字符，中间均以空格隔开。假设数字取值为m（范围1~9），后面字符个数为n。假设n个字符围成一圈，从第一个字母开始循环报数，当数到m以后，第m个字母就出列，直到这n个字母全部出列。最后，按照出列的顺序输出这些字母，中间仍以空格隔开。取值范围：m为1到9， 字符个数n大于1小于20。

运行时间限制: 无限制

内存限制: 无限制

输入:

第一个为数字，后面为多个字符，均以空格隔开

输出:

输出重新排列后的字符，以空格隔开

样例输入:

3 a b c d e f g h i

样例输出:

c f i d h e b g a

答案提示:

建议采用循环链表

/*
循环报数
描述:	
输入1个数字和多个字符，中间均以空格隔开。假设数字取值为m（范围1~9），后面字符个数为n。假设n个字符围成一圈，从第一个字母开始循环报数，当数到m以后，第m个字母就出列，直到这n个字母全部出列。最后，按照出列的顺序输出这些字母，中间仍以空格隔开。取值范围：m为1到9， 字符个数n大于1小于20。
运行时间限制:	无限制
内存限制:	无限制
输入:	
第一个为数字，后面为多个字符，均以空格隔开
输出:	
输出重新排列后的字符，以空格隔开
样例输入:	
3 a b c d e f g h i
样例输出:	
c f i d h e b g a
答案提示:	
建议采用循环链表

AUTHOR:CIPHER
TIME:20150730
*/ 
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<string>
using namespace std;
//那就用循环链表试试
//对于你们的题目输入输出描述 我也是醉了 
#define N 50
char str
;

struct node{
	char val;
	struct node *next;
	node(int v)
	{
		val=v;
	}
	node(){
	}
}; 

int main()
{
	int m,i;
//	freopen("text.txt","r",stdin);

	while(gets(str))
	{
		m=str[0]-'0';	
		node *help=new node(1);
		node *head=help;
		int sum=0;
		int len=strlen(str);
	
		for(i=2;i<len;i++)
		{
			if(str[i]!=' ')
			{
				sum++;
				node *tmp=new node();
				tmp->val=str[i];
				head->next=tmp;
				head=head->next;
			}
		}
		head->next=help->next;//成环 
		
		node *pre=head;
		head=head->next;
		int k=1;
		
		while(sum>0&&head!=NULL)
		{
			if(k==m)
			{
				cout<<head->val;
				pre->next=head->next;
				head=pre->next;
				sum--;
				if(sum!=0)
					cout<<" ";
				k=1;
			}
			k++;
			pre=pre->next;
			head=head->next;
		}
		printf("\n");
		
	}
	return 0;
}

/*
最大递增数
2895345323
345
123526897215
2689
*/
#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
#define N 100
char ss
;

int main()
{
	while(scanf("%s",ss)!=EOF)
	{
		int k,j,len=strlen(ss);
		char max
="0";
		
		for(int i=0;i<len;i++)
		{
			char tmp
="0",
			k=0;
			tmp[k++]=ss[i];
			
			j=i+1;
			while(j<len&&ss[j]>ss[j-1])
			{
				tmp[k++]=ss[j];
				j++;
			}
			tmp[k]='\0';
			
			if(strlen(max)<strlen(tmp)||(strlen(max)==strlen(tmp)&&strcmp(max,tmp)<0))
			{
				strcpy(max,tmp);
			}
		}
		printf("%s\n",max);
	}
	return 0;
}
/*
最大递增数
2895345323
123526897215
11111
1
121221
111222
*/

/*
计算麻将的番数
1 1条2条3条
2 四张花色一样的 2番
3 巧七对，7对一样的牌 2番
番数相加
1T2T3T,4T5T6T,7T8T9T,1D2D3D,4D4D. 
1
*/
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define N 50
char str
;

int main()
{
	int ans,len,i,j;
	while(gets(str))
	{
		len=strlen(str);
		ans=0;
		
		//卡2条
		for(i=0;i<len;i++)
		{
			if(str[i]=='T')
			{
				if(str[i-1]=='2')
				{
					if(i-3>=0&&str[i-3]=='1')
						ans++;
				}
			}
		}
		
		//四归1，4张一样的牌 
		for(i=0;i<len;i++)
		{
			j=i;
			while(str[j]!=','&&str[j]!='.')
				j++;
			if(j-i==8)
			{
				ans+=2;
			}
			i=j;
		}
		
		//一组牌恰好7对 
		j=0;//对数 
		for(i=0;i<len;i++)
		{
			if(str[i]==','||str[i]=='.')
			{
				j++;
			}
		}
		if(j==7)
			ans++;
		printf("%d\n",ans);
	}
	return 0;
}
/*
3T4T5T,4T5T6T,7T8T9T,1D2D3D,4D4D.
1T2T3T,4T5T6T,7T8T9T,1D2D3D,4D4D.
1T2T3T,1T2T3T,1T2T3T,1D2D3D,4D4D.
2T2T2T2T,1T2T3T,7T8T9T,1D2D3D,4D4D.
2T2T2T2T,2T2T2T2T,2T2T2T2T,4D4D.
2T2T,4T5T,7T7T,1D1D,4D4D,2D2D,2T2T. 
*/

/*
单词迷宫 
字符查找 
5 5
SOLO
CPUCY
EKLQH
CRSOL
EKLQO
PGRBC
*/ 
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define N 100
#define M 25
char str
;
char map[M][M];
bool vis[M][M];
int m,n;

bool solve(int index,int x,int y)
{
	if(index==strlen(str))
		return true;
	if(x>=0&&x<n&&y>=0&&y<m&&map[x][y]==str[index]&&!vis[x][y])
	{
		vis[x][y]=1;
		index++;
		bool f=solve(index,x+1,y)||solve(index,x-1,y)||solve(index,x,y+1)||solve(index,x,y-1);
		if(f)
			return true;
		else
			vis[x][y]=0;
	}
	return false;
}

int main()
{
	int i,j;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		scanf("%s",str);
		for(i=0;i<n;i++)
		{
			scanf("%s",map[i]);
		}
		
		bool f=0;
		for(i=0;i<n && !f;i++)
		{
			for(j=0;j<m && !f;j++)
			{
				if(map[i][j]==str[0])
				{
					memset(vis,0,sizeof(vis));
					f=solve(0,i,j);
				}
			}
		}
		
		if(f)
			printf("YES\n");
		else
			printf("NO\n");
	}
	return 0;
}

/*
蛇形矩阵 
5
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11

*/
#include <iostream>
using namespace std;
int main()
{
	int y,x;
	int n;
	cin>>n;
	for(y=1; y<=n; y++)
	{
		for(x=1; x<=n-y; x++)
			cout<<((x+y-1)*(x+y-1)+(x+y-1))/2-y+1<<" ";
        cout<<((x+y-1)*(x+y-1)+(x+y-1))/2-y+1;
		cout<<endl;
	}
	return 0;
}

/*
单词倒排 
样例输入
I am a student
样例输入
student a am I
*/
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<string>
using namespace std;
#define N 25
char str
;

int main()
{
	while(gets(str))
	{
		int len=strlen(str);
		string ans;
		
		for(int i=len-1;i>=0;)
		{
			while(i>=0&&str[i]==' ')
				i--;
				
			string tmp;
			while(i>=0&&str[i]!=' ')
			{
				tmp=str[i]+tmp;
				i--;
			}
			
			if(ans.size()>0)
				ans+=' ';
			ans+=tmp;
		}
		cout<<ans<<endl;
	}
	return 0;
}

/*
判断字符串中的最长回文串
abdbdc
aaaaa
abcabca
abccba
a
aa
ab 
*/
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define N 50
#define INF 9999999

char str
;
int main()
{
	int i;
	while(gets(str))
	{
		int len=strlen(str);
		int max=-INF;
		int left,right;
		
		for(i=0;i<len;i++)
		{
			left=i-1;
			right=i+1;
			while(left>=0&&right<len&&str[left]==str[right])
			{
				left--;
				right++;
			}
			if(right-left-1>max)
			{
				max=right-left-1;
			}
			
			left=i;
			right=i+1;
			while(left>=0&&right<len&&str[left]==str[right])
			{
				left--;
				right++;
			}
			if(right-left-1>max)
			{
				max=right-left-1;
			}
		}
		
		printf("%d\n",max);
	}
	return 0;
}

/*
精确计算2的N次方;N(100=N=1000)
200
1606938044258990275541962092341162602522202993782792835301376
*/
#include<iostream>
#include<stdio.h>
using namespace std;
#define N 1000
int ans
;

int main()
{
	int n,k,i,j,tmp,t;
	while(scanf("%d",&n)!=EOF)//100<=N<=1000
	{
		memset(ans,0,sizeof(ans));
		k=0;
		ans[0]=1;
		
		for(i=1;i<=n;i++)
		{
			for(j=0;j<=k;j++)
				ans[j]*=2;
			t=0;
			for(j=0;j<=k;j++)
			{
				tmp=ans[j]+t;
				ans[j]=tmp%10;
				t=tmp/10;
			}
			if(t>0)
			{
				k++;
				ans[k]=t;
			}
		}
		
		for(i=k;i>=0;i--)
			printf("%d",ans[i]);
		printf("\n");
	}
	return 0;
}

/*
给定数组，奇数最大放中间，偶数，最大的放中间靠右位置，一左一右放剩下的数
5
3 6 1 9 7
6
3 6 1 9 7 8

3 7 9 6 1
1 6 8 9 7 3
*/
#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
#define N 50
int a
,ans
;

bool cmp(int a,int b)
{
	return a>b;
}

int main()
{
	int i,n,left,right,k;
	char arr
;
	while(scanf("%d",&n)!=EOF)//n>0
	{
//		itoa(n,arr,8);
//		for(i=0;i<strlen(arr);i++)
//			cout<<arr[i];
//		cout<<endl;
			
		for(i=0;i<n;i++)
			scanf("%d",&a[i]);
		sort(a,a+n,cmp);
		right=n/2;
		left=n/2-1;
		k=0;
		while(k<n)
		{
			ans[right]=a[k];
			k++;
			right++;
			if(k>=n)
				break;
			ans[left]=a[k];
			k++;
			left--;
		}	
		for(i=0;i<n-1;i++)
			printf("%d ",ans[i]);
		printf("%d\n",ans[i]);
	}
	return 0;
}

/*
表达式求值
输入字符串长度不超过100,包含+ —* / （ ）；  
*/

#include <iostream>
#include <string>
#include <stack>
#include "stdlib.h"
using namespace std;

int pri(char m)
{
	switch(m)
	{	case '+':
		case '-':
			return 1;
		case '*':
		case '/':
			return 2;
		case '(':
		case ')':
			return 0;
		case '#':
			return -1;
		default:
			break;
	}
}

int getResult(string s)
{
	stack<int>value;
	stack<char>fuhao;
	
	s=s+"#$";
	if(s[0]=='-')
		s="0"+s;
	int i=0;
	
	int c=0;
	while(s[i]!='$')
	{
		if(s[i]<='9'&&s[i]>='0')//数字 
		{
			c=s[i]-'0';
			i++;
			while(s[i]<='9'&&s[i]>='0')
			{
				c=c*10+s[i]-'0';
				i++;
			}
			i--;
			value.push(c);
			c=0;
		}
		else if(fuhao.size()==0||s[i]=='(' || pri(s[i])>pri(fuhao.top()))
			fuhao.push(s[i]);
		else if(s[i]==')')
		{
			for(;fuhao.top()!='(';fuhao.pop())
			{
				char d=fuhao.top();
				fuhao.pop();
				int a=value.top();
				value.pop();
				int b=value.top();
				value.pop();
				switch(d)
				{
					case '+':
						a=a+b;
						break;
					case '-':
						a=b-a;
						break;
					case '*':
						a=a*b;
						break;
					case '/':
						a=b/a;
						break;
					default:
						break;
				}
				value.push(a);
			}
		}
		else
		{
			for(;fuhao.size()!=0&&pri(s[i])<=pri(fuhao.top());)
			{	
				char d=fuhao.top();
				fuhao.pop();
				int a=value.top();
				value.pop();
				int b=value.top();
				value.pop();
				switch(d)
				{
					case '+':
						a=a+b;
						break;
					case '-':
						a=b-a;
						break;
					case '*':
						a=a*b;
						break;
					case '/':
						a=b/a;
						break;
				}
				value.push(a);
			}
			fuhao.push(s[i]);
		}
		i++;
	}
	return value.top();
}

int main(void)
{
	string a;
	while(cin>>a){
		cout<<getResult(a)<<endl;
	}
	return 0;
}

/*
最小公倍数 
*/
#include <iostream>
using namespace std;
int gdc(int x,int y)
{
	return (!y)?x:gdc(y,x%y);
}
int main()
{
	int a,b;
	while(cin>>a>>b)
	{
		cout<<(a*b)/gdc(a,b)<<endl;
	}
	
	return 0;
}

/*
编程实现，将输入字符串字符按如下规则排序
1：英文字母A到Z排序，不区分大小写
2: 同一个英文字符大小写同时存在时，按照输入排序
3: 说非英文字符位置不变 

A Famous Saying: Much Ado About Nothing (2012/8).

A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8). 
*/
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define N 100
char str
;

int main()
{
	int i,j;
	while(gets(str))
	{
		int len=strlen(str);
		for(i=0;i<len;i++)
		{
			if( (str[i]>='a'&&str[i]<='z') || (str[i]>='A'&&str[i]<='Z'))
			{
				char a=tolower(str[i]);
				for(j=0;j<i;j++)
				{
					if( (str[j]>='a'&&str[j]<='z') || (str[j]>='A'&&str[j]<='Z'))
						if(tolower(str[j])>a)
						{
							char tmp=str[i];
							str[i]=str[j];
							str[j]=tmp;
						}
				}
			}
		}
		printf("%s\n",str);
	}
	return 0;
}