笔记代码（各种算法实现）

//此法可以按照不排序输出，符合题意用vector<pair<string,int>>
int main ()
{
int invalid = 0;

vector<pair<string,int>> VoteResult;
vector<pair<string,int>>::iterator it;

string str1 , str2 ;
int i=0;
int found=0;
while(1)
{
cin >> str1;

if ( str1 == "addCandidate" )
{
cin >> str2 ;
for (it=VoteResult.begin();it!=VoteResult.end();it++)
{
if (it->first==str2)
{
found=1;
break;
}
}
if(found!=1)
VoteResult.push_back(make_pair(str2,0));
}
else if( str1 == "vote")
{
cin >> str2 ;
found=0;
for (it=VoteResult.begin();it!=VoteResult.end();it++)
{
if (it->first==str2)
{
found=1;
break;
}
}
if (found==1)
it->second+=1;
else
invalid += 1;
}
else if( str1 == "getVoteResult" )
{
for ( it = VoteResult.begin() ; it != VoteResult.end(); it++ )
cout << (*it).first << " " << (*it).second << endl;
cout << invalid <<endl;
return 0;
}
}
return 0;
}

//map实现，升序输出候选人，不符合题意
int main ()
{

int invalid = 0;

map<string,int> VoteResult;
map<string,int>::iterator it;

string str1 , str2 ;
while(1)
{
cin >> str1;

if ( str1 == "addCandidate" )
{
cin >> str2 ;
VoteResult[str2] = 0;

}
else if( str1 == "vote")
{
cin >> str2 ;
if ( VoteResult.find( str2 ) != VoteResult.end() )
VoteResult[ str2 ] += 1;
else
invalid += 1;
}
else if( str1 == "getVoteResult" )
{
for ( it = VoteResult.begin() ; it != VoteResult.end(); it++ )
cout << (*it).first << " " << (*it).second << endl;
cout << invalid <<endl;
return 0;
}
}
return 0;
}

//一串字符，连续出现次数限制为x=3，如aaaa-bcdb
int main()
{
string s_in;
cin>>s_in;
int len=s_in.size();
int f=0;
char s_out[100];//[1000]={'\0'};
char tmp='\0';

for (int i=0;i<len;i++)
{
if (s_in[i]!=tmp)
{
s_out[i]=(s_in[i]-'a'+1)%26+'a';
tmp=s_in[i];
f=0;
}
else
{
f++;
if(f==1)
s_out[i]=(s_in[i]-'a'+2)%26+'a';
else if (f==2)
s_out[i]=(s_in[i]-'a'+3)%26+'a';
else
{
s_out[i]=(s_in[i]-'a'+1)%26+'a';
f=0;
}
}
}
s_out[len]='\0';

for (int i=0;i<len;i++)
{
cout<<s_out[i];
}
cout<<endl;
return 0;
}

//输出整型数据中存在指定整数的数据，并按照升序排列返回
int compare (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}

int *calcTimes(int num[], int len,int value)
{
vector<int> data;
qsort(num,len,sizeof(int),compare);   //使用快速排序例程进行排序
//sort(vec.begin(),vec,end())默认升序排序，若                                         //要降序可用
//bool cmp(const int &a,const int &b){return a>b;}
sort(vec.begin(),vec.end(),cmp);
//也可用sort升序排序完成后用，元素翻转函数reverse(vec.begin(),vec.end());
int n=1,tmp=value;
while(tmp!=0)  //求出tmp是几位数
{
n*=10;
tmp/=10;
}
int reminder=0;
for(int i=0;i<len;i++)
{
if(num[i] < n && num[i] != value)
continue;
else if(num[i] == value)
{
data.push_back(num[i]);
}
else
{
tmp = num[i];
while(tmp >= value)
{
reminder = tmp%n;
if(reminder == value)
{
data.push_back(num[i]);
break;
}
else
{
tmp/=10;
}

}
}
}
int *result = new int[data.size()];
for( int i=0;i<data.size();i++)
//这里完全是为了返回需要。。。主要是端口限制带来的麻烦
{
result[i] = data[i];
}
cout<<endl;
vector<int>::iterator it;   //这是容器输出的一种方式，也可以用data[i]的方式输出
for (it=data.begin();it!=data.end();it++)
{
cout<<*it<<endl;
}
return result; //只返回数组的首个元素或者首元素地址
}

int main()
{
int len,value;
cout<<"enter len and value";
cin>>len>>value;
int *data = new int[len];
cout<<"enter len numbers of data[len]";
for(int i=0;i<len;i++)
{
cin>>data[i];
}
int *result = calcTimes(data,len,value);
delete[] data;
return 0;
}

//输入数组与指定数字，并以差值为标准升序排序输出数组，可以解决差值相等情况
/*
struct num
{
int rs;
int data;
}s[100];

int cmp(const void *a ,const void *b)
{

struct num* c=(num*)a;
struct num* d=(num*)b;
if(c->rs!=d->rs)
return c->rs - d->rs;
else
return c->data - d->data;
/ *  //写法一
if((*(num*)a).rs!=(*(num*)b).rs)
return (*(num*)a).rs - (*(num*)b).rs;
else
return (*(num*)a).data - (*(num*)b).data;* /
}

int main()
{
int n;
int val;
cout<<"shu ru n:";
cin>>n;
cout<<"shu ru val:";
cin>>val;
for (int i=0;i<n;i++)
{
cin>>s[i].data;
s[i].rs=abs(s[i].data-val);
}
qsort(s,n,sizeof(s[0]),cmp);
for (int i=0;i<n;i++)
{
cout<<s[i].data<<" ";
}
cout<<endl;

return 0;
}*/

//取出整型数据中出现次数最多的元素并升序输出
/*
vector<int> calTimes(int a[],int len)
{
map<int,int>cont;
map<int,int>::iterator it;
vector<int>rel;
vector<int>::iterator itt;
int Max=INT_MIN;

for (int i=0;i<len;i++)
{
it=cont.find(a[i]);
if(it==cont.end())
cont[a[i]]=1;
else
{
int t=it->second;
cont.erase(it);
cont[a[i]]=t+1;
}
}
for (it=cont.begin();it!=cont.end();it++)
{
if(it->second>Max)
Max=it->second;
}
for (it=cont.begin();it!=cont.end();it++)
{
if(it->second==Max)
rel.push_back(it->first);
}
sort(rel.begin(),rel.end());
return rel;
}
int main()
{
int a[10]={1,1,3,4,4,4,9,9,9,10};
int len=10;
vector<int>RE=calTimes(a,10);
vector<int>::iterator it;
for (it=RE.begin();it!=RE.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
return 0;
}*/

//输入字符统计每个字符输入个数，并升序输出字符和统计个数
/*
int main()
{
map<char,int>cnt;
map<char,int>::iterator it;
char c[1000]={'\0'};
cin>>c;
int len=strlen(c);
for (int i=0;i<len;i++)
{
it=cnt.find(c[i]);
if (it==cnt.end())
cnt[c[i]]=1;
else
{
int t=it->second;//保证it不是空的
cnt.erase(it);
cnt[c[i]]=t+1;
}
}
for (it=cnt.begin();it!=cnt.end();it++)
{
cout<<it->first<<" "<<it->second<<" ";
}
cout<<endl;

return 0;
}*/

/*******m个字符以n个一行，不足补0*****\
int main()
{
string s;
int n;
cout<<"enter m zi fu:";
cin>>s;
cout<<"n mei gei";
cin>>n;
int len=s.size();

for (int i=1;i<=len;i++)
{
if(i%n!=0) cout<<s[i-1];
else cout<<s[i-1]<<endl;
}
int yu=len%n;
int number=n-yu;
for(int j=1;j<=number;j++)
cout<<0;
cout<<endl;

return 0;
}
\***********/

/*******电话号码翻译*******\
int main()
{
char a[11][11]={"zero","one","two","three","four","five","six","seven","eight","nine","double"};
char c='0';
char tmp[11];
int f,d;

while (c!='\n')
{
scanf("%s%c",&tmp,&c);
f=0;
for (int i=0;i<11;i++)
{
if (!strcmp(tmp,a[i])&&i<10)
{
f=1;
cout<<i;
if (d==1)
{
cout<<i;
d=0;
}
}
else if (!strcmp(tmp,a[i])&&i==10)
{
d=1;
f=1;
}
}
if(f==0)
break;

}
if(f==0||d==1||f==2) cout<<"Error"<<endl;
return 0;
}

/**********频率数组记录出现次数最多的字符*******\
int main()
{
string s;
cout<<"shu ru zi fu chuan:";
cin>>s;
int len=s.size();

int cnt[200];
int max_cnt=-1;
memset(cnt,0,sizeof(cnt));
for (int i=0;i<len;i++)
{

int num=s[i];//将字符转换为ascii码值
cnt[num]++;
if (cnt[num]>max_cnt)
max_cnt=cnt[num];
//		max_cnt=max(max_cnt,cnt[s[i]]);
}
for (int j=0;j<=129;j++)
{
if (cnt[j]==max_cnt)
{
cout<<(char)j<<endl;
break;//为了保证输出的是第一个最小的字典序字符
}
}
return 0;
}
\**************/

/**********以整型数输入方式*****\

int cal(int n)//计算各个位上的和//输出按各位和升序，若和相等则按数值大小升序排序
{
int ans=0;
if(n==0)
return 0;
else
{
while (n!=0)
{
ans+=n%10;
n/=10;
}
return ans;
}
}

int cmp(int x,int y)
{
if(cal(x)!=cal(y))
return cal(x)<cal(y);
else
return x<y;
}
int main()
{
int arr[10];
for (int i=0;i<10;i++)
{
cin>>arr[i];
}
sort(arr,arr+10,cmp);
for (int i=0;i<10;i++)
{
if(i==9)
cout<<arr[i];
else
cout<<arr[i]<<" ";
}
return 0;
}
\************/

//**//\\\**\给定的字符串中找单词，按长度降序排列，并输入到新字符串中，空格，重复只输出一次
//容器法
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

bool myfunction (const string &str1,const string &str2) {

return (str2.length() < str1.length());
}

void my_word(char input[], char output[]){

vector<string> str;
char *cur = input;
char *p = input;
int len;
bool flag = false;
//去除杂质，取单词
while(*p != '\0')
{
if((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z'))
p++;
else
{
len = p-cur;
if(len > 1)
{
string tmp(cur,len);

for(int i=0;i<str.size();i++)
if(tmp == str[i])
flag = true;
if(flag != true)
str.push_back(tmp);
}
cur = p+1;
p++;
flag = false;
}
}

len = p-cur;
if(len > 1)
{
string tmp(cur,len);

for(int i=0;i<str.size();i++)
if(tmp == str[i])
flag = true;
if(flag != true)
str.push_back(tmp);
}

//sort
sort(str.begin(),str.end(),myfunction);
//拼接字符串
*output='\0';
int i;
for(i=0;i<str.size()-1;i++)
{
strcpy(output+strlen(output),(str[i]+" ").c_str());

}
strcpy(output+strlen(output),(str[i]).c_str());
cout<<output<<endl;
}

int main()
{

char input[]="some ninja local buses, a bd b c d somes1234123drivers";
char output[500];
my_word(input, output);

return 0;
}

///注意char**指针的传递

通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符

过滤掉。比如字符串"abacacde"过滤结果为"abcde"。
要求实现函数： void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);
【输入】 pInputStr：  输入字符串
lInputLen：  输入字符串长度
【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例
输入："deefd"        输出："def"
输入："afafafaf"     输出："af"
输入："pppppppp"     输出："p"
//20:29 2013/7/24
// main函数已经隐藏，这里保留给用户的测试入口，在这里测试你的实现函数，可以调用printf打印输出
// 当前你可以使用其他方法测试，只要保证最终程序能正确执行即可
// 该函数实现可以任意修改，但是不要改变函数原型。一定要保证编译运行不受影响
void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr)
{
}
*/

#include "iostream"
#include "cstring"
#include "malloc.h"
using namespace std;

char* stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr)
{
char *cur = NULL;
char *r = pOutputStr;
*pOutputStr='\0';
while(*pInputStr != '\0')
{
cur = pOutputStr;
while(*cur != '\0')
{
if(*cur == *pInputStr)
break;
cur++;
}
if(*cur == '\0')
*(r++) = *(pInputStr++);
else
pInputStr++;
}
*r='\0';
return pOutputStr;
}

int main()
{
//const char*a[]=="aabfcadfakeafccdede";
char*a="aabfcadfakeafccdede";
cout<<"过滤前字符串："<<a<<endl;

long len=strlen(a);
char *b=(char*)malloc(len*sizeof(char));
b=stringFilter(a,len,b);
cout<<"过滤后字符串：";
cout<<b<<endl;
return 0;
}

//filter程序
int main()
{
string s;
cin>>s;
int len=s.size();
int a[200]={0};
char b[200]={'0'};
int j=0;

for (int i=0;i<len;i++)
{
if (a[s[i]-'0']==0)
{
b[j]=s[i];
j++;
a[s[i]-'0']=1;
}
else
continue;
}
for (int i=0;i<j;i++)
{
cout<<b[i];
}
cout<<endl;
return 0;
}

/*通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，
并输出压缩后的字符串。
压缩规则：
1. 仅压缩连续重复出现的字符。比如字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc".
2. 压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz"

要求实现函数：
void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr);

【输入】 pInputStr： 输入字符串
lInputLen： 输入字符串长度
【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；
*/
#include <stdio.h>
#include<string.h>
#include<malloc.h>

void stringZip(const char *p_str, long len, char *p_outstr)
{
int count=1;
for(int i=0;i<len;i++)
{
if(p_str[i]==p_str[i+1])
{
count++;
}
else
{
if(count>1)
{
*p_outstr++ = count +'0';
*p_outstr++ =p_str[i];
}
else
{
*p_outstr++ =p_str[i];
}
count = 1;//注意其位置
}
}
*p_outstr = '\0';
}

void main()
{
char *str = "cccddeccffgghhhhjhkk";
printf("压缩之前的字符串为：%s\n",str);
int len = strlen(str);
char * outstr = (char*)malloc(len*sizeof(char));
stringZip(str,len,outstr);
printf("压缩之后的字符串为：%s\n",outstr);
free(outstr);
outstr = NULL;
}

//map<char ,int>实现字符压缩程序
/*
int main()
{
map<char,int> zip;
map<char,int>::iterator it;

string s;
cin>>s;
int len=s.size();

for (int i=0;i<len;i++)
{
it=zip.find(s[i]);
if (it==zip.end())
{
zip[s[i]]=1;
}
else
{
int t= it->second;
zip.erase(it);
zip[s[i]]=t+1;

}
}
for (it=zip.begin();it!=zip.end();it++)
{
cout<<it->second<<it->first<<"  ";
}
cout<<endl;
return 0;
}*/

/////////////////////////////////////////////////////
//删除要查找的字符串，并返回删除次数
int delete_sub_str(char *input,char *sub_str,char *result){
int count=0;
int len = strlen(sub_str);
char *p = result;

while(*input != '\0'){
int i=0;
for(;i<len;i++){
*p = *input;
if(*input != *(sub_str+i)){
p++;
input++;
break;;
}
p++;
input++;
}

if(i == len){
p = p-len;
count++;
}

}
*p='\0';
return count;
}

/////////////////////////////////////////////////
///////////////字串分离，并以逗号隔开

#include "iostream"
#include "cstring"
#include "malloc.h"
using namespace std;

void DivideString(const char* pInputStr , long lInputLen , char* pOutputStr)
{
int i , j;
bool flag;
for(i = 0 ; pInputStr[i] == ' ' ; ++i)   //跳过字符串前面的空格
;
flag = true;
for(j = 0 ; i < lInputLen ; ++i)
{
if(pInputStr[i] != ' ')
{
if(!flag)
flag = true;
pOutputStr[j++] = pInputStr[i];    //将各个子串分离保存下来
}
else
{
if(flag)
pOutputStr[j++] = ',';
flag = false;
}
}
pOutputStr[j++] = ',';
pOutputStr[j++] = '\0';
}

int main()
{
char *input="abcd efg hijkl mn opq      china";
int len=strlen(input);
char* output=(char*)malloc(len*sizeof(char));
DivideString(input,len,output);
cout<<output<<endl;
return 0;
}

//filter 的牛逼写法
void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr)
{
int a[26] = {0};
int pos = 0;
long i, j;
const char *p = pInputStr;
for(i = 0, j = 0; i < lInputLen; i++)
{
pos = pInputStr[i] - 'a'; //将出现的字符标记为1，下次出现同样的字符时就不再存储
if(a[pos] == 0)
{
a[pos]++;
pOutputStr[j++] = pInputStr[i];
}
}

pOutputStr[j] = '\0';
}

//压缩程序的牛逼写法
void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr)
{
int i, j, k = 0, cnt = 0;
char buffer[30];

for(i = 0; i < lInputLen;)
{
for(j = i + 1;;j++)
{
if(pInputStr[j] == pInputStr[i])
cnt++;
else
break;
}

if(cnt != 0)
{
memset(buffer, 0, sizeof(buffer));
itoa(cnt + 1, buffer, 10);
strcat(pOutputStr, buffer);
k += strlen(buffer);
i += cnt;
}
pOutputStr[k++] = pInputStr[i++];
cnt = 0;
}
}

//阿里巴巴第一题字符串查找
#include <stdio.h>
#include <string.h>

int FindQueryInText( char query[], char text[]);     //查找长度函数
void GetQuery( char sourcequery [], char densquery[],int startIndex,int querylength );//从指定位置读取指定长度的到目的字符串中

void main()          //测试main函数
{
int length = 0;               //运算结果长度
char query[] = "acbac";       //初始化字符串
char text[] = "acaccbabb";    //初始化被查找字符串

length = FindQueryInText( query,text);  //调用函数给出结果
printf("%d",length);
}

int FindQueryInText( char query[], char text[])
{
int querylength = 0,textlength = 0;
int i = 0,j=0;
char comparequery[100] = {0};
char *pqueryPosition = NULL;

querylength = strlen(query);
textlength = strlen(text);

for(i = querylength;i>0;i--)          //循环querylength次，依次查找是否有字符串
{
for(j = 0;j<querylength-i+1;j++)  //每次查找要从query中取querylength-i次
{
GetQuery(query,comparequery,j,i); //每次比较从query中取出i个字符，进行比较
pqueryPosition=strstr(text,comparequery);//比较，若是text中用comparequery中，则返回非NULL指针。
if (pqueryPosition != NULL)
{
break;
}
}
if (pqueryPosition != NULL)
{
break;
}
}
return i;
}

void GetQuery( char sourcequery [], char densquery[],int startIndex,int querylength )
{
int i = 0;
for (i = 0;i < querylength;i ++ )
{
densquery[i] = sourcequery[i+startIndex];
}
densquery[querylength] = '\0';
}

//写法二阿里巴巴第一题
#include <stdio.h>
#include <string.h>
using namespace std;

#define qurey "acbac"
#define text  "acaccbabb"
#define N 10002

int c

;

int STRICT_LCS_LENGTH(char *X, char *Y,int m,int n)
{
int i,j,max=0;
for ( i = 0;i < m;i++)
c[i][0] = 0;

for ( j = 0;j < n;j++)
{c[0][j] = 0;}

for( i = 0;i < m;i++){
for ( j = 0;j < n;j++){
if (X[i] == Y[j])
{
c[i][j] = c[i-1][j-1]+1;
if(c[i][j] > max)
max = c[i][j];
}
else
c[i][j] = 0;
}
}
return max;
}

int main(){

char a
= qurey;
char b
= text;
int m = strlen(a);
int n = strlen(b);
int len = STRICT_LCS_LENGTH(a,b,m,n);
printf("%d\n",len);

}

//西安交大第一题，第二字符串补齐到第一字符串（定长）并输出
/*
给定三个参数，src，len，str，其中src，和str为字符窜，将str中内容补齐到src后，补齐后总长为len
如输入：src="abc",str="12345" len=8   输出：abc12345;
如输入：src="abc",str="1234567" len=8   输出：abc12345;
如输入：src="abc",str="12" len=8   输出：abc12121;
*/
#include "iostream"
#include "cstring"
using namespace std;

int main()
{
char src[100],str[100];
cin>>src>>str;

int src_len=strlen(src);
int str_len=strlen(str);
/*  方法一
if (str_len>=8-src_len)
{
str[8-src_len]='\0';
strcat(src,str);
}
else if (str_len<8-src_len)
{
int j=8-src_len;
for (int i=0;i<j;i++)
{
int n=i;
n=n%str_len;
src[src_len+i]=str
;
}
src[8]='\0';

}
*/
//方法二
int j=8-src_len;
for (int i=0;i<j;i++)
{
int n=i;
n=n%str_len;
src[src_len+i]=str
;
}
src[8]='\0';

cout<<src<<endl;

return 0;
}

//西安交大第二题国名排序
#include "iostream"
#include "cstring"
#include "string"
using namespace std;

int main()
{
string s[5];
for (int i=0;i<5;i++)
{
cin>>s[i];
}

for (int i=0;i<5;i++)
{
for (int j=i+1;j<5;j++)
{
if (s[i]>s[j])
{
swap(s[i],s[j]);
}
}
}
for (int k=0;k<5;k++)
{
cout<<s[k]<<" ";
}
cout<<endl;

return 0;
}

/*******函数实现选择法排序数组*************\
int main()
{
void select_sort(int array[],int n);
int a[10]={12,43,34,6,73,123,123,45,2354,2};
select_sort(a,10);
for (int i=0;i<10;i++)
{
cout<<a[i]<<endl;
}
return 0;
}

void select_sort(int array[],int n)
{
int i,j,k,t;
for (i=0;i<n-1;i++)
{
k=i;
for (j=i+1;j<n;j++)
{
if(array[j]<array[k])
k=j;
t=array[k];
array[k]=array[i];
array[i]=t;
}
//return;
}
}

将整数倒序输出，剔除重复数据
输入一个整数，如12336544，或1750，然后从最后一位开始倒过来输出，
最后如果是0，则不输出，输出的数字是不带重复数字的，所以上面的输出是456321和571。
如果是负数，比如输入-175，输出-571。
*/

#include "iostream"
using namespace std;

int main()
{
int Num,n[50],a[10]={0},temp,i=0,flag=0;
char c;
scanf("%c%d",&c,&Num);

while (Num>0)
{
temp=Num%10;
if (a[temp]==0)
{
a[temp]=1;
n[i]=temp;
i++;
}
Num=Num/10;
}
if(c=='-') printf("%c",c);
for (temp=0;temp<i;temp++)
{
if ((n[temp]!=0)||flag!=0)
{
printf("%d",n[temp]);
flag=1;
}
}
if(c!='-') printf("%d",(int)c-48);
return 0;
}

整数化为2进制数，并逆序输出
*/

#include "iostream"
using namespace std;

int main()
{
int m;
cout<<"输入要转化的正整数：";
cin>>m;
int a[32]={0},i=0,j;
while (m>0)
{
a[i]=m%2; //如果转换成16进制，可以将m改为
//M[m%16]的表，M表中存0~F字符
//并且a[]也要定义成char型数据
i++;
m/=2;
}
for (j=0;j<i;j++)
{
cout<<a[j];
}
cout<<"正序为：";
for (j=i-1;j>=0;j--)
{
cout<<a[j];
}
return 0;
}

//一串字符串分成多字子串，以空格隔开
#include "iostream"
#include "string.h"
#include "stdlib.h"
using namespace std;

int main()
{
char a[]="abcd,efg Hijk/lmnop0qrst Uvwxyz";
char b[]="def";
int len=strlen(a);

for (int i=0;i<len;i++)
{
if (a[i]<'A' || (a[i]>'Z'&&a[i]<'a') || a[i]>'z')
{
a[i]=',';
}
}
char *p;
char except[]=",";
int j=0;
char *word[100];
p=strtok(a,except);
while (p!=NULL)
{
word[100]=p;
cout<<p<<endl;
p=strtok(NULL,except);
cout<<"word"<<j<<"wei:"<<word<<endl;
}

大数相减
输入两行字符串正整数，第一行是被减数，第二行是减数，输出第一行减去第二行的结果。
备注：1、两个整数都是正整数，被减数大于减数
示例：
输入：1000000000000001
1
输出：1000000000000000
注意大数用char a[] 存储，用%s接收，一位一位的运算。注意a[0]里的正负号。
*/

#include "iostream"
using namespace std;
int main()
{
char s1[1010]={'\0'},s2[1010]={'\0'};
scanf("%s%s",&s1,&s2);
int len1=strlen(s1),len2=strlen(s2),i,j,m1,m2,f=0;
int answer[1010],k=0;
for (i=len1-1,j=len2-1;i>=0;i--,j--)
{
m1=(int)s1[i]-48;
if(j>=0) m2=(int)s2[j]-48;
else m2=0;
if(f==1) //先判断是否有借位，然后在计算m1-m2
{
m1=m1-1;f=0;
}
if(m1>=m2) {answer[k++]=m1-m2;f=0;}
else {answer[k++]=m1+10-m2;f=1;}
}
int t=0;//帮助判断高位是否为0
for (k=k-1;k>=0;k--)
{
if(t==0&&answer[k]==0) continue;
else {t=1;printf("%d",answer[k]);}
}
return 0;
}

将 电话号码 one two 。。。nine zero
翻译成1  2 。。9 0

中间会有double

例如输入：OneTwoThree
输出：123
输入：OneTwoDoubleTwo
输出：1222
输入：1Two2 输出：ERROR
输入：DoubleDoubleTwo 输出：ERROR
第三题：有空格，非法字符，两个Double相连，Double位于最后一个单词 都错误
*/

#include "iostream"
using namespace std;

int main()
{
char a[11][11]={"zero","one","two","three","four","five",
"six","seven","eight","nine","double"};
char temp[11];
char c=' ';
int i,d=0,f;

cout<<"输入数字格式如（one two double three）:";
while (c!='\n')
{
scanf("%s%c",&temp,&c);
f=0;
for (i=0;i<11;i++)
{
if (!strcmp(temp,a[i])&&i<10)
{
printf("%d",i);
f=1;
if (d==1)
{
printf("%d",i);
d=0;
}
}
else if (!strcmp(temp,a[i])&&i==10)
{
d=1;
f=1;
}
}
if(f==0) break;
}
printf("\n");
if (d==1||f==0)
printf("Error\n");

return 0;
}

字符串M化成以N为单位的段
输入m个字符串 和一个整数n, 把字符串M化成以N为单位的段，不足的位数用0补齐。
如 n=8 m=9 ，
123456789划分为：12345678
90000000
123化为 ：12300000
*/

#include "iostream"
using namespace std;

int main()
{
int m,n;
char str[100]={'\0'};
int len;
int yu,shang;

printf("输入字符窜字符个数：");
scanf("%d",&m);

scanf("%s",&str);
len=strlen(str);

printf("输入n的值：");
scanf("%d",&n);

yu=len%n;

for (int i=0;i<len;i++)
{
if(i%n==0)
printf("\n%c",str[i]);
else
printf("%c",str[i]);
}

if (yu==0)
;
else
{
for(int i=yu+1;i<=n;i++)
printf("0");
printf("\n");
}

return 0;
}

//子串合并
/*
int main()
{
char *c="   abc def gh i      d";
int len =strlen(c);
char *out=(char*)malloc(len*sizeof(char));
bool flag;
int j;
int i;
for (i=0;c[i]==' ';i++)
;

for (j=0;i<len;i++)
{
if (c[i]!=' ')
{
flag=true;
out[j++]=c[i];
}
else
{
if(flag)
out[j++]=',';
flag=false;
}
}
out[j++]=',';
out[j++]='\0';
for (int i=0;i<j;i++)
{
cout<<out[i];
}

cout<<endl;
return 0;
}*/

//strstr的实现写法
#include "iostream"
using namespace std;

char* strstra(const char* src,const char* pat)
{
char* temp1= (char*)src;
char* temp2= (char*)pat;
char *temp3;
if(!*temp2)
return temp1;
while(*temp1!='\0')
{
temp3 =  temp1;
while(*temp3 && *temp2 && !(*temp1-*temp2))
{
temp3++;
temp2++;
}
if(!*temp2)
return temp1;
temp1++;
}
return NULL;
}

int main()
{
char *s1="abcdefj";
char *s2="def";
char*c=strstra(s1,s2);
cout<<c<<endl;
return 0;
}

//10进制转换成x进制
/***************\
int x=8;
int i=0;
char num[100]={0};
int number;
cin>>number;
while (number!=0)
{
if ((number%x)>=10&&(number%x<=15))
{
num[i]=(char)((number%x)+55);//10-x转换
i++;
number/=x;
}
else if (number%x<10)
{
num[i]=(number%x)+'0';//10-x转换
i++;
number/=x;
}
}
for (int j=i-1;j>=0;j--)//按阅读习惯输出
{
cout<<num[j];
}
\**************************/

/****\
//x-10转换
string s;
cin>>s;
double num=0;
double x=2;

int len=s.size();

char c=9;//可以直接将 9 赋值给char，此时cout<<c 无输出显示空白
cout<<c<<endl;
int a=(c-'0')*2;//字符可以直接参与运算并赋值给整型数据的
cout<<a<<endl;

double j=0;
for (int i=len-1;i>=0;i--)  //字符串输入，借助pow函数完成x-10的转换，注意pow的数据和返回值都是double型
{
if (s[i]>='A'&&s[i]<='F')
{
num=num+((s[i]-'A')+10)*pow(x,j);
j++;
}
else if (s[i]>='a'&&s[i]<='f')
{
num=num+((s[i]-'a')+10)*pow(x,j);  //可以用数学函数pow，但要求是double型数据
j++;
}
else if (s[i]>='0'&&s[i]<='9')
{
num=num+(s[i]-'0')*pow(x,j);  //可以用数学函数pow，但要求是double型数据
j++;
}
}
cout<<num;

/////菲薄拉塞序列输出
cout<<"******************************************加强版Fibonacci数序写法"<<endl;
//int main()
{
int i;
int f[20]={1,1};
for (i=2;i<20;i++)
{
f[i]=f[i-1]+f[i-2];
}
for (i=0;i<20;i++)
{
if(i%4==0) cout<<endl;
cout<<setw(8)<<f[i];
}
cout<<endl;
}

/////////////////////////////列车站台问题
/*
#include<stdio.h>
#include<string>
#include<queue>
#include<vector>
using namespace std;

#define MAX 35
#define SUBWAY_A 20
#define SUBWAY_B 15
typedef struct node{
int adjvex;
struct node *next;
}edgenode;
typedef struct{
char name[10];
bool flag;
edgenode *link;
}vexnode;

const char subway_name1[SUBWAY_A][10]={"A1","A2","A3","A4","A5","A6","A7","A8","A9","T1","A10","A11","A12","A13","T2","A14","A15","A16","A17","A18"};
const char subway_name2[SUBWAY_B][10]={"B1","B2","B3","B4","B5","B6","B7","B8","B9","B10","B11","B12","B13","B14","B15"};
void creat(vexnode ga[]){
int i;
edgenode *p;
for(i=0;i<MAX;i++){
ga[i].link=NULL;
ga[i].flag=true;
if(i<SUBWAY_A) strcpy(ga[i].name,subway_name1[i]);
else strcpy(ga[i].name,subway_name2[i-20]);
}
//A地铁建邻接表
for(i=1;i<SUBWAY_A-1;i++){
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=i-1;
p->next=NULL;
ga[i].link=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=i+1;
p->next=NULL;
ga[i].link->next=p;
if(i==9){
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+4;
p->next=NULL;
ga[i].link->next->next=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+5;
p->next=NULL;
ga[i].link->next->next->next=p;
}
else if(i==14){
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+9;
p->next=NULL;
ga[i].link->next->next=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+10;
p->next=NULL;
ga[i].link->next->next->next=p;
}
}
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A-1;
p->next=NULL;
ga[0].link=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=1;
p->next=NULL;
ga[0].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A-2;
p->next=NULL;
ga[SUBWAY_A-1].link=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=0;
p->next=NULL;
ga[SUBWAY_A-1].link->next=p;

//B地铁建邻接表
for(i=1;i<SUBWAY_B-1;i++){
if(i==4||i==5||i==9||i==10) continue;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+i-1;
p->next=NULL;
ga[i+SUBWAY_A].link=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+i+1;
p->next=NULL;
ga[i+SUBWAY_A].link->next=p;
}
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+3;
p->next=NULL;
ga[SUBWAY_A+4].link=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=9;
p->next=NULL;
ga[SUBWAY_A+4].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=9;
p->next=NULL;
ga[SUBWAY_A+5].link=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+6;
p->next=NULL;
ga[SUBWAY_A+5].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+8;
p->next=NULL;
ga[SUBWAY_A+9].link=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=14;
p->next=NULL;
ga[SUBWAY_A+9].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=14;
p->next=NULL;
ga[SUBWAY_A+10].link=p;
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+11;
p->next=NULL;
ga[SUBWAY_A+10].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+1;
p->next=NULL;
ga[SUBWAY_A].link=p;

p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=SUBWAY_A+SUBWAY_B-2;
p->next=NULL;
ga[SUBWAY_A+SUBWAY_B-1].link=p;
//  打印各邻接节点
for(i=0;i<MAX;i++){
printf("%s:",ga[i].name);
edgenode *s;
s=ga[i].link;
while(s!=NULL){
printf("->%s",ga[s->adjvex].name);
s=s->next;
}
printf("\n");
}

}
int main(){
vexnode ga[MAX];
creat(ga);
int i;
char str[2][10];
while(scanf("%s%s",str[0],str[1])!=EOF){
int temp=0;
for(i=0;i<MAX;i++){
ga[i].flag=true;
if(!strcmp(str[0],ga[i].name)) temp=i;
}
queue<vexnode>q;
q.push(ga[temp]);
ga[temp].flag=false;
int count=0;
int start=0;
int end=1;
bool find_flag=false;
while(!q.empty()){
if(find_flag) break;
count++;
printf("************************\n");
printf("第%d层搜索：",count);
int temp_end=end;
while(start<temp_end){
printf("%s ",q.front().name);
if(!strcmp(q.front().name,str[1])){
find_flag=true;
break;
}
edgenode *s;
s=q.front().link;
while(s!=NULL){
if(ga[s->adjvex].flag){
q.push(ga[s->adjvex]);
ga[s->adjvex].flag=false;
end++;
//printf("%s ",ga[s->adjvex].name);
}
s=s->next;
}
q.pop();
start++;
}
printf("\n");
}
printf("%d\n",count);
}
return 0;
}
*/

//写法二站台问题

#include <cstdlib>
#include <iostream>
#include <string>

/*
Author : 俗人
Time ： 2013/9/2
description : 地铁换乘问题

已知2条地铁线路,其中A为环线,B为东西向线路,线路均为双向,
换乘点为 T1,T2,编写程序,任意输入两个站点名称,输出乘坐地铁
最少所需要经过的车站数量

A(环线):A1...A9 T1 A10...A13 T2 A14...A18
B(直线):B1...B5 T1 B6...B10 T2 B11...B15

样例输入:A1 A3
样例输出:3

*/

using namespace std;

//无向图的数据结构
struct Graph
{
int arrArc[100][100];  //邻接矩阵
int verCount;  //点数
int arcCount;  //边数
};

//FLOYD算法 求任意两点最短路径矩阵
void floyd(Graph *p,int dis[100][100]){

for(int k = 1;k <= p->verCount;k++)
for(int i = 1; i <= p->verCount;i++)
for(int j = 1;j <= p->verCount;j++)
{
//存在更近的路径，则更新
if(dis[i][j]>dis[i][k]+dis[k][j])
dis[i][j]=dis[i][k]+dis[k][j];
}

}

//站名字符串转节点编号
int  char_to_int(string s){

string s1[38] = {"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","A10",
"A11","A12","A13","A14","A15","A16","A17","A18",
"B1","B2","B3","B4","B5","B6","B7","B8","B9","B10",
"B11","B12","B13","B14","B15","T1","T2"} ;

for(int i=1 ; i <= 38;i ++){
if (s == s1[i])
return i;
}

return -1;
}

int main(int argc, char *argv[])
{
Graph g;

g.verCount = 37;
g.arcCount = 36;

cout<<"number of ver:"<<g.verCount<<" number of arc:" <<g.arcCount<<endl;

//初始化邻接矩阵
for(int i = 1;i<=g.verCount;i++)
{ for(int j = 1;j<=g.verCount;j++)
{
//i到本身的距离为0
//不同节点值为不可达
if(i==j) g.arrArc[i][i]= 0;
else
g.arrArc[i][j] = 65535;
}
}

//输入A环线个点相连情况 每个边权重都为1
int a[21] = {1,2,3,4,5,6,7,8,9,34,10,11,12,13,35,14,15,16,17,18,1};
for(int i=0;i<20;i++)
{
g.arrArc[a[i]][a[i+1]] = 1;
g.arrArc[a[i+1]][a[i]] = 1;
}

//输入B线个点相连情况 每个边权重都为1
int b[17] = {19,20,21,22,23,34,24,25,26,27,28,35,29,30,31,32,33};
for(int i=0;i<16;i++)
{
g.arrArc[b[i]][b[i+1]] = 1;
g.arrArc[b[i+1]][b[i]] = 1;
}

//计算邻接矩阵
floyd(&g,g.arrArc);

cout << "请输入起始站点与终点:" <<endl;
string start;
string end;
cin >> start >> end;
cout << g.arrArc[char_to_int(start)][char_to_int(end)]+1 <<endl;

system("PAUSE");
return EXIT_SUCCESS;
}

//两个正整数相减或相加并输出结果
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXCHAR 256

//必须规定均为小写字母
void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr)
{
int a[26] = {0};
int pos = 0;
long i, j;
const char *p = pInputStr;
for(i = 0, j = 0; i < lInputLen; i++)
{
pos = pInputStr[i] - 'a'; //将出现的字符标记为1，下次出现同样的字符时就不再存储
if(a[pos] == 0)
{
a[pos]++;
pOutputStr[j++] = pInputStr[i];
}
}

pOutputStr[j] = '\0';
}

void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr)
{
int i, j, k = 0, cnt = 0;
char buffer[30];

for(i = 0; i < lInputLen;)
{
for(j = i + 1;;j++)
{
if(pInputStr[j] == pInputStr[i])
cnt++;
else
break;
}

if(cnt != 0)
{
memset(buffer, 0, sizeof(buffer));
itoa(cnt + 1, buffer, 10);
strcat(pOutputStr, buffer);
k += strlen(buffer);
i += cnt;
}
pOutputStr[k++] = pInputStr[i++];
cnt = 0;
}
}

void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr)
{
int i, cnt = 0, a, b, result;
char ch[1] = {'0'};
char op1[MAXCHAR], op[MAXCHAR], op2[MAXCHAR], buffer[4];
for(i = 0; i < lInputLen; i++)
if(pInputStr[i] == ' ')
cnt++;

if(cnt != 2)                    //空格数不等于2
{
strcat(pOutputStr, ch);
return;
}

sscanf(pInputStr, "%s %s %s", op1, op, op2);

if(strlen(op) > 1 || (op[0] != '+' && op[0] != '-'))        // 操作符有多个
{
strcat(pOutputStr, ch);
return;
}

for(i = 0; i < strlen(op1); i++)                            //操作数1是否有其他字符
{
if(op1[i] < '0' || op1[i] > '9')
{
strcat(pOutputStr, ch);
return;
}
}

for(i = 0; i < strlen(op2); i++)                            //操作数2是否有其他字符
{
if(op2[i] < '0' || op2[i] > '9')
{
strcat(pOutputStr, ch);
return;
}
}

a = atoi(op1);
b = atoi(op2);

switch(op[0])
{
case '+':
result = a + b;
itoa(result, buffer, 10);
strcat(pOutputStr, buffer);
break;
case '-':
result = a - b;
itoa(result, buffer, 10);
strcat(pOutputStr, buffer);
break;
default:
break;
}
}

int main()
{
char pInputStr1[] = {"aaabbbcccdde"};
char pInputStr2[] = {"aaabbcddde"};
char pInputStr3[] = {"3 + 4"};
char pOutputStr1[MAXCHAR] = {0};
char pOutputStr2[MAXCHAR] = {0};
char pOutputStr3[MAXCHAR] = {0};

/* TODO: 调用被测函数 */
stringFilter(pInputStr1, strlen(pInputStr1), pOutputStr1);
stringZip(pInputStr2, strlen(pInputStr2), pOutputStr2);
arithmetic(pInputStr3, strlen(pInputStr3), pOutputStr3);

/* TODO: 执行完成后可比较是否是你认为正确的值 */
printf(pOutputStr1); //abcde
cout<<endl;
printf(pOutputStr2); //3a3b3c2de
cout<<endl;
printf(pOutputStr3); //7
cout<<endl;
return 0;
}