王道c语言

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/*
	1.整型变量 

int main()
{
	int i=7;
	short s=0x80fb;
	long l=10;//32位long是4字节 ，64位的8个字节 
	long long l2=20;//32为的是8个，64位是8个字节 
	unsigned short us=0x80fb;
}*/ 

/*
	5.scanf读取标准输入 
	%d %f可以忽略\n 
	缓冲区快满的时候系统自动刷新到屏幕 
	print中加\n或者用system("pause")可以将数据强制刷新到标准输出 

int main()
{
	int i,j;
	char c;
	float f;
	scanf("%d",&i);
	printf("i=%d\n",i);
//	scanf("%f",&f);
//	printf("f=%f\n",f);
	scanf("%c",&c);
	printf("c=%c\n",c);
	system("pause");
	return 0;
}*/

/*
	6.while_scanf
  	stdin代表标准输入
  	fflush刷新标准输入，标准输出
  	fflush(stdin) 清空标准缓冲区 
  	13以上版本 rewind(stdin) 

int main()
{
	int i,j;
	int ret;
	while(fflush(stdin),(ret=scanf("%d%d",&i,&j))!=EOF)
	{
		printf("%d\n",ret);
		printf("i=%d\n",i);
	}
	system("pause");
	return 0;
}*/ 

/*
	7.整型，字符，浮点型混合输入 

int main()
{
	int i=5;
	double f;
	float l;
	char c;
	int ret;
	ret=scanf("%d %c%lf%f",&i,&c,&f,&l);
	printf("i=%d,c=%c,f=%lf,l=%f,ret=%d\n",i,c,f,l,ret);
	system("pause");
	return 0;
}*/ 

/*
	9.关系运算符
	单目运算符!>算术运算符>关系运算符>逻辑运算符 
	 
int main()
{
	int i;
	while(fflush(stdin),scanf("%d",&i)!=EOF)
	{
		if(3<i&&i<10)
		{
			printf("i is right\n");	
		}else{
			printf("i is not right\n");
		}
	}	
	system("pause");
	return 0;
}*/	
	
/*
	10.逻辑运算符
	单目运算符!>算术运算符
	&&>||
	判断闰年：能被4整除不能被100整除或能被400整除 
	C语言0为假，非0为真 
	
int main()
{
	int year;
	int i; 
//	while(scanf("%d",&year)!=EOF)
//	{
//		if(year%4==0&&year%100!=0||year%400==0)//!(year%100)
//		{
//			printf("%d is leap year\n",year);
//		}else{
//			printf("%d is not leap year\n",year);
//		}
//	}	
	i=0;//短路运算 
	i==0&&printf("system is error\n");//前面为真，后面打印 
	i=0;
	i==1||printf("|| system is error\n");//前面为假，后面打印 
	system("pause");
	return 0;
}*/	
	
/*
	11.位运算符 
	需要赋值i=i<<1 
	malloc(1<<30)申请1G内存 
	左移，高位丢弃，低位补0 ，为了乘2
	右移，正数 低位丢弃，高位补0，负数 低位丢弃，高位补1 除2，负奇数是减一除2 
	~按位取反就是：取反减1 
	
int main() 
{
	short i=-7;
	int j;
	int result=0;
	printf("before <<i=%d\n",i);
	i=i<<1;
	printf("i=%d\n",i);
	i=-7;
	printf("before >>i=%d\n",i);
	i=i>>1;
	printf("i=%d\n",i);
	int a[5]={13,6,7,13,6};
	for(i=0;i<5;i++)
	{
		result=result^a[i];//^按位异或,先化为二进制，再进行异或 
		printf("%d\n",result); 
	}
	printf("result=%d\n",result);
	i=5,j=7;
	printf("i&j=%d\n",i&j);//按位与 
	printf("i|j=%d\n",i|j);//按位或 
	printf("~i=%d\n",~i);//取反
	system("pause");
	return 0; 
}*/ 
	
/*
	12.条件运算符与逗号运算符	
	条件运算符 从右到左
	逗号运算符：整体的值是最后一个表达式的值 
	
int main()
{
	int i,j,k,max;
	while(fflush(stdin),scanf("%d%d%d",&i,&j,&k)!=EOF)
	{
		//max=(i>j?i:j)>k?(i>j?i:j):k;
		max=i>j?(i>k?i:k):(j>k?j:k);
		printf("max=%d\n",max);	
	}	
//	i=5;
//	j=(i,i+5);
	printf("%d\n",j); 
	system("pause");
	return 0;
}*/	
	
/*
	13.自增自减运算符 

int main()
{
	int i=-1;
	int j;
	j=i++>-1;
	printf("i=%d,j=%d\n",i,j);
	j=!++i;
	printf("i=%d,j=%d\n",i,j);
	i=0;
	j=!i++;
	printf("i=%d,j=%d\n",i,j);
	printf("%d\n",sizeof(i));
	j+=1;//j=j+1
	printf("%d\n",j);
	system("pause");
	return 0;
}*/ 

/*
	数据类型
	int 4
	short 2
	long 4 8
	
	float 4
	double 8 scanf("%lf")
	
	char 1
	
	scanf使用
	
	"%d %c%f",&i,&c,&f
	
	运算符与表达式
	算术运算符>关系运算符>逻辑运算符 逻辑与& 逻辑或|  
	
	左移 高位丢弃 地位补0 乘2 
	右移 地位丢弃 正数 高位补零 负数高位补1 除2-1
	
	异或运算符
	1个数与自己异或 零
	1个数与零异或 得到自身
	
	三目运算符
	i,j,max
	max=i>j?i:j; 
*/

/*
	14.if语句 

int main()
{
	int i;
	while(scanf("%d",&i)!=EOF)
	{
		if(i>0)//不能在if后加分号 
		{
			printf("i is bigger than 0\n");
		}else{
			printf("i is not bigger than 0\n");
		} 
	}
	system("pause");
	return 0;		
}*/
	
/*
	15.switch

int main()
{
	int year,mon;
	while(scanf("%d%d",&year,&mon)!=EOF)
	{
		switch(mon)
		{			
			case 2:printf("%d is %d days\n",mon,28+(year%4==0&&year%100||year%400==0));break;
			
			case 3:
			case 5:
			case 7:
			case 9:
			case 11:printf("%d is 30 days\n",mon);break;
				
			case 1:
			case 4:		
			case 6:
			case 8:		
			case 10:			
			case 12:printf("%d is 31 days\n",mon);break;
			default:printf("error mon\n");
		}
	}
	system("pause");
	return 0;
}*/

/*
	16.goto无条件转移 
	goto 只能在本函数内使用 
 
int main()
{
	int i=1;
	int total=0;
lable:
	total=total+i;
	i++;
	if(i<=100)
	{
		goto lable;
	} 
	printf("total=%d\n",total);
	system("pause");
	return 0;
}*/

/*
	17.goto向下跳转 

int main()
{
	int disk;
	scanf("%d",&disk);
	if(disk==0)
	{
		goto disk_error;
	} 
	//写磁盘操纵
	printf("write success\n");
disk_error:
	printf("system disk is error\n");
	system("pause");
	return 0; 
}*/ 

/*
	18.while循环 

int main()
{
	int i=1,total=0;
	while(i<=100)//不能加分号 
	{
		total=total+i;
		i++;//让表达式趋近于假 
	}
	printf("total=%d\n",total);
	system("pause");
	return 0;
}*/ 

/*
	19.do_while循环 

int main()
{
	int i=1;
	int total=0;
	do
	{
		total=total+i;
		i++;
	}while(i<=100);//这里必须加分号，否则编译不通
	printf("total=%d\n",total);
	system("pause");
	return 0; 
}*/ 

/*
	20.for循环 
	for语句的执行过程
	(1)先求解表达式1。
	(2)求解表达式2，若其值为真(值为非0)，则执行for
		语句中指定的内嵌语句，然后执行下面第(3)步。若
		为假(值为0)，则结束循环，转到第(5)步。
	(3)求解表达式3。
	(4)转回上面第(2)步骤继续执行。
	(5)循环结束，执行for语句下面的语句。 

int main()
{
	int i,total;
	for(i=1,total=0;i<=100;i++)//不会死循环，但不能加分号 
	{
		total=total+i;
	}
	printf("total=%d\n",total);
	system("pause");
	return 0;
}*/ 

/*
int main()
{
	int i,total;
	for(i=1,total=0;i<=100;i++)
	{
		if(!(i%2))//求1~100内的奇数和 
		{
			continue;//跳过本次循环 ，continue后面的语句不会得到执行，表达式3依然计算 
		}
		total=total+i; 
	}
	printf("total=%d\n",total);
	system("pause");
	return 0;
}*/  

/*
	21.计算日期是今年的第几天 
	//多层循环发生死循环，从最外层循环一次打断点，停到哪层，哪层有问题 
 
int main()
{
	int year,mon,day,total,i;
	int a[12]={31,28,31,30,31,30,31,30,31,30,31,30};
	while(scanf("%d%d%d",&year,&mon,&day)!=EOF)
	{
		total=0;
		for(i=0;i<mon-1;i++)
		{
			total=total+a[i];
		}
		total=total+day;
		if(mon>2)
		{
			total=total+(year%4==0&&year%100||year%400==0);
		}
		printf("%4d-%02d-%02d is %dth days\n",year,mon,day,total);
	}
	system("pause");
	return 0;
}*/

/*
	22.一维数组 
	1.具有相同的数据类型
	2.使用过程中需要保留原始数据 
	3.常量表达式中可以包括常量和符号常量，但不能包括变量 
	不能用变量说明数组大小
	int arr[N]={0}; 
	int arr[]={1,2,3,4,5};
	arr数组首地址
	&arr指针类型的数组首地址 
	每个函数执行时都要分配栈空间，执行完毕后释放栈空间。
	每个函数栈空间大小为1M 

#define N 5 
void print(int a[5],int len)
{
	int i;
	for(i=0;i<len;i++)
	{
		printf("%3d",a[i]);
	}
	a[4]=20;
	printf("\n");
} 
int main()
{
	int i=10; 
	int arr[N]={1,2,3,4,5};//后定义的变量在低地址 
//	arr[5]=6;访问越界 
//	arr[6]=7;
//	arr[7]=8;
//	arr[8]=9;
	printf("i=%d\n",i);
	print(arr,N);//一维传递时长度无法传递给函数 
	printf("a[4]=%d\n",arr[4]); 
	system("pause");
	return 0;
}*/

/*
	23.二维数组 

void print(int a[][4],int row)
{
	int i,j;
	for(i=0;i<row;i++)
	{
		for(j=0;j<sizeof(a[0])/sizeof(int);j++)
		{
			printf("%3d",a[i][j]);
		}
		printf("\n");
	}
	a[2][3]=50; 
}
int main()
{
	int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
	print(a,3);
	printf("a[2][3]=%d\n",a[2][3]);
	system("pause");
	return 0;
}*/  

/*
	24.字符数组 

int main()
{
	//char c[5]={'h','e','l','l','o'}; 
	char c[6]="hello";
	int i;
	printf("%s\n",c);
//	for(i=0;i<2;i++)
//	{
//		printf("%c",0xcc);//没有找到\0 
//	}
	printf("\n");
	system("pause");
	return 0;
}
*/
/*
int main()
{
	char c[20];		  //scanf自动赋结束符\0 
	char d[20];		  //忽略空格和\n 
	scanf("%s%s",c,d);//字符串对应的是字符数组名
	printf("%s---%s\n",c,d);
	system("pause");
}*/

/*
	25.gets与puts
	gets()函数从stdin(标准输入)读取字符并把它们加载到str(字符串)里，直到遇到新行(\n)
	或达到EOF。新行字符翻译为一个null中断符。gets()的返回值是读入的字符串，如果错误
	就返回null。 
	int puts(char *str);函数puts()把str(字符串)写到stdout(标准输出)上。put()成功返回
	非负值，失败时返回EOF。 

int main()
{
	char c[20];
	while(gets(c)!=NULL)
	{
		//printf("%s\n",c);
		puts(c);
	}
	system("pause"); 
}*/ 

/*
	26.str系列函数 
	
size_t mystrlen(char c[]) 
{
	int i=0;
	while(c[i]!='\0')//while(c[i++]) return i-1
	{
		i++;
	}
	return i;
}
int main()
{
	char c[10];
	char d[10];
	size_t len;
//	while(gets(c)!=NULL)
//	{
//		len=mystrlen(c);//只能统计字符串 
//		printf("%d\n",len);
//	}	
	scanf("%s%s",c,d);
//	strcpy(c,d);//d中的字符串复制给c
//	puts(c);
	printf("strcmp result=%d\n",strcmp(c,d));
	strcat(c,d);//将d连接到c 
	puts(c);
	system("pause"); 
}*/ 

/*
	float 占4个字节 
	27.指针 
	32位的系统，指针占4个字节
	64位的系统，指针占8个字节 
	指针的本质是 间接访问 
	取地址与取值操作符
		取地址操作符是&，也叫引用，通过该操作符我们可以获取一个变量的地址值；取值
		操作符为*，也叫解引用，通过该操作符我们可以拿到一个地址对应位置的数据。 
	指针的使用场景
		1.值传递
		2.偏移 

int main() 
{
	int i=10;
	int *i_pointer,*p;//i_pointer是指针变量 
	i_pointer=&i;
	printf("i=%d\n",i);//直接访问
	printf("*i_pointer=%d\n",*i_pointer);//间接访问 
	system("pause"); 
}*/

/*
	28.指针的传递 

void change(int *i)
{
	*i=5;//通过间接访问拿到变量i的空间 
}
//指针的传递，在子函数中改变主函数里的变量值 
int main()
{
	int i=10;
	printf("before change,i=%d\n",i);
	change(&i);
	printf("after change,i=%d\n",i);
	system("pause");
}*/ 

/*
	29.指针的偏移 
	我们把指针的加减，称之为指针的偏移，加就是向后偏移，减就是向前偏移 
	指针的类型必须是奇类型 +sizeof(int) 

int main()
{
	int a[5]={1,2,3,4,5};
	int *p;
	int index;
	p=a;
	for(index=0;index<5;index++)
	{
		//printf("%3d",*(p+index));
		//printf("%3d",*(a+index));
		printf("%3d",p[index]);
	}
	printf("\n");
	p=&a[4];
	for(index=0;index<5;index++)
	{
		printf("%3d",*(p-index));
	}
	printf("\n");
	system("pause");
}*/ 

/*
	30.指针与自增自减运算符
 
int main()
{
	int a[3]={2,7,8};
	int *p;
	int j;
	p=a;
	//j=*++p;
	j=*p++;//j=*p; p=p+1
	printf("a[0]=%d,j=%d,*p=%d\n",a[0],j,*p);
	j=p[0]++;//j=p[0]; p[0]=p[0]+1 
	printf("a[0]=%d,j=%d,*p=%d,a[1]=%d\n",a[0],j,*p,a[2]);
	system("pause");
}*/ 

/*
	31.指针与一维数组 
	栈空间由系统自动管理
	堆空间如果要用自己申请释放 
	堆的效率比栈低得多 
	
void change(char *p)
{
	*p='H';
	p[1]='E';
	*(p+2)='L';
}
int main()
{
	char c[10]="hello";
	change(c);
	puts(c);
	system("pause");
}*/

/*
	32.动态内存空间申请
	函数调用是值传递，调用函数时没有取地址，所以函数无法改变p的值 
	 
int main()
{
	int i;
	char *p;
	scanf("%d",&i);//要申请的空间大小 
	p=(char*)malloc(i);//申请堆空间 
	strcpy(p,"malloc success");
	puts(p);
	free(p);//无释放，就会内存泄露
	p=NULL;//free以后不赋为NULL，拿着指针去访问对应空间，称为野指针 
	system("pause"); 
}*/

/*
	33.free以后不赋为NULL 
 
int main()
{
	int *p,*p1,*p2;
	p=(int*)malloc(4);
	*p=1;
	p1=(int*)malloc(4);
	*p1=2;
	free(p);
	//p=NULL;
	p2=(int*)malloc(4);
	*p2=3;
	*p=100;
	printf("*p1=%d,*p2=%d\n",*p1,*p2);
	system("pause");
}*/

/*
	windows 函数栈 1M  262144字节 
	linux 函数栈 10M 
*/

/*
	34.堆与栈的差异 
	堆空间必须用free()函数才能够释放
	栈空间对由系统程序释放 

#define N 1000000
//int main()
//{
//	//int a[N];//栈溢出了 
//	int *a=(int*)malloc(4*N);//申请堆空间 
//	a[N-1]=10;
//	printf("%d\n",a[N-1]);
//	system("pause");
//} 
//栈空间函数执行结束就释放 
char* print_stack()
{
	char c[]="I am stack";
	puts(c);
	return c;
}
//堆空间不会因为函数的执行结束而释放 
char* print_malloc()
{
	char *p=(char*)malloc(20);
	strcpy(p,"I am malloc");
	puts(p);
	return p;
} 
int main()
{
	char *p;
	p=print_stack();//延迟推栈 
	puts(p);//栈空间重新分配给下一个函数使用 
	p=print_malloc();
	puts(p); 
	system("pause");
}*/


/*
	35.字符指针与字符数组的初始化 

int main()
{
	char *p="hello";//指向了字符串常量区的hello 
	char *p1=(char*)malloc(20);
	strcpy(p1,"hello");//拷贝到堆空间里的hello 可读可写 
	char c[10]="hello";//将字符串常量区的hello ctrcpy给了c栈空间，可读可写 
	c[0]='H';
	p1[0]='H';//p1="hello";内存泄露  变成常量区的hello 
	puts(p1);
	p="world";
	//c="world";//不行 
	strcpy(c,"world");
	c[0]='H';//不行 c是地址 
	printf("c=%s\n",c);//world 
	system("pause");
}*/ 

/*
	36.数组指针与二维数组
	数组指针每次加一偏移到下一排
	*(p+2)得到一个一维数组，整型指针类型 
	*(p+2)+1的值为11 
	*(*(p+2)+1)从二级指针变为一级指针 

void print(int (*p)[4],int row)
{
	int i,j;
	for(i=0;i<row;i++)
	{
		for(j=0;j<sizeof(*p)/sizeof(int);j++)
		{
			printf("%3d",p[i][j]);//*(*(p+i)+j)
		}
		printf("\n");
	}
}
int main()
{
	int b[4]={1,2,3,4};
	int a[3][4]={1,3,5,7,2,4,6,8,9,11,13,15};//a是数组指针 
	int (*p)[4];//定义数组指针
	p=a;
	print(p,3);
	system("pause"); 
}*/ 

/*
	题目 
	1.求数组的最大值和次大值 

int main()
{
	max1=a[0]>a[1]?a[0]:a[1];
	max2=a[0]<a[1]?a[0]:a[1];
	for(i=2;i<n;i++)
	{
		if(a[i]>max1)
		{
			max2=max1;
			max1=a[i];
		}else if(a[i]>max2)
		{
			max2=a[i];
		}
	}
}*/

/*
	2.打印菱形
	    *
	   * *
	  * * *
	 * * * *
	* * * * * 
	 * * * *
	  * * *
	   * *
	    * 

int main()
{
	int i,j;
	int n;
//	while(scanf("%d",&n)!=EOF)//
//	{
		for(i=0;i<9;i++)
		{
			for(j=0;j<(4-i>0?4-i:i-4);j++)
			{
				printf(" ");
			}
			for(j=0;j<9-2*abs(4-i);j++)
			{
				if(j%2)//=1奇数 
				{
					printf("%d",j%2);
				}else{//=0偶数 
					printf("*");
				}	
			}
			printf("\n");
		}
//	}
	system("pause");
}*/

/*
	3.给定一个含有n个元素的整型数组，找出数组中的两个元素x和y是的abs(x-y)
	值最小。 
	4.输入一行字符串，把字符串翻转
	Input:I_am_a_student
	Output:student_a_am_I
	1)直接翻转一下
	2)把每个单词找出来，原地自身翻转 
 
void reverse(char *start,char *end)
{
	char tmp;
	while(start<end)
	{
		tmp=*start;
		*start=*end;
		*end=tmp;
		start++;
		end--;
	}
}
int main()
{
	char c[500];
	while(gets(c)!=NULL)
	{
		reverse(c,c+strlen(c)-1);
		puts(c);
	} 
	system("pause");
}
void reverse(char *start,char *end)
{
	char tmp;
	while(start<end)
	{
		tmp=*start;
		*start=*end;
		*end=tmp;
		start++;
		end--;
	}
}
int main()
{
	char c[1000];
	while(gets(c)!=NULL)
	{
		reverse(c,c+strlen(c)-1);
		puts(c);
	}
}*/
/*
void reverse(char *start,char *end)
{
	char tmp;
	while(start<end)
	{
		tmp=*start;
		*start=*end;
		*end=tmp;
		start++;
		end--;
	}
}
int main()
{
	char c[500];
	char *ps,*pe;
	while(gets(c)!=NULL)
	{
		reverse(c,c+strlen(c)-1);
		//puts(c);
		ps=c;
		while(*ps)//循环 
		{
			while(*ps==' ')//找到一个单词的开头 
			{
				ps++;
			} 
			pe=ps;//找到单词的开头 
			while(*ps!=' ' && *ps)//到单词的尾部,保证不能是'\0'也不能是' ' 
			{
				ps++;
			}
			reverse(pe,ps-1); 
		}
		puts(c);
	} 
	system("pause");
} 
void reverse(char *start,char *end)
{
	char tmp;
	while(start<end)
	{
		tmp=*start;
		*start=*end;
		*end=tmp;
		start++;
		end--;
	}
}
int main()
{
	char c[500];
	char *ps,*pe;
	while(gets(c)!=NULL)
	{
		reverse(c,c+strlen(c)-1);
		ps=c;
		while(*ps)//循环 
		{
			while(*ps==' ')//找到一个单词的开头 
			{
				ps++; 
			} 
			pe=ps;//找到单词的开头 
			while(*ps!=' ' && *ps)//到单词的尾部，保证不能是'\0'也不能是' '
			{
				ps++;
			} 
			reverse(pe,ps-1);
		}
		puts(c);
	}
	system("pause");
}*/
/*
	int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
	int (*p)[4];
	p=a;
	*(p+1)
	a[1]

	a	0x2000
	&a+1	0x2030
	int i;
*/

/*
	1.二级指针
	使用场景：传递与偏移 
		
//二级指针的传递，在子函数改变主函数某一个一级指针变量的值
void change(int **p2,int *pj)
{
	*p2=pj;
} 
int main()
{
	int i=10;
	int j=5;
	int *pi=&i;
	int *pj=&j;
	printf("i=%d,j=%d,*pi=%d,*pj=%d\n",i,j,*pi,*pj);
	change(&pi,pj);
	printf("i=%d,j=%d,*pi=%d,*pj=%d\n",i,j,*pi,*pj);
	system("pause"); 
}*/ 

/*
	2.二级指针的偏移 (索引排序)
	&p[0]对任何一个元素取地址，就变成一个二级指针了
	二级指针偏移与指针数组完美对应，服务于以及指针，偏移一个就可以访问到下一个
	一级指针的元素
	p+1偏移一个指针元素位置的大小 
 
#define N 5
int main()
{
	char b[5][15]={"Google","Facebook","Linkin","Amazon","Microsoft"};
	char *p[5];//二级指针 
	char **p2=(char **)malloc(20);//模拟实现指针数组，在堆上 
	//char **p2;//二级指针
	int i,j;
	char *tmp;
	for(i=0;i<N;i++)
	{
		p2[i]=b[i];//恰好每个一位数组中存的就是一个字符指针类型的地址 
		//*(p2+i)=b[i];
	} 
	//p2=p;
	for(i=0;i<N;i++)
	{
		puts(b[i]);
	} 
	//索引式排序
	for(i=N-1;i>0;i--)
	{
		for(j=0;j<i;j++)
		{
			if(strcmp(p2[j],p2[j+1])==1)
			{
				tmp=p2[j];
				p2[j]=p2[j+1];
				p2[j+1]=tmp;
			}
		}
	} 
	printf("sort ok--------\n");
	for(i=0;i<N;i++)
	{
		puts(p2[i]);
	}
	printf("---------------\n");
	for(i=0;i<N;i++)
	{
		puts(b[i]);
	}
	system("pause");
}*/

/*
	3.函数指针
	 
void b()
{
	printf("I am func b\n");
}
void a(void (*p)())
{
	p();
}
//传递的一种行为 
int main()
{
	void (*p)();//定义一个函数指针
	p=b;
	a(b);
	system("pause"); 
}*/ 

/*
	4.函数调用
	<>直接到系统默认的头文件目录中搜索 
	""先搜索当前目录 ，再到系统默认的头文件目录中搜索
#include "func.h"
//函数定义
int printstar(int i)
{
	printf("*********\n");
	printf("printstar=%d\n");
	return i+3;
} 
-----------------------------
#include "func.h"
int main()
{
	int a=10;
	a=printstar(a);
	printstar(a);
	system("pause");
}*/

/*
	5.全局变量 

int i=10;
void print(int i,int j)
{
	printf("print i=%d\n",i);
}
int main()
{
	int i=15;
	printf("main i=%d\n",i);
	i=5;
	print(i,i++);
	system("pause");
}*/

/*	
	6.嵌套调用 
	main函数调用a函数，a函数调用b函数，然后b回到a，a回到main 
	上下文：寄存器里面的数据 
  
#include<setjmp.h> 
void b(jmp_buf *envbuf)
{
	printf("I am b func\n");
	longjmp(*envbuf,5);//跳回setjmp，初始没有返回值，这里设置返回值为5 
}
void a(jmp_buf *envbuf)
{
	printf("before b I am a func\n");
	b(envbuf);
	printf("after b I am a func\n");
}
int main()
{
	jmp_buf envbuf;//保存程序执行的上下文 局部变量 
	int ret;
	ret=setjmp(envbuf);//第一次返回值为零，会死循环 
	if(0==ret)
	{
		a(&envbuf);//传地址效率高 
	} 
	system("pause");
}*/

/*
	7.递归调用 
 
int f(int n)//递归 
{
	if(1==n)
	{
		return 1;
	}
	if(2==n)
	{
		return 2;
	}
	return f(n-1)+f(n-2);
}
int f_no(int n)
{
	int first=1;
	int second=2;
	int i;
	int total;
	for(i=2;i<n;i++)
	{
		total=first+second;
		first=second;
		second=total;
	}
	return total;
} 
int main()
{
	int n;
	while(scanf("%d",&n)!=EOF)
	{
		printf("%d!=%d\n",n,f_no(n));
	}
	system("pause");
}*/

/*
	汉诺塔 
	1.将A上n-1个盘借助C座先移到B座上
	2.把A座上剩下的一个盘移到C座上
	3.将n-1个盘从B座上借助于A移到C座上 

//定义hanoi函数，将n个盘从one座借助two座，移到three座 
void hanoi(int n,char one,char two,char three)
{
	void move(char x,char y);//对move函数的声明 
	if(n==1) move(one,three);
	else
	{
		hanoi(n-1,one,three,two);
		move(one,three);
		hanoi(n-1,two,one,three);
	} 
} 
void move(char x,char y)
{
	printf("%c-->%c\n",x,y);
}
int main()
{
	void hanoi(int n,char one,char two,char three);
	//对hanoi函数的声明 
	int m;
	printf("input the number of diskes:");
	while(scanf("%d",&m)!=EOF)
	{
		printf("The step to moveing %d diskes:\n",m);
		hanoi(m,'A','B','C');
	}	
	system("pause"); 
}*/

/*
	9.变量的作用域
	局部变量：只在离自己最近的大括号内有效。
	1)不同函数中可以使用相同名字的变量，他们代表不同的对象，互不干扰。
	2)形式参数也是局部变量。
	3)在一个函数内部，可以在复合语句中定义变量，这些变量只在本复合语句中有效。 
	全局变量：从定义变量的位置开始到本源文件结束。
	1)全局变量在程序的全部执行过程中都占用存储单元。
	2)使用全局变量过多，会降低程序的清晰性。
	3)降低函数的通用性。 
 
int main()
{
	int i=10;
	{
		int j=5;
	} 
	printf("i=%d,j=%d\n",i,j);
	system("pause");
}*/ 

/*
//不能把全局变量写在头文件func.h当中 
#include"func.h"
//借用其他文件的全局变量 
//extern int k;
//static 修饰函数，函数只在本文件内有效 
static void print()
{
	static int i=0;//静态局部变量，只会初始化一次
	i++;
	printf("i=%d\n",i); 
	//printf("I am print k=%d\n",k);
} 
----------------------
#include"func.h"
int k=10;//全局变量
int main()
{
	int i=10;
	{
		int j=5;//局部变量只在离自己最近的大括号内有效 
	}
	//print("i=%d\n",i);
	print();
	print();
	system("pause"); 
}*/ 	

/*
	static可以用来修饰：局部变量、全局变量、函数 
	静态存储方式：指在程序运行期间由系统分配固定的存储空间的方式。
	动态存储方式：则是在程序运行期间根据需要进行动态的分配空间的方式。 
	函数存储在栈空间，执行结束灰飞烟灭
	静态局部变量存储在静态区，只会初始化一次 
*/

/*
int main()
{
	int arr[3]={0};
	char *p[3]={"alp","num","oth"};
	char *init[3]={"alp","num","oth"};
	char c,*p_tmp;
	int i,j,tmp;
	while(scanf("%c",&c)!=EOF)
	{
		if(c>='A' && c<='Z' || c>='a' && c<='z')
		{
			arr[0]++;
		}else if(c>='0'&&c<='9')
		{
			arr[1]++;
		}else if(c!='\n')
		{
			arr[2]++;
		}
		if(c=='\n')
		{
			for(i=2;i>0;i--)//排序
			{
				for(j=0;j<i;j++)
				{
					if(arr[j]<arr[j+1])
					{
						tmp=arr[j];
						arr[j]=arr[j+1];
						arr[j+1]=tmp;
						p_tmp=p[j];
						p[j]=p[j+1];
						p[j+1]=p_tmp;
					}
				}
			} 
			//printf("%5d %5d %5d\n",arr[0],arr[1],arr[2]);
			for(i=0;i<arr[0]+1;i++)//每一行
			{
				if(0==i)//第一列
				{
					printf("%3d   ",arr[0]);
				}else{
					printf("***** ");
				} 
				if(i==arr[0]-arr[1])//第二列
				{
					printf("%3d   ",arr[1]);
				}else if(i>arr[0]-arr[1])
				{
					printf("***** ");
				}
				if(i==arr[0]-arr[2])//第三列
				{
					printf("%3d",arr[2]); 
				}else if(i>arr[0]-arr[2])
				{
					printf("*****");
				} 
				printf("\n");
			} 
			printf("%4s  %4s  %4s\n",p[0],p[1],p[2]);
			memset(arr,0,sizeof(arr));//将数组内的值全部设为0 
			memcpy(p,init,sizeof(p));//将init首地址拷贝给p，因为数组里不是字符串，所以不能用strcpy 
		}
	}
	system("pause");
}*/

/* 
int main()
{
	int a[8]={11,6,4,7,6,4,11,20};
	int b[8]={0};
	int c[8]={0};
	int i;
	int res=0;//结果
	for(i=0;i<8;i++)
	{
		res=res^a[i];//异或 
	} 
	printf("res=%d\n",res);
	system("pause");
}*/

/*
	找出出现一次的两个数

int main()
{
	int a[8]={11,6,4,7,6,4,11,20};
	int first=0;
	int second=0;
	int partition=1;
	int i,j=0,k=0;
	int res=0;//结果
	for(i=0;i<8;i++)
	{
		res=res^a[i];
	} 
	printf("res=%d\n",res);//异或结果
	for(i=0;i<31;i++)
	{
		if(res&partition) 
		{
			break;
		}
		partition=partition<<1;
	} 
	for(i=0;i<8;i++)//分组
	{
		if(a[i]&partition)//奇数 相当于a[i]%2 
		{
			first=first^a[i];
		}else{//偶数 
			second=second^a[i];
		}
	} 
	printf("%d %d\n",first,second);
	system("pause");
}*/

/*
	1.结构体
	结构体是值传递，直接将值拷贝给子函数，不同于数组的地址传递 
	1001 Lilei M 18 98.50 BeiJing
	1001 Lilei M 18 98.50 BeiJing
	1001 Lilei M 18 98.50 BeiJing
		
struct student//sizeof(struct student)=68
{
	int num;
	char name[20];
	char sex;
	int age;
	float score;
	char addr[30]; 
};
int main()
{
	struct student s1={1001,"Lilei",'M',18,98.5,"BeiJing"};
	struct student sarr[3];
	int i;
	printf("%d %s %c %d %5.2f %s\n",s1.num,s1.name,s1.sex,s1.age,s1.score,s1.addr);
	for(i=0;i<3;i++)
	{
		scanf("%d%s %c%d%f%s",&sarr[i].num,sarr[i].name,&sarr[i].sex,&sarr[i].age,&sarr[i].score,&sarr[i].addr);
	
	}
	printf("------------------------------------\n");
	for(i=0;i<3;i++)
	{
		printf("%d %s %c %d %5.2f %s\n",sarr[i].num,sarr[i].name,sarr[i].sex,sarr[i].age,sarr[i].score,sarr[i].addr);	
	}
	
	system("pause");
}*/	
	
/*
	2.结构体指针 

struct student
{
	int num;
	char name[20];
	char sex;
};
int main()
{
	struct student s={1001,"Hulu",'M'};
	struct student sarr[3]={1001,"Zhangsan",'M',1005,"Lisi",'M',1007,"wangwu",'M'};
	struct student *p;
	int num;
	p=&s;
	printf("%d %s %c\n",p->num,p->name,(*p).sex);
	p=sarr;
	num=p->num++;//num=p->num; p->num=p->num+1;
	printf("num=%d,p->num=%d\n",num,p->num);
	num=p++->num;//num=p->num; p=p+1;
	printf("num=%d,p->num=%d\n",num,p->num);
	system("pause");
}*/

/*
	3.typedef使用 
 
typedef struct student//结构体内无指针，可以省略student 
{
	int num;
	char name[20];
	char sex;
}stu,*pstu;
//pstu==struct student*
//typedef 目的 代码即注释，见文知意 
int main()
{
	stu s={1001,"Hulu",'M'};
	pstu p;
	p=&s;
	printf("%d %s %c\n",p->num,p->name,p->sex);
	system("pause"); 
}*/

/*
	4.链表的增删改查
 	 
typedef struct student
{
	int num;
	float score;
	struct student *pNext;
}stu,*pstu;
//头插法 
void list_head_insert(pstu *pphead,stu** pptail,int i)
{
	pstu pnew=(pstu)malloc(sizeof(stu));//申请空间 
	memset(pnew,0,sizeof(stu));
	pnew->num=i;
	//pnew->pNext=NULL;
	if(NULL==*pphead)//判断链表是否为空
	{
		*pphead=pnew;//如果链表为空，头指针和尾指针都指向新节点 
		*pptail=pnew; 
	}else{
		pnew->pNext=*pphead;//原有的头结点赋给新节点的pnext
		*pphead=pnew; 
	} 
}
//尾插法
void list_tail_insert(pstu *pphead,pstu *pptail,int i) 
{
	pstu pnew=(pstu)calloc(1,sizeof(stu));
	pnew->num=i;
	if(NULL==*pphead)//判断链表是否为空 
	{
		*pphead=pnew;//如果链表为空，头指针和尾指针都指向新结点 
		*pptail=pnew;
	}else{
		(*pptail)->pNext=pnew;//->优先级高于* 
		*pptail=pnew;
	}
}
//有序插入
void list_sort_insert(pstu *pphead,pstu *pptail,int i)
{
	pstu pcur,ppre;
	pstu pnew=(pstu)calloc(1,sizeof(stu));
	pnew->num=i;
	pcur=*pphead;
	ppre=pcur;
	if(NULL==pcur)//判断链表是否为空 
	{
		*pphead=pnew;//如果链表为空，头指针和尾指针都指向新结点
		*pptail=pnew; 
	}else if(i<pcur->num)//判断是否要插入头部
	{
		pnew->pNext=pcur;//原有的头结点赋给新结点的pnext
		*pphead=pnew; 
	}else{//插入中间或者尾部 
		while(pcur)//插入到中间 
		{
			if(pcur->num>i)
			{
				ppre->pNext=pnew;
				pnew->pNext=pcur;
				break; 
			}
			ppre=pcur;//把当前位置给小弟
			pcur=pcur->pNext;//指向下一个位置 
		}
		if(NULL==pcur)//进行尾插 
		{
			ppre->pNext=pnew;
			*pptail=pnew;
		}
	} 
} 
//结点删除
void list_delete(pstu *pphead,pstu *pptail,int i)
{
	pstu pcur=*pphead,ppre=*pphead;
	if(!pcur)
	{
		printf("List is empty\n");
	}else if(i==pcur->num)//删除的是头结点
	{
		*pphead=pcur->pNext;
		free(pcur);//释放结点空间 
		if(!*pphead)
		{
			*pptail=NULL;
		} 
	}else{
		while(pcur)//删除的是中间 
		{
			if(pcur->num==i)//删除的是中间 
			{
				ppre->pNext=pcur->pNext;
				free(pcur);
				break; 
			}
			ppre=pcur;
			pcur=pcur->pNext;
		}
		if(pcur==*pptail)//删除的是尾结点
		{
			*pptail=ppre;
		} 
		if(!pcur)//删除结点不在链表里 
		{
			printf("delete num is not in the List\n"); 
		}
	} 
} 
void list_modify(pstu phead,int i,float score)
{
	if(!phead)
	{
		printf("List is empty\n");
	}else{
		while(phead)
		{
			if(phead->num==i)
			{
				phead->score=score;
				break; 
			}
			phead=phead->pNext; 
		}
		if(!phead)
		{
			printf("modify num is not in the List\n");
		}
	}
}
//链表打印 
void list_print(pstu phead)
{
	while(phead)//phead!=NULL
	{
		printf("%3d %5.2f\n",phead->num,phead->score);
		phead=phead->pNext;
	}
	//printf("\n");
	printf("---------------------------------\n");
}
int main()
{
	pstu phead=NULL,ptail=NULL;//定义头尾指针，描述链表
	int i;
	float score;
	while(scanf("%d",&i)!=EOF)
	{
		//list_head_insert(&phead,&ptail,i);
		//list_tail_insert(&phead,&ptail,i);
		list_sort_insert(&phead,&ptail,i);
	} 
	list_print(phead);
//	while(printf("please input delete num:"),scanf("%d",&i)!=EOF)
//	{
//		list_delete(&phead,&ptail,i);
//		list_print(phead);
//	}
	while(printf("please input modify num:"),scanf("%d%f",&i,&score)!=EOF)
	{
		list_modify(phead,i,score);
		list_print(phead);
	}
	system("pause");
}*/

/*
	2.共用体和枚举
	如果共用体变量a的起始地址为1000，name公共体成员i,ch,f的起始地址均为1000.
	注意：
	1)同一个内存段可以用来存放集中不同类型的成员，但在每一瞬间只能存放其中一种，而不是同时
	存放几种。
	2)共用体变量中起作用的成员是最后一次存放的成员，在存入一个新的成员后原有的成员
	就失去作用。
	3)共用体变量的地址和它的各个成员的地址都是同一地址。
	4)不能对共用体变量名赋值，也不能企图引用变量名来得到一个值，又不能用体变量时对它初始化。
	5)不能把共用体变量作为函数参数，也不能使函数带回共用体变量，但可以使用指向共用体变量的指针。
	6)共用体类型可以出现在结构体类型定义中，也可以定义共用体数组。反之，结构体也可以出现在共用体
	类型定义中，数组也可以作为共用体的成员。 
	
typedef struct{
	int a;
	char c;
	float f;
}stu;

union data{//实现可变参数，相同时间内只能有一个变量有效 
	int a;
	char c;
	float f;
};

enum weekday{sun,mon,tue,wed,thu,fri,sat};//枚举常量，替代#define 
int main()
{
	union data d;//成员共有空间 
	stu s={10,'a',98.5};
	enum weekday workday;
	workday=tue;
	printf("workday=%d\n",workday); 
	d.a=10;
	d.c='b';
	d.f=88.5;	
	printf("%d %c %lf\n",d->a,d->c,d->f);
	system("pause");
}*/ 

/*
	3.栈Stack
	堆Heap 
	链表 后进先出 LIFO 头插法，头部删除法
	队列 先进先出 FIFO 尾插法，头部删除法 

typedef struct tag
{
	int val;
	struct tag *pNext;
}Node,*pNode;

typedef struct
{
	pNode phead;
	int size;
}Stack,*pStack;

void push(pStack p,int val)
{
	pNode pnew=(pNode)calloc(1,sizeof(Node));
	pnew->val=val;
	if(!p->phead)
	{
		p->phead=pnew;
	}else{
		pnew->pNext=p->phead;
		p->phead=pnew;
	}
	p->size++;
}

int main()
{
	Stack s;//定义一个栈
	int i;
	memset(&s,0,sizeof(s)); 
	while(scanf("%d",&i)!=EOF)
	{
		push(&s,i);
	}
	system("pause");
}*/

/*
	4.二叉树的层次建树 

typedef struct node
{
	char c;
	struct node *left;
	struct node *right; 
}Node,*pNode;

#define N 10

//前序遍历
void preorder(pNode node)
{
	if(node!=NULL)
	{
		printf("%c",node->c);
		preorder(node->left);
		preorder(node->right);
	}
} 

//中序遍历
void midorder(pNode node)
{
	if(node!=NULL)
	{
		midorder(node->left);
		printf("%c",node->c);
		midorder(node->right);
	}
} 

//后序遍历
void lastorder(pNode node)
{
	if(node!=NULL)
	{
		lastorder(node->left);
		lastorder(node->right);
		printf("%c",node->c);
	}
} 
int main()
{
	char c[N]={'A','B','C','D','E','F','G','H','J','K'}; 
	pNode p[N];
	pNode tree;
	int i,j;
	for(i=0;i<N;i++)//申请空间并初始化数据 
	{
		p[i]=(pNode)calloc(1,sizeof(Node));
		p[i]->c=c[i];
	} 
	tree=p[0];
	for(i=1;i<N;i++)//进树的元素 
	{
		for(j=0;j<N;j++)//找到树中的位置 
		{
			if(NULL==p[j]->left)
			{
				p[j]->left=p[i];
				break;
			}
			if(NULL==p[j]->right)
			{
				p[j]->right=p[i];
				break;
			}
		}
	}
	preorder(tree);
	printf("\n---------------------\n");
	midorder(tree);
	printf("\n---------------------\n");
	lastorder(tree);
	printf("\n---------------------\n");
	system("pause"); 
}*/

/*
	5.元素个数不确定的进制 

typedef struct node
{
	char c;
	struct node *left;
	struct node *right;
}Node,*pNode;

typedef struct tag
{
	pNode pos;
	struct tag *pNext;
}tag_t,*ptag_t;

//中序遍历
void midorder(pNode node)
{
	if(node!=NULL)
	{
		midorder(node->left);
		printf("%c",node->c);
		midorder(node->right);
	}
} 

int main()
{
	pNode tree=NULL;
	pNode pnew;
	ptag_t phead=NULL,ptail=NULL;
	ptag_t lpnew,lp_insert;
	char c;
	while(scanf("%c",&c)!=EOF)
	{
		if(c=='\n')
		{
			break;
		}
		pnew=(pNode)calloc(1,sizeof(Node));
		pnew->c=c;
		lpnew=(ptag_t)calloc(1,sizeof(tag_t));
		lpnew->pos=pnew;
		if(NULL==tree)
		{
			tree=pnew;
			phead=lpnew;
			ptail=lpnew;
			lp_insert=phead;
			continue;
		}
		//放入链表，尾插法
		ptail->pNext=lpnew;
		ptail=lpnew;
		//放入树
		while(lp_insert)
		{
			if(NULL==lp_insert->pos->left)
			{
				lp_insert->pos->left=pnew;
				break;
			}
			if(NULL==lp_insert->pos->right)
			{
				lp_insert->pos->right=pnew;
				break;
			}
			lp_insert=lp_insert->pNext;
		} 
	}
	midorder(tree);
	system("pause");
}*/ 

/*
	6.八大排序算法
	 
#include<time.h>
#define N 10
#define SWAP(a,b) {int tmp;tmp=a;a=b;b=tmp;}//用宏定义来交换a,b的值 

void arr_print(int *a)
{
	int i;
	for(i=0;i<N;i++)
	{
		printf("%3d",a[i]);
	}
	printf("\n");
} 

//选择排序 
void arr_select(int *a)
{
	int i,j,max_pos;
	for(i=N;i>0;i--)//控制无序数的数目
	{
		max_pos=0;
		for(j=1;j<i;j++)
		{
			if(a[max_pos]<a[j])
			{
				max_pos=j;
			}
		} 
		SWAP(a[max_pos],a[i-1]);
	} 
}

//插入排序 
void arr_insert(int *a)
{
	int i,j,k,insert_val;
	for(i=1;i<N;i++)//要插入的数据 
	{
		for(j=0;j<i;j++)//找到插入位置 
		{
			if(a[i]<a[j])
			{
				insert_val=a[i];
				for(k=i-1;k>=j;k--)//进行移动 
				{
					a[k+1]=a[k];
				}
				a[j]=insert_val;
				break; 
			}
		}
	}
}

int partition(int *a,int left,int right)
{
	int i,k;
	k=left;
	for(i=left;i<=right;i++)
	{
		if(a[i]<a[right])
		{
			SWAP(a[i],a[k]);
			k++;
		}
	}
	SWAP(a[k],a[right]);
	return k;
}

void arr_quick(int *a,int left,int right)
{
	int pivot;
	if(left<right)
	{
		pivot=partition(a,left,right);
		arr_quick(a,left,pivot-1);
		arr_quick(a,pivot+1,right);
	}
} 

int compare(int *left,int *right)
{
	return *left-*right;
}

void heap_max(int *a,int pos,int len)
{
	int dad=pos;
	int son=2*dad+1;
	while(son<len)
	{
		if(son+1<len&&a[son]<a[son+1])// < >从大到小 
		{
			son++;
		}
		if(a[dad]<a[son])// >从大到小 
		{
			SWAP(a[dad],a[son]);
			dad=son;
			son=2*dad+1;
		}else{
			break;
		}
	}	
}

void arr_heap(int *a)
{
	int i;
	//变为大根堆 
	for(i=N/2-1;i>=0;i--)
	{
		heap_max(a,N/2-1,N);
	}
	//交换，调整 
	SWAP(a[0],a[N-1]);
	for(i=N-1;i>0;i--)
	{
		heap_max(a,0,i);
		SWAP(a[0],a[i-1]);
	}
}

int main() 
{
	int a[N];//50w个数 *a=(int*)calloc(N,sizeof(int)); 
	int i;
	time_t start,end; 
	srand(time(NULL));//生成随机种子
	for(i=0;i<N;i++)
	{
		a[i]=rand()%100;
	} 
	arr_print(a);
	//arr_select(a);
	//arr_insert(a);
	start=time(NULL);
	//arr_quick(a,0,N-1);
	//qsort(a,N,sizeof(int),compare);//排50w个数 
	//arr_print(a);
	arr_heap(a);
	end=time(NULL);
	arr_print(a);
	printf("use time=%d\n",end-start);
	system("pause"); 
}*/ 

/*
	链表的有序插入
	1.链表是否为空，为空，新节点即为头结点，也是尾结点
	2.链表不为空，如果要插入的结点，小于头结点，头插法
	3.遍历链表，发现某结点的值大于插入结点，插入到该节点值之前
	4.遍历未找到位置，插入到尾部，修改尾指针
	
	二叉树的层次建树
	用两个循环，外层控制进树的元素，内层找到元素应该放入树中的位置 
	
	快排
	把最后一个元素作为分割值，判、判断数组元素小于分割值，放在数组考前位置，
	最终实现分割值左边的数据小于分割值，右边大于分割值。 
	递归进行 
	
	空间换时间
	0~99之间
	当你知道你排的数是范围有限
	
*/	

/* 
	2.二分查找
 
int b_search(int *a,int low,int high,int target)
{
	int mid;
	while(low<=high)
	{
		mid=(low+high)/2;
		if(target>a[mid])
		{
			low=mid+1;
		}else if(target<a[mid])
		{
			high=mid+1;
		}else{
			return mid;
		}
	}
} 
int main()
{
	int a[10]={21,30,33,36,51,62,77,81,91,96};
	int pos;
	pos=b_search(a,0,9,36);
	printf("pos=%3d\n",pos);
	system("pause");
}*/

/*
	堆排
	1.把数组调整为大根堆
	2.把树根和最后一个叶子结点交换
	3.把剩余元素继续调整为大根堆
	4.重复2，3步 
*/

/*
	红黑树
	1.节点是红色或黑色
	2.根是黑色
	3.所有叶子都是黑色(叶子是NIL结点)
	4.每个红色节点必须有两个黑色的子节点(从每个叶子到根的所有路径上不能有两个连续的红色节点)
	5.从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。 

int main()
{
	int n;
	int a[10];
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		scanf("%x",&a[i]);
	}
	for(int i=0;i<n;i++)
	{
		printf("%o\n",a[i]);
	}
	return 0;
} 
#include<stdio.h>
int main()
{
	int n,a[10],i;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%x",&a[i]);
	}
	for(i=0;i<n;i++)
	{
		printf("%o\n",a[i]);
	}
	return 0;
}
#include<stdio.h>
#include<string.h>
int main()
{
	int n,i,j,k,a,cur,ok,m,l;
	char s[10][100001],d16[16][5]={"0000","0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"},out[140000]={},z[13]={};
	scanf("%d",&n);
	for(j=0;j<n;j++)
		scanf("%s",s[j]);
	for(j=0;j<n;j++)
	{
		k=0;ok=1;m=0;//初始化标记数据
		l=strlen(s[j]);//初始化标记数据
		a=3-l%3;//初始化标记数据，求出要将这个十六进制数补足为3的倍数需要补上多少个0
		if(a==3) ok=0;//十六进制数长度刚好为3的倍数时转换二进制不需要补0，ok标记是否为3的倍数0是1不是 
		for(i=0;i<l;i++)
		{
			if(65<=s[j][i])
				s[j][i]-=7;
			if(ok)//十六进制数位数不足转二进制时补0占位 
				if(a==1){
					strcat(z,"0000");k=k+4;ok=0;
				}else if(a==2){
					strcat(z,"00000000");k=k+8;ok=0;
				} 
			z[k++]=d16[s[j][i]-48][0];//一位十六进制转四位二进制
			z[k++]=d16[s[j][i]-48][2];
			z[k++]=d16[s[j][i]-48][3];
			z[k++]=d16[s[j][i]-48][4]; 
			if(k==12)//每转三位十六进制数将其转换为四位八进制数 
			{
				for(cur=0;cur<12;m++)
					out[m]=((z[cur++]-48)*4+(z[cur++]-48)*2+(z[cur++]-48)*1)+48;
				z[0]='\0';k=0;//z[0]='\0'初始化字符串结束符位置避免溢出			
			} 
		} 
		for(;k<3;k++)
			if(out[k]!=48) break;//48是字符'0'的ASCII值
		for(;k<m;k++)
			printf("%c",out[k]);
		putchar('\n'); 
	}
	return 0;
}
#include<stdio.h>	
int main()
{
	int a;
	scanf("%d",&a);
	if(a%4==0&&a%100!=0||a%400==0)
		printf("yes");
	else
		printf("no");
	return 0;	
} 
#include<stdio.h>
int main()
{
	int n; 
	int a[5];
	for(int i=0;i<32;i++)
	{
		n=0;
		a[5]={0};
		for(int j=0;i<50000;j++)
		{
			if(i/2==0) break;
			else{
				n++;
				a[5-n]=i%2;
				i/=2;
			}
		}
		printf("%d%d%d%d%d\n",a[0],a[1],a[2],a[3],a[4]);
	}
	return 0;	
}
#include<iostream>
#include<string>
using namespace std;
int main()
{
	int i,j;
	string str="00000";
	for(i=0;i<32;++i)
	{
		cout<<str<<endl;
		str[4]+=1;
		for(j=4;j>=0;--j)
		{
			if(str[j]=='2')
			{
				str[j-1]+=1;
				str[j]='0';
			}
		}
	}
	return 0;
}
#include<iostream>
using namespace std;
int main()
{
	for(int i=0;i<32;i++)
	{
		cout<<i%32/16<<i%16/8<<i%8/4<<i%4/2<<i%2<<endl; 
	}
	return 0;
}
#include<iostream>
using namespace std;
int main()
{
	int a,b,c,d,e;
	for(a=0;a<2;++a)
		for(b=0;b<2;++b)
			for(c=0;c<2;++c)
				for(d=0;d<2;++d)
					for(e=0;e<2;++e)
						cout<<a<<b<<c<<d<<e<<endl;
	return 0;
}
#include<iostream>
using namespace std;
int main()
{
	int n,m,s=0,d=10001,x=-10001;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>m;
		s+=m;
		if(m>x) x=m;
		if(m<d) d=m;
	}
	cout<<d<<endl;
	cout<<x<<endl;
	cout<<s<<endl;
}
#include<iostream>
using namespace std;
int main()
{
	int n,m,a[10000],i=0;
	cin>>n;
	while(n--)
	{
		cin>>m;
		i=0;
		while(m/2!=0)
		{
			a[i++]=m%2;
			m/=2;
		}
		while(i--)
			cout<<a[i];
		printf("\n");
	}
	return 0;
}*/
/*
#include <iostream>
#include <string> 
using namespace std;
int main()
{
	string s1, s2;
	cout << "please input two strings:" << endl;
	cin >> s1 >> s2;
	cout << s1 + s2 << endl;
	system("pause");
	return 0;
} 
#include <iostream>
#include <string> 
using namespace std;
int main()
{
	string s1, s2;
	cout << "please input two strings:" << endl;
	cin >> s1 >> s2;
	if (s1 > s2)
		cout << "the first string is greater" << endl;
	else if (s1 < s2)
		cout << "the second string is greater" << endl;
	else
		cout << "two strings is equal" << endl;
	    system("pause");
	return 0;
}
#include <iostream>
#include <string> 
using namespace std;
int main()
{
	string s1 = "hello C++";
	string s2 = "chuan zhi bo ke";
	cout << "before swap :" << endl;
	cout << "s1:" << s1 << endl << "s2:" << s2 << endl;
	s1.swap(s2);
	cout << "after swap:" << endl;
	cout << "s1:" << s1 << endl << "s2:" << s2 << endl;
	system("pause");
	return 0;
}
#include<iostream>
using namespace std;
int main()
{
	int n,m,s=0,d=10001,x=-10001;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>m;
		s+=m;
		if(m>x) x=m;
		if(m<d) d=m;
	}
	cout<<x<<endl;
	cout<<d<<endl;
	cout<<s<<endl;
}
#include<iostream>
using namespace std;
int main()
{
	int n,m[999],a,i;
	cin>>n;
	for(i=0;i<n;i++)
	{
		cin>>m[i];
	}
	cin>>a;
	for(i=0;i<n;i++)
	{
		if(m[i]==a)
			break;
	}
	if(i==n)
		cout<<-1<<endl;
	else
		cout<<i+1<<endl;
}	
#include<iostream>
using namespace std;
int main()
{
	int n,i,j;
	cin>>n;
	int a[n][n];
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			if(j>i)
				break;
			if(!j||j==i)
				a[i][j]=1;
			else
				a[i][j]=a[i-1][j-1]+a[i-1][j];
		}
	}
	for(i=0;i<n;i++)
	{
		for(j=0;j<i+1;j++)
		{
			if(!i&&!j||i==j)
				cout<<a[i][j];
			else 
				cout<<a[i][j]<<" ";
		}
		cout<<endl;
	}
}
#include<iostream>
using namespace std;
int main()
{
	int a,b,c,s;
	for(int i=100;i<=999;i++)
	{
		a=i%10;
		b=i/10%10;
		c=i/100%10;
		s=a*a*a+b*b*b+c*c*c;
		
		if(i==s)
			cout<<i<<endl;
	}
}
#include<iostream>
using namespace std;
int main()
{
	for(int i=1000;i<=9999;i++)
	{
		if(i%10==i/1000%10&&i/10%10==i/100%10)
			cout<<i<<endl;
	}
}
#include<iostream>
using namespace std;
int main()
{
	int n,s;
	cin>>n;
	for(int i=10000;i<=999999;i++)
	{
		if(i/100000==0)
		{
			s=i%10+i/10%10+i/100%10+i/1000%10+i/10000%10;
			if(s==n&&(i%10==i/10000%10&&i/10%10==i/1000%10))
				cout<<i<<endl;	
		}
		else
		{
			s=i%10+i/10%10+i/100%10+i/1000%10+i/10000%10+i/100000%10;
			if(s==n&&(i%10==i/100000%10&&i/10%10==i/10000%10&&i/100%10==i/1000%10))
				cout<<i<<endl;
		}
			
//		if(i%100000==0&&((i%10+i/10%10+i/100%10+i/1000%10+i/10000%10+i/10000%10==n)&&))
//			cout<<i<<endl;
//		else if(i%1000000==0&&((i%10+i/10%10+i/100%10+i/1000%10+i/10000%10+i/10000%10+i/100000%10==n)&&))
//			cout<<i<<endl;
	}
}
#include<stdio.h>
int main()
{
	int a;
	scanf("%d",&a);
	printf("%x",a);
	return 0;
} 
#include<iostream>
using namespace std;
int main()
{
	int a,b,i=0;
	char c,d[99999];
	cin>>a;
	while(a/16)
	{
		b=a%16;
		if(b>9)
		{
			c='A'+b-10;
			d[i++]=c;
		}
		else
			d[i++]=b+48;
		a/=16;
	}
	b=a%16;
	if(b>9)
	{
		c='A'+b-10;
		d[i++]=c;
	}
	else
		d[i++]=b+48;
	while(i--)
		cout<<d[i];
}
#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;
int main()
{
	int l,i=0;
	long long sum=0;
	char a[10];
	gets(a);
	l=strlen(a);
	while(i<l)
	{
		if(a[i]>=48&&a[i]<=57)
			sum+=(a[i]-48)*pow(16,l-i-1);
		else if(a[i]>=65&&a[i]<=90)
			sum+=(a[i]-55)*pow(16,l-i-1);
		i++;
	}
	cout<<sum;
}
#include<iostream>
using namespace std;
int main()
{
	int n;
	cin>>n;
	if(n==1)
		printf("1");
	else
	{
		int a[1000];
		int head=0,tail=0,p=0;
		a[0]=1;
		int i,j;
		for(i=2;i<=n;i++)
		{
			for(j=head;j<=tail;j++)
			{
				p=a[j]*i+p;
				a[j]=p%10;
				p=p/10;
			}
			while(p!=0)
			{
				tail++;
				a[tail]=p%10;
				p=p/10;
			}
		} 
		for(i=tail;i>=0;i--)
		{
			printf("%d",a[i]);
		}
	}
}
**************************************

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
	string a,b,c,d,e;
	int la,lb,i;
	
	cin>>a>>b;
	
	la=a.length();
	for(i=0;i<la;i++)
	{
		c[la-i-1]=a[i];
	}
//	for(i=0;i<la;i++)
//	{
//		cout<<c[i];
//	}
	
	lb=b.length();
	for(i=0;i<lb;i++)
	{
		d[lb-i-1]=b[i];
	}
//	for(i=0;i<lb;i++)
//	{
//		cout<<d[i];
//	}
	
	
	int r=0;
	if(la>lb)
	{
		for(i=lb;i<la;i++)
		{
			d[i]=0;
		}
		for(i=0;i<la;i++)
		{
			e[i]=(c[i]+d[i]+r)%10;
			r=(c[i]+d[i]+r)/10;
		}
		for(i=0;i<la;i++)
		{
			cout<<e[i];
		}
	}
}
#include<stdio.h>
#include<string.h>
int main()
{
	int r,i,j,k;
	int a[100]={0},b[100]={0},c[200]={0};
	char m[100],n[100];
	
	scanf("%s%s",m,n);
	
	for(i=0;i<strlen(m);i++)
		a[i]=m[strlen(m)-i-1]-48;//将m的最高项(其实是大数的个位)存放在a的最小项
	for(j=0;j<strlen(n);j++)
		b[j]=n[strlen(n)-j-1]-48;//同理
		
	k=(i>j)?i:j;//选择较大的数的长度
	r=0;
	
	for(i=0;i<k;i++)
	{
		c[i]=(a[i]+b[i]+r)%10;
		r=(a[i]+b[i]+r)/10;
	} 
	
	if(r!=0)//判断一下最后一次元素按有没有进位，如果有的话，就让c多增加一位
	{
		c[i]=r;
		i++;
	} 
	
	for(j=i-1;j>=0;j--)
		printf("%d",c[j]);
		
	return 0;
}
#include<stdio.h>
#include<string.h>
#include<math.h>
int main()
{
	char a[20],b[20];
	scanf("%s%s",a,b);
	int l,flag=0;
	l=strlen(a);
	if(strlen(a)!=strlen(b))
		printf("1");
	else
	{
		for(int i=0;i<l;i++)
		{
			if(abs(a[i]-b[i])!=32&&abs(a[i]-b[i])!=0)
			{
				flag=4;
				break;
			}
			if(abs(a[i]-b[i])==32)
				flag=1;
		}
		if(!flag)
			printf("2");
		else if(flag==4)
			printf("4");
		else
			printf("3");		 
	}
	return 0;
}
#include<iostream>
#include<cstring>
using namespace std;

int main()
{
	int data[10005];
	int temp[10005];
	int n,r,t1,tail;
	memset(data,0,sizeof(data));
	cin>>n;
	if(n<=1) return 1;
	int head=0;
	data[0]=1;
	for(int i=1;i<=n;i++)
	{
		t1=0;
		for(int j=0;j<=head;j++)
		{
			//!!!模拟手工计算，当前位相乘后加上进位数
			r=data[j]*i+t1;
			if(r>=10000)
			{
				//!!!计算出进位数字
				t1=r/10000;
				data[j]=r%10000;
				//!!!最大位+1
				if(j==head) head++; 
			}else{
				data[j]=r;
				t1=0;
			}
		}
	}
}
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define N 500
#define INF 99999999
int map[N][N];
int main(){
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i = 0;i <= n;i++){
		for(int j = 0;j <= n;j++){
			if(i == j){//i,j相同的点初始化为0，为INF会出错 
				map[i][j] = 0;
			}else{
				map[i][j] = INF;
			} 
		}
	}
	for(int i = 0;i<m;i++){
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		map[a][b] = c;
		map[b][a] = c;
	}
	//核心代码
	 for(int k = 1;k<=n;k++){
	 	for(int i = 1;i<=n;i++){
		 	for(int j = 1;j<=n;j++){
			 	if(map[i][j]>map[i][k]+map[k][j]){
				 	map[i][j] = map[i][k]+map[k][j];
				 } 
			 } 
		 } 
	 } 
	 int index = 0;
	 int min = INF;
	 int max;
	 //min赋为INF不能放到循环里
	 for(int i = 1;i<=n;i++){
	 	max = 0;
	 	for(int j = 1;j <= n;j++){
		 	if(max<map[i][j]){//这里是小于号，找出变成其他动物最长的口诀的长度 
			 	max = map[i][j];
			 }
		 }
		 if(min > max){//更新最小值 
		 	min = max;
		 	index = i;
		 } 
	 } 
	 //当有无法变成的动物时，max会等于INF
	 if(index==0){
	 	printf("0\n");	
	 }else{
	 	printf("%d %d\n",index,min);
	 }
	 return 0;
}*/