小白进阶日记4（7.26）-小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。

1.从键盘上输入10个整数存放到一维数组中，将其中最小的数与第一个数对换，最大的数与最后一个数对换。
要求进行数据交换的处理过程编写成一个函数，函数中对数据的处理要用指针方法实现。

#include<stdio.h>
void transform(int *a)
{
	int max,min,i,temp=0,temp1;
	max=min=0;
	for(i=0;i<10;i++)
	{
		if(a[i]>=a[max])
		{
			max=i;
		}
			
		if(a[i]<=a[min])
			min=i;
		if(i==9);
		
	}
	if(max==0)					//这里要考虑两者情况
	{							//如果a[max]在第一个数的话，先交换min的值会导致最大值不是原来的下标
		temp=a[9];				//所以要先交换max的值 
		a[9]=a[max];			//最小值也是一样
		a[max]=temp;
				temp=a[0];
		a[0]=a[min];
		a[min]=temp;
		
		
	}
	else if(min==9)
	{
		temp=a[0];
		a[0]=a[min];
		a[min]=temp;
		
		temp=a[9];
		a[9]=a[max];
		a[max]=temp;
		
	}
	else
	{
		temp=a[0];
		a[0]=a[min];
		a[min]=temp;
		
		temp=a[9];
		a[9]=a[max];
		a[max]=temp;
	}
	
	//printf("%d --",a[9]);
	
}
int main(int argc, char * argv [ ])
{
	int a[10],i,*p;
	p=a;
	for(i=0;i<10;i++)
	{
		scanf("%d",&a[i]);
	}
	transform(a);
	for(i=0;i<10;i++)
	{
		printf("%d ",*(p+i));
	}
	printf("\n");
	
}

编写一个函数（参数用指针）将一个3×3矩阵转置

#include<stdio.h>
#include<stdlib.h>

int *zhuanzhi(int (*a)[3],int n)
{
	int i,j;
	int b[3][3];
	for(i=0;i<3;i++)			//通过b数组改变a的行列转置
	{
		for(j=0;j<3;j++)
		{
			b[i][j]=a[i][j];
			
		}
	}
	for(i=0;i<3;i++)
	{
		for(j=0;j<3;j++)
		{
			a[j][i]=b[i][j];
			
		}
	}
	
	return *a;
	
}
int main(int argc, char * argv [ ])
{
	int a[3][3]={
		{1,2,3},
		{4,5,6},
		{7,8,9}
	},i,j;
	
	zhuanzhi(a,3);
	
	
	
	for(i=0;i<3;i++)
	{
		for(j=0;j<3;j++)
		{
			printf("%d ",a[i][j]);
			
		}
		printf("\n");
	}
}

3.用指针法编程，从键盘上输入多个字符串（每个串不超过5个字符且没有空格），用”*”作为输入结束的标记。
从所输入的若干字符串中，找出一个最大的串，并输出该串。要求串的输入以及最大串的查找通过调用编写的函数实现。
(多使用<string.h>里学过的库函数)

#include<stdio.h>
#include<string.h>
void find_max_substring(char *s)
{
	//通过变量计数，算出每个子字符串的长度
	int i=0,j=0,k=0,m,m1,n,s1;
	char *p,*q,*l,temp[6],temp1[6];
	p=s;
	l=temp;
	q=temp1;
	while(1)				//将第一个子字符串存入temp
	{	
		if(*s=='*')
		{
			
			strncpy(temp,p,k);	
			k=0;
			break;
		}
		k++;			//字符串长度计数
		s++;
	}
	s++;				//跳过*
	p=s;				//指针移到第二个子字符串开头
	
	while(*s)
	{
		
		if(*s=='*')
		{
			//s=s+1;					//跳过*
			strncpy(temp1,p,k);		//把第二个开始的子字符串依次存到temp1
			p=p+k+1;					
			k=0;
		}
		m=strcmp(temp1,temp);		//依次和第一个子字符串比较
		if(m>=0)
			strcpy(temp,temp1);		//如果比第一个大则把当前的子字符串变成temp
		
		
		s++;
		j++;
		k++;
	}
	printf("最大的子字符串为：%s",l);
}
int main(int argc, char * argv [ ])
{
	char s[30]={'\0'};
	int len;
	scanf("%s",s);
	find_max_substring(s);
}

如果一个01串任意两个相邻位置的字符都是不一样的,我们就叫这个01串为交错01串。
例如: “1”,“10101”,"0101010"都是交错01串。
编写一个函数，实现求一个01串（字符窜中只有两种字符 例如：abbbabbbaaa）的最长交错子串的功能。
（最长交错子串：最长的子窜，并且还是01串）

#include<stdio.h>
#include<string.h>
void miss_substring(char *s1)
{
	int count=0,i=0,j=0,len=0,m=0;
	char *p,*q,s2[30],s_max[30]="0";
	p=s1;
	q=s_max;
	//*(q)='1';
	while(*(p+1)!=0)
	{
		if(*p!=*(p+1)&&(*(p+2)!=0))					//如果当前字符和下一个字符不相等就计数+1,如下下个字符为结束符则直接转到else
		{
			count++;
		}
		else
		{	
			
			if(strlen(s_max)>=m)				//存最大的子字符串
				strncpy(s_max,p-count,count);
			//printf("%s\n",(p-count));
			 printf("%ld--+\n",strlen(s_max)); //这里必须要用%ld,或者用int强制转换
			m=strlen(s_max);
			count=0;
			printf("%d\n",*(p+1));
		}
	
	p++;
	}
	printf("%s",q);
}
int main(int argc, char * argv [ ])
{
	char s1[30];
	scanf("%s",s1);
	miss_substring(s1);
}

输入： 第一行包括一个数字N，表示本次用例包括多少个待校验的字符串。
后面跟随N行，每行为一个待校验的字符串。

输出：	N行，每行包括一个被修复后的字符串。

示例： 输入：  2
	       helloo
	       wooooooow
           输出：  hello
	       woow

1. 三个同样的字母连在一起，一定是拼写错误，去掉一个的就好啦：比如 helllo -> hello
2. 两对一样的字母（AABB型）连在一起，一定是拼写错误，去掉第二对的一个字母就好啦：比如 helloo -> hello
3. 上面的规则优先“从左到右”匹配，即如果是AABBCC，虽然AABB和BBCC都是错误拼写，应该优先考虑修复AABB，结果为AABCC

#include<stdio.h>
#include<string.h>
void debug_(char (*s)[30],int n)
{
	int i=0,j=0,count=0;
	char (*p)[30];
	p=s;
	while(i<n)
	{	
		while(*(*(s+i)+j))				//判断每个字符串是否结束
		{
			if(*(*(s+i)+j)==*(*(s+i)+j+1))	//如果当前字符和下一个字符相等，则count+1
			{
				count++;
				if(count>=2)				//count>=2就意味出现多个同样字符
				{
					strcpy((*(s+i)+j),(*(s+i)+j+1));	//后面的字符往前覆盖掉一个相同的字符
					//printf("%s+- ",(*(s+i)+j));
					j=0;								//从头开始遍历该字符串
					count=0;							//清零
				}
			}
			j++;
		}
		j=0;
		i++;
		count=0;
	}
	
}
int main(int argc, char * argv [ ])
{
	int n,i;
	char s[10][30];
	
	//输入要修改的字符串个数
	printf("输入字符串个数：\n");
	scanf("%d",&n);
	//通过循环实现输入字符串
	for(i=0;i<n;i++)
	{
		scanf("%s",s[i]);
		
	}
	//调用改错函数
	printf("===");
	debug_(s,n);
	printf("修改后结果为：\n");
	for(i=0;i<n;i++)
	{
		printf("%s\n",s[i]);
		
	}
}

小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。
现在有一个给定的字符串s,s中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。
如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。
请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)

例如: s = "ABAB",那么小易有六种排列的结果:
"AABB","ABAB","ABBA","BAAB","BABA","BBAA"
其中只有"AABB"和"BBAA"满足最多只有一对不同颜色的相邻砖块。

输入：输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s中的每一个字符都为一个大写字母(A到Z)。

输出：输出一个整数,表示小易可以有多少种方式。

#include<stdio.h>
#include<string.h>
void sort(char *s,int len)
{
	int i,n=0,h,j,k[len],k1[len],count=0,count1=0,str[100]={0};
	char *p,a,b;
	p=s;
	a=*p;
	b=*p;
	for(i=0;i<len;i++)			//将输入的每个字符出现的次数按ascii码存到str里去
	{
		if(*(s+i)!=0)
			str[*(s+i)]++;
	}
	for(j=65;j<91;j++)			//在A-Z中出现一种字母就n++一次，若n！=2的话就不满足题意
	{
		if(str[j]!=0)
			n++;
	}
	if(n!=2)
		printf("输入不满足条件！");
	else
		printf("2种");
	printf("\n");
}
int main(int argc, char * argv [ ])
{
	char s[50]={'\0'};
	int n,len;
	scanf("%s",s);
	
	len=strlen(s);
	sort(s,len);
	
}